转载

【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教程 java-demo Maven教程 springcloud-demo hibernate教程 Docker 教程 memcached教程 Quartz指南 Hive教程 ANTLR教程 SpringCloud Ant教程 java实例教程 Hazelcast教程 XStream教程 Elastic-Job-Lite 深入浅出MyBatis ibaties教程 SVN教程 rabittmq教程 Hadoop教程 solr教程 WebService CXF学习 JPA教程 ActiveMQ中文指南 Java内存模型 dubbo教程 python3-demo Linux入门视频教程
近期评论
  1. 1 Dependency Check命令行方式扫描jar包的安全漏洞
  2. 2 maven使用Dependency-Check来扫描安全漏洞
  3. 3 使用sonarqube分析代码质量
  4. 4 使用screw来对比数据库表和字段差异
  5. 5 Spring Boot 实现防盗链功能
  6. 6 在Spring Boot中的实现国际化（i18n）
  7. 7 一个用于 SMB/CIFS 网络的 Java 库-JCIFS
  8. 8 Spring Boot 3.x嵌入MongoDB 进行测试
  9. 9 java如何解析和生成yaml文件？
  10. 10 java如何解析和生成sql？
网站信息
  • 文章总数：82,734 篇
  • 文件总数：284,312 个
  • 标签总数：2,416 个
  • 分类总数：85 个
  • 留言数量：2,558 条
  • 在线人数：684 人
  • 运行天数：4,438天
  • 最后更新：2024年12月21日21点
Loading...

其他链接

关于本站

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

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

问题交流

[HBLOG]公众号 HBLOG HBLOG