转载

【java实例】自己动手实现IOC和MVC（四）

现在我要进行实例化的信息都收集起来，然后进行实例化了 问题？ ①怎么进行实例化？ 这时候我要用到我们收集的class的信息类的List，进行循环 ，然后利用Java反射机制进行实例化操作 下面一段伪代码：
  1. List<BeanDefinition> beanDefinitions = BeandefinitionList.getBeanDefinitions();
  2.      if(beanDefinitions!=null && !beanDefinitions.isEmpty()){
  3.             for(BeanDefinition bd:beanDefinitions){
  4.                 if(bd!=null){
  5.                     //初始化bean
  6.                     //然后是存储bean
  7.                 }
  8.             }
  9.     }
  ②怎么进行注入？ 也是循环List<BeanDefinition> ，然后循环BeanDefinition里面的属性集合，接着利用java反射调用set方法进行注入操作
  1. List<BeanDefinition> beanDefinitions = BeandefinitionList.getBeanDefinitions();
  2.         for(BeanDefinition bd : beanDefinitions){
  3.             Object bean =获得实例化后的bean根据id
  4.             List<PropertyDefinition> pds = bd.getProperties();
  5.             if(pds!=null && !pds.isEmpty()){
  6.                 for(PropertyDefinition pd:pds){
  7.                     String name = pd.getName();
  8.                     String ref = pd.getRef();
  9.                     if(ref!=null && !"".equals(ref)){
  10.                         //这里会进行属性的注入操作
  11.                     }
  12.                 }
  13.             }
  14.         }
②实例化之后放在哪里？ 会放在一个Map里 ，供我们以后进行使用 这里我们提供一个类用于对这个Map的操作 ，具体实现如下：
  1. package com.ajunframework.beans.factory;
  3. import java.util.HashMap;
  4. import java.util.Map;
  6. /**
  7.  * 存储bean
  8.  * @author harries
  9.  *
  10.  */
  11. public class BeanMap {
  13.     private static Map<String,Object> beans = new HashMap<String,Object>();
  15.     private BeanMap(){}
  16.     /**
  17.      * 添加bean
  18.      * @param beanName
  19.      * @param value
  20.      */
  21.     public  static void put(String beanName ,Object value){
  22.         beans.put(beanName, value);
  23.     }
  25.     /**
  26.      * 获得bean
  27.      * @param beanName
  28.      * @return
  29.      */
  30.     public static Object getBean(String beanName){
  31.         if(!beans.isEmpty()){
  32.             return beans.get(beanName);
  33.         }
  34.         return new HashMap<String,Object>();
  35.     }
  37.     public static Map<String,Object> getBeanMap(){
  38.         return beans;
  39.     }
  40. }
此时提供了一个BeanFactory interface 用于我们扩展 对beanMap的操作
  1. package com.ajunframework.beans.factory;
  3. /**
  4.  *bean工厂
  5.  * @author harries
  6.  * @http://www.liuhaihua.cn
  7.  */
  8. public interface BeanFactory {
  10.     /**
  11.      * 设置bean
  12.      * @param beanName 
  13.      * @param fullClassName
  14.      */
  15.      void setBean(String beanName,String fullClassName);
  16.     /**
  17.      * 获得bean根据beanName
  18.      * @param name
  19.      * @return
  20.      */
  21.     Object getBean(String name);
  23.     <T> T getBean(String name, Class<T> requiredType);
  25.     <T> T getBean(Class<T> requiredType);
  27.     Object getBean(String name, Object... args);
  29.     boolean containsBean(String name);
  31.     boolean isSingleton(String name);
  33.     boolean isPrototype(String name);
  35.     @SuppressWarnings("unchecked")
  36.     boolean isTypeMatch(String name, Class targetType);
  38.     Class<?> getType(String name);
  40.     String[] getAliases(String name);
  42. }
下面是实现类 AnnotationBeanFactory.java
  1. package com.ajunframework.beans.factory;
  4. import com.ajunframework.beans.annotation.Action;
  5. import com.ajunframework.beans.annotation.Dao;
  6. import com.ajunframework.beans.annotation.Scope;
  7. import com.ajunframework.beans.annotation.Service;
  8. import com.ajunframework.beans.constant.BeanScop;
  9. import com.ajunframework.beans.utils.BeanUtils;
  11. /**
  12.  * bean工厂
  13.  * @author harries
  14.  * @http://www.liuhaihua.cn
  15.  */
  16. public class AnnotationBeanFactory implements BeanFactory {
  18.     private static AnnotationBeanFactory beanFactory = new AnnotationBeanFactory();
  20.     private AnnotationBeanFactory(){}
  22.     public static AnnotationBeanFactory getBeanFactory(){
  23.         if(beanFactory!=null){
  24.             return beanFactory;
  25.         }
  26.         return new AnnotationBeanFactory();
  27.     }
  29.     public void setBean(String beanName,String fullClassName) {
  30.         try {
  31.             Object bean = BeanUtils.instanceClass(Class.forName(fullClassName));
  32.             BeanMap.put(beanName, bean);
  33.         } catch (ClassNotFoundException e) {
  34.             e.printStackTrace();
  35.         }
  37.     }
  39.     public boolean containsBean(String name) {
  40.         Object bean = BeanMap.getBeanMap().get(name);
  41.         if(bean!=null){
  42.             return true;
  43.         }
  44.         return false;
  45.     }
  48.     public Object getBean(String name) {
  49.         return BeanMap.getBeanMap().get(name);
  50.     }
  52.     @SuppressWarnings("unchecked")
  53.     public <T> T getBean(String name, Class<T> requiredType) {
  54.         Object bean = BeanMap.getBeanMap().get(name);
  55.         if(bean!=null){
  56.             Class<?> clazz = bean.getClass();
  57.             if(clazz.getName().equals(requiredType.getName()) ){
  58.                 return (T)bean;
  59.             }
  60.         }
  61.         return null;
  62.     }
  64.     @SuppressWarnings("unchecked")
  65.     public <T> T getBean(Class<T> requiredType) {
  66.         if(requiredType.isAnnotationPresent(Dao.class) || requiredType.isAnnotationPresent(Service.class) || requiredType.isAnnotationPresent(Action.class)){
  67.             String fullName = requiredType.getName();
  68.             String beanName = fullName.substring(fullName.lastIndexOf(".")+1).substring(0,1).toLowerCase()+ fullName.substring(fullName.lastIndexOf(".")+1).substring(1);
  69.             Object bean = BeanMap.getBeanMap().get(beanName);
  70.             return (T)bean;
  71.         }
  73.         return null;
  74.     }
  76.     public Object getBean(String name, Object... args) {
  78.         return null;
  79.     }
  81.     public Class<?> getType(String name) {
  82.         Object bean = BeanMap.getBeanMap().get(name);
  83.         if(bean!=null){
  84.             bean.getClass().getClass();
  85.         }
  86.         return null;
  87.     }
  89.     @SuppressWarnings("unchecked")
  90.     public boolean isPrototype(String name) {
  91.         Object bean = BeanMap.getBeanMap().get(name);
  92.         if(bean!=null){
  93.             Class clazz = bean.getClass();
  94.             if(clazz.isAnnotationPresent(Scope.class)){
  95.                 String scopeValue = ((Scope) clazz.getAnnotation(Scope.class)).value();
  96.                 if(scopeValue!=null && BeanScop.PROTOTYPE.equals(scopeValue.trim())){
  97.                     return true;
  98.                 }
  99.             }
  100.         }
  102.         return false;
  103.     }
  105.     @SuppressWarnings("unchecked")
  106.     public boolean isSingleton(String name) {
  107.         Object bean = BeanMap.getBeanMap().get(name);
  108.         if(bean!=null){
  109.             Class clazz = bean.getClass();
  110.             if(clazz.isAnnotationPresent(Scope.class)){
  111.                 String scopeValue = ((Scope) clazz.getAnnotation(Scope.class)).value();
  112.                 if(scopeValue!=null && BeanScop.SINGLETON.equals(scopeValue.trim())){
  113.                     return true;
  114.                 }else if(scopeValue!=null && BeanScop.PROTOTYPE.equals(scopeValue.trim())){
  115.                     return false;
  116.                 }else{
  117.                     return true;
  118.                 }
  119.             }else{
  120.                 return true;
  121.             }
  122.         }
  123.         return false;
  124.     }
  126.     @SuppressWarnings("unchecked")
  127.     public boolean isTypeMatch(String name, Class targetType) {
  128.         Object bean = BeanMap.getBeanMap().get(name);
  129.         if(bean!=null){
  130.             Class clazz = bean.getClass();
  131.             if(clazz.equals(targetType)){
  132.                 return true;
  133.             }
  134.         }
  135.         return false;
  136.     }
  138.     public String[] getAliases(String name) {
  139.         return null;
  140.     }
  142. }
下面给出上面整个过程的代码: 初始化上下文bean 接口
  1. package com.ajunframework.beans.applicationContext;
  4. /**
  5.  * 初始化上下文bean 接口
  6.  * @author harries
  7.  * @http://www.liuhaihua.cn
  8.  */
  9. public interface  ClassPathApplicationContext {
  11.     /**
  12.      * instance bean
  13.      */
  14.      void instanceBean();
  17.     /**
  18.      * DI bean
  19.      */
  20.      void injectObject();
  22.     /**
  23.      * read class‘s Annotation info to instance definitionBean
  24.      */
  25.      void readAnnotationCLass();
  27.      /**
  28.       * 初始化
  29.       */
  30.      void init();
  31. }
基于注释的上下文实例化bean类 AnnotationClassPathApplicationContext.java
  1. package com.ajunframework.beans.applicationContext;
  4. import java.util.List;
  6. import com.ajunframework.beans.annotation.Action;
  7. import com.ajunframework.beans.annotation.Dao;
  8. import com.ajunframework.beans.annotation.Service;
  9. import com.ajunframework.beans.definition.BeanDefinition;
  10. import com.ajunframework.beans.definition.BeandefinitionList;
  11. import com.ajunframework.beans.definition.PropertyDefinition;
  12. import com.ajunframework.beans.factory.AnnotationBeanFactory;
  13. import com.ajunframework.beans.scan.ScanClass;
  14. import com.ajunframework.beans.utils.BeanWrapper;
  16. /**
  17.  * 基于注释的上下文实例化bean类
  18.  * @author harries
  19.  * @http://www.liuhaihua.cn
  20.  */
  21. public class AnnotationClassPathApplicationContext implements ClassPathApplicationContext {
  23.     private static AnnotationClassPathApplicationContext cx = new AnnotationClassPathApplicationContext();
  25.     private AnnotationClassPathApplicationContext(){}
  27.     public static AnnotationClassPathApplicationContext getAnnotationClassPathApplicationContext(){
  28.         if(cx!=null){
  29.             return cx;
  30.         }
  31.         return new AnnotationClassPathApplicationContext();
  32.     }
  34.     public void instanceBean() {
  35.          List<BeanDefinition> beanDefinitions = BeandefinitionList.getBeanDefinitions();
  36.          if(beanDefinitions!=null && !beanDefinitions.isEmpty()){
  37.                 for(BeanDefinition bd:beanDefinitions){
  38.                     if(bd!=null){
  39.                         //初始化bean
  40.                         AnnotationBeanFactory.getBeanFactory().setBean(bd.getId(), bd.getCalssName());
  41.                     }
  42.                 }
  43.         }
  45.     }
  47.     public void injectObject() {
  48.         List<BeanDefinition> beanDefinitions = BeandefinitionList.getBeanDefinitions();
  49.         for(BeanDefinition bd : beanDefinitions){
  50.             Object bean = AnnotationBeanFactory.getBeanFactory().getBean(bd.getId());
  51.             List<PropertyDefinition> pds = bd.getProperties();
  52.             if(pds!=null && !pds.isEmpty()){
  53.                 for(PropertyDefinition pd:pds){
  54.                     String name = pd.getName();
  55.                     String ref = pd.getRef();
  56.                     if(ref!=null && !"".equals(ref)){
  57.                         BeanWrapper b = new BeanWrapper(bean);
  58.                         Object propvalue = AnnotationBeanFactory.getBeanFactory().getBean(name);
  59.                         b.setPropertyValue(name, propvalue);
  60.                     }
  61.                 }
  62.             }
  63.         }
  65.     }
  67.     public void readAnnotationCLass() {
  68.         Class<?> [] classes = ScanClass.getScanPackageClasses();
  69.         if(classes != null && classes.length>0){
  70.             for(Class<?> c:classes){
  71.                 if(c.isAnnotationPresent(Dao.class) || c.isAnnotationPresent(Service.class) || c.isAnnotationPresent(Action.class)){
  72.                     BeandefinitionList.addBeanDefinitionAndSetProperty(c);
  73.                 }
  74.             }
  75.         }
  76.     }
  78.     public  void init(){
  79.         readAnnotationCLass();
  80.         instanceBean();
  81.         injectObject();
  82.     }
  84. }
到目前为止 整个ioc的过程已经完成了，下一节介绍一下这个project中用到的一些工具类
正文到此结束
所属分类： IT教程

热门推荐

相关文章

阿里云首购8折
说给你听

本文目录
随机标签
书籍教程
springboot-demo Java入门教程 bootstrap3 CSS Apache基础教程 php ionic 教程 Python mysql教程 eclipse Ubuntu VPS系统配置 AngularJS 教程 MongoDB教程 Struts2教程 Redis教程 Spring教程 Git教程 Jenkins进阶系列 openfire参考指南 Java设计模式 HBase教程 Maven教程 hibernate教程 Docker 教程 memcached教程 Quartz指南 Hive教程 Ant教程 ANTLR教程 SpringCloud java实例教程 springcloud-demo XStream教程 Hazelcast教程 Elastic-Job-Lite 深入浅出MyBatis SVN教程 ibaties教程 rabittmq教程 solr教程 Hadoop教程 WebService CXF学习 JPA教程 ActiveMQ中文指南 java-demo Java内存模型 dubbo教程 python3-demo Linux入门视频教程
近期评论
  1. 1 Spring Cloud Consul实现选举机制
  2. 2 Spring Boot集成ShedLock实现分布式定时任务
  3. 3 利用oss进行数据库和网站图片备份
  4. 4 Spring Cloud Stream实现数据流处理
  5. 5 Python3访问MySQL数据库快速入门Demo
  6. 6 Github开源项目作者可以免费申请 JetBrains 全家桶
  7. 7 Spring Cloud Vault快速入门Demo
  8. 8 Spring Cloud Gateway快速入门Demo
  9. 9 Spring Cloud Contract快速入门Demo
  10. 10 Spring Cloud Consul快速入门Demo
网站信息
  • 文章总数：82,714 篇
  • 文件总数：284,287 个
  • 标签总数：2,393 个
  • 分类总数：85 个
  • 留言数量：2,560 条
  • 在线人数：677 人
  • 运行天数：4,408天
  • 最后更新：2024年11月21日19点
Loading...

其他链接

关于本站

本站定位：个人技术类博客

本站作用：写博客、记日志、闲聊扯淡鼓捣技术。

问题交流

[HBLOG]公众号 HBLOG HBLOG