devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

手写spring+springmvc+mybatis框架篇——springIOC容器_javaee中ioc容器封装map属性

作者：我家自动化 | 2024-03-15 11:23:52

赞

踩

javaee中ioc容器封装map属性

启动IOC容器为initBean方法。下面贴一下这两个类的关系图 

首先是applicationContext











其次是InitBean


    XmlApplicationContext :为解析xml文件的类，在spring源码中Resouce接口是用来解析多种文件格式的xml文件的接口，可能参数时inputStream，也可能是byteArray等，但是我们这里比较简单，直接用new File()传递xml文件。将读取到的对象用如下对象来保存

 Map<String, GenericBeanDefinition> beanDefinitionXmlMap = new ConcurrentHashMap<>(256);

spring也是这么做的。这个也就是我们说的容器。这里介绍一下我定义的这个beanDefinitionXmlMap 对象，beanDefinitionXmlMap 中的key为我们xml文件中的id，value为GenericBeanDefinition 对象，每一个GenericBeanDefinition 对象其实就代表一个bean，在GenericBeanDefinition 对象中，className就是对应的实体类的class的名字，而一个ChildBeanDefinition 对象就代表一个子元素(一个property：属性注入 或者一个constructor-arg元素：构造器注入)

  1. package spring.factory;
  2.  
  3. import lombok.Data;
  4. import java.util.List;
  5. /**
  6.  * Created by Xiao Liang on 2018/6/29.
  7.  * 用来存放xml中注入的bean
  8.  */
  9. @Data
  10. public class GenericBeanDefinition {
  11.     /**
  12.      * className和xml中的class对应
  13.      */
  14.     private String className;
  15.  
  16.     /**
  17.      *  这是bean下面的属性集合
  18.      */
  19.     private List<ChildBeanDefinition> childBeanDefinitionList;
  20. }
  1. package spring.factory;
  2.  
  3. import lombok.Data;
  4. /**
  5.  * Created by Xiao Liang on 2018/6/27.
  6.  */
  7. @Data
  8. public class ChildBeanDefinition {
  9.     private String childrenType;// 这个是property或者constructor-arg类型
  10.     private String attributeOne;//这个是第一个值
  11.     private String attributeTwo;//这个是第二个值
  12. }

    我定义的IOCRULES是用枚举来表示的，下面贴一下我定义的注入规则。

  1. package spring.xmlRules;
  2.  
  3. import lombok.Getter;
  4. /**
  5.  *  @Author xiao liang
  6.  * Ioc中xml配置的规则
  7.  */
  8. @Getter
  9. public enum IocRules {
  10.     BEAN_RULE("bean", "id", "class"),
  11.     SNAN_RULE("component-scan", "base-package", "null"),
  12.     /**
  13.      * set注入的规则
  14.      */
  15.     SET_INJECT("property", "name", "value"),
  16.     /**
  17.      * 构造器注入的规则，使用构造器注入的时候必须指定顺序。
  18.      */
  19.     CONS_INJECT("constructor-arg", "value", "index");
  20.     private String type;
  21.     private String name;
  22.     private String value;
  23.     IocRules(String property, String name, String value) {
  24.         this.type  = property;
  25.         this.name  = name;
  26.         this.value = value;
  27.     }
  28. }

XmlApplicationContext：。其实这里最好是只提供接口，然后让子类来实现。但是为了简化，方便起见，直接写在了这里。最关键的是标红的两个方法，一个是getBeanDefinitionMap，一个是getComponentList。第一个是解析xml文件并且将属性值保存在容器(beanDefinitionXmlMap对象)中，第二个是获取一个链表，这个链表是存在注解扫描的并且排列好实例化顺序后的链表。这个扫描+实例化顺序的核心功能在ScanUtil工具类中。这个类也是难点。

  1. package spring.xml;
  2.  
  3. import lombok.extern.slf4j.Slf4j;
  4. import org.dom4j.Document;
  5. import org.dom4j.DocumentException;
  6. import org.dom4j.Element;
  7. import org.dom4j.io.SAXReader;
  8. import spring.Utils.StringUtils;
  9. import spring.Utils.scan.ScanUtil;
  10. import spring.constants.Constants;
  11. import spring.exception.XmlException;
  12. import spring.factory.ChildBeanDefinition;
  13. import spring.factory.GenericBeanDefinition;
  14. import spring.xmlRules.IocRules;
  15. import java.io.File;
  16. import java.util.ArrayList;
  17. import java.util.List;
  18. import java.util.Map;
  19. import java.util.concurrent.ConcurrentHashMap;
  20. /**
  21.  * Created by Xiao Liang on 2018/6/28.
  22.  * 封装解析xml的方法，模仿Ioc注入 BeanDefinition。实际注入的是GenericBeanDefinition
  23.  */
  24. @Slf4j
  25. public class XmlApplicationContext {
  26.     /**
  27.      * @Description 将xml中的bean元素注入到容器中的方法
  28.      *
  29.      * @return 返回值是指定xml中的bean的容器
  30.      */
  31.     public  Map<String, GenericBeanDefinition> getBeanDefinitionMap(String contextConfigLocation) {
  32.         Map<String, GenericBeanDefinition> beanDefinitionXmlMap = new ConcurrentHashMap<>(256);
  33.         List<Element> elementsList = getElements(contextConfigLocation);
  34.         //遍历每一个bean，注入beanDefinitionMap
  35.         for (Element element :
  36.                 elementsList) {
  37.             if (element.getName().equals("bean")){
  38.                 //声明一个bean的map,用来盛放当前bean子元素的容器
  39.                 GenericBeanDefinition genericBeanDefinition = new GenericBeanDefinition();
  40.                 List<ChildBeanDefinition> childBeanDefinitionList = new ArrayList<>();
  41.                 String beanId = element.attributeValue(IocRules.BEAN_RULE.getName());
  42.                 String beanClass = element.attributeValue(IocRules.BEAN_RULE.getValue());
  43.                 //保证子元素确实存在
  44.                 if (!StringUtils.isEmpty(beanId) && !StringUtils.isEmpty(beanClass)) {
  45.                     //当前bean的className
  46.                     genericBeanDefinition.setClassName(beanClass);
  47.                     //当前bean的所有子元素
  48.                     List<Element> elements = element.elements();
  49.                     if (elements != null) {
  50.                         for (Element childrenElement :
  51.                                 elements) {
  52.                             //如果匹配set注入规则,则注入到容器
  53.                             if (childrenElement.getName().equals(IocRules.SET_INJECT.getType())) {
  54.                                 ChildBeanDefinition childBeanDefinition = new ChildBeanDefinition();
  55.                                 childBeanDefinition.setChildrenType(IocRules.SET_INJECT.getType());
  56.                                 String name = IocRules.SET_INJECT.getName();
  57.                                 String value = IocRules.SET_INJECT.getValue();
  58.                                 setChildBeanDefinitionByType(childrenElement, childBeanDefinition, name, value, childBeanDefinitionList);
  59.                             }
  60.                             //如果匹配构造器注入规则,则注入到容器
  61.                             else if (childrenElement.getName().equals(IocRules.CONS_INJECT.getType())) {
  62.                                 ChildBeanDefinition childBeanDefinition = new ChildBeanDefinition();
  63.                                 childBeanDefinition.setChildrenType(IocRules.CONS_INJECT.getType());
  64.                                 String name = IocRules.CONS_INJECT.getName();
  65.                                 String value = IocRules.CONS_INJECT.getValue();
  66.                                 setChildBeanDefinitionByType(childrenElement, childBeanDefinition, name, value, childBeanDefinitionList);
  67.                             }
  68.                         }
  69.                     } else {
  70.                         log.info("{}下面没有子元素", beanId);
  71.                     }
  72.                     genericBeanDefinition.setChildBeanDefinitionList(childBeanDefinitionList);
  73.                     beanDefinitionXmlMap.put(beanId, genericBeanDefinition);
  74.                 }
  75.             }
  76.         }
  77.         return beanDefinitionXmlMap;
  78.     }
  79.     /**
  80.      * @Description 根据指定的xml，获得注解扫描的bean容器
  81.      * @param contextConfigLocation
  82.      * @return
  83.      */
  84.     public List<String> getComponentList(String contextConfigLocation){
  85.         List<String> componentList = new ArrayList<>();
  86.         List<Element> elementsList = getElements(contextConfigLocation);
  87.         for (Element element :
  88.                 elementsList) {
  89.             if (element.getName().equals(IocRules.SNAN_RULE.getType())) {
  90.                 String packageName = element.attributeValue(IocRules.SNAN_RULE.getName());
  91.                 componentList.addAll(resolveComponentList(packageName));
  92.             }
  93.         }
  94.         return componentList;
  95.     }
  96.     /**
  97.      * 根据要扫描的包名，返回有注解扫描的类
  98.      * @param packageName
  99.      * @return
  100.      */
  101.     public List<String> resolveComponentList(String packageName){
  102.         if (StringUtils.isEmpty(packageName)){
  103.             throw new XmlException("请正确设置"+IocRules.SNAN_RULE.getType()+"的属性");
  104.         }
  105.         List<String> componentList = new ArrayList<>();
  106.         List<String> componentListAfter = ScanUtil.getComponentList(packageName);
  107.         componentList.addAll(componentListAfter);
  108.         return  componentList;
  109.     }
  110.     /**
  111.      * 将每个bean的子元素注入容器
  112.      *
  113.      * @param element
  114.      * @param childBeanDefinition
  115.      * @param name
  116.      * @param value
  117.      * @param childBeanDefinitionList
  118.      */
  119.     private void setChildBeanDefinitionByType(Element element, ChildBeanDefinition childBeanDefinition, String name, String value,
  120.                               List<ChildBeanDefinition> childBeanDefinitionList) {
  121.         if (childBeanDefinition != null) {
  122.             childBeanDefinition.setAttributeOne(element.attributeValue(name));
  123.             childBeanDefinition.setAttributeTwo(element.attributeValue(value));
  124.             childBeanDefinitionList.add(childBeanDefinition);
  125.         } else {
  126.             throw new XmlException("未按照格式配置xml文件或者暂不支持改配置属性");
  127.         }
  128.     }
  129.  
  130.     /**
  131.      * 解析xml的工厂,根据路径名获取根元素下面的所有子元素
  132.      * @param contextConfigLocation
  133.      * @return
  134.      */
  135.     private List<Element> getElements(String contextConfigLocation) {
  136.         // 创建saxReader对象
  137.         SAXReader reader = new SAXReader();
  138.         // 通过read方法读取一个文件 转换成Document对象
  139.         Document document = null;
  140.         String pathName = Constants.PATH + contextConfigLocation;
  141.         try {
  142.             document = reader.read(new File(pathName));
  143.         } catch (DocumentException e) {
  144.             log.error("文件没有找到,{}", pathName);
  145.         }
  146.         //获取根节点元素
  147.         Element node = document.getRootElement();
  148.         //获取所有的bean
  149.         List<Element> elementsList = node.elements();
  150.         return elementsList;
  151.     }
  152. }

难点一：ScanUtil类，这个类是spring容器的核心以及难点，我说一下过程，按照这个过程来看代码比较好理解。分为几个步骤

1 首先通过getClassName获取指定包下的所有类名的集合。

2 遍历每个类名的集合，用resolveComponent方法来扫描注解在类上的注解@MyController @MyService @MyRepository,

3 如果类上面有这些注解，则开始扫描此类上的属性上有没有@MyAutowired注解，如果存在@MyAutowired注解，则去属性对应的类上面递归上面的过程。直到类中没有@MyAutowired注解的时候。将类名添加到ComponentList链表中。在此过程中，如果类名是接口，并且有实现类的时候，添加到ComponentList链表中的是实现类的名字。为了完成此步骤，我设计了一个makeInterfaceAndImplMap方法用来绑定接口和其实现类，所以此框架目前只支持一个接口，一个实现类。

4 在第三步中，如果类上没有注解，并且是一个接口，此时默认是需要动态代理的接口，将此类名直接添加到ComponentList链表中。

  1. package spring.Utils.scan;
  2.  
  3. import lombok.extern.slf4j.Slf4j;
  4. import spring.Utils.AnnotationUtils;
  5. import spring.Utils.ListAddUtils;
  6. import spring.annotation.MyAutowired;
  7. import spring.annotation.MyController;
  8. import spring.annotation.MyRepository;
  9. import spring.annotation.MyService;
  10. import java.io.File;
  11. import java.io.IOException;
  12. import java.lang.annotation.Annotation;
  13. import java.lang.reflect.Field;
  14. import java.net.URL;
  15. import java.util.*;
  16. import java.util.concurrent.ConcurrentHashMap;
  17. /**
  18.  * Created by Xiao Liang on 2018/6/27.
  19.  * 扫描工具类(核心方法是getClassName和getComponentList)
  20.  * 1 扫描包下的注解
  21.  * 2 扫描包下的类名
  22.  */
  23. @Slf4j
  24. public class ScanUtil {
  25.     private static List<String> listClassName = new ArrayList<>();
  26.     private static List<String> componentList = new ArrayList<>();
  27.     private static Map<String, String> interfaceAndImplMap = new ConcurrentHashMap<>();
  28.     /**
  29.      * 扫描指定包下面的所有类名
  30.      *
  31.      * @param packageName,包名
  32.      * @return 类名的集合，
  33.      */
  34.     public static List<String> getClassName(String packageName) {
  35.         Enumeration<URL> urls = null;
  36.         ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
  37.         String newPackageName = packageName.replace(".", "/");
  38.         try {
  39.             urls = contextClassLoader.getResources(newPackageName);
  40.             while (urls.hasMoreElements()) {
  41.                 URL url = urls.nextElement();
  42.                 File packageFile = new File(url.getPath());
  43.                 File[] files = packageFile.listFiles();
  44.                 if (files == null) {
  45.                     break;
  46.                 }
  47.                 for (File file :
  48.                         files) {
  49.                     //如果是class，则添加到list中返回
  50.                     if (file.getName().endsWith(".class")) {
  51.                         String templeName = (packageName.replace("/", ".") + "." + file.getName());
  52.                         String newTempleName = templeName.substring(0, templeName.lastIndexOf("."));
  53.                         listClassName.add(newTempleName);
  54.                     }
  55.                     //如果是package，则继续遍历
  56.                     else {
  57.                         String nextPackageName = newPackageName + "." + file.getName();
  58.                         getClassName(nextPackageName);
  59.                     }
  60.                 }
  61.             }
  62.         } catch (IOException e) {
  63.             e.printStackTrace();
  64.         }
  65.         return listClassName;
  66.     }
  67.     /**
  68.      * 返回 有注解的实例化顺序的链表
  69.      */
  70.     public static List<String> getComponentList(String packageName) {
  71.         //获取所有类
  72.         List<String> classNameList = getClassName(packageName);
  73.         //将扫描的接口和其实现类，使用map对应上,模仿spring接口注入，复杂的原因是java不支持从接口获取实现类
  74.         makeInterfaceAndImplMap(classNameList);
  75.         for (String className :
  76.                 classNameList) {
  77.             try {
  78.                 //实例化每个类
  79.                 resolveComponent(className);
  80.             } catch (ClassNotFoundException e) {
  81.                 log.error("扫描注解的时候,{}没有找到", className);
  82.                 e.printStackTrace();
  83.             }
  84.         }
  85.         return componentList;
  86.     }
  87.     /**
  88.      * getComponentList();递归调用的子方法
  89.      *
  90.      * @param className
  91.      */
  92.     public static void resolveComponent(String className) throws ClassNotFoundException {
  93.         Class<?> aClass = Class.forName(className);
  94.         //在此处添加要识别的注解，也是每次扫描的顺序，最好遵循习惯
  95.         addNewAnnotation(MyController.class, aClass);
  96.         addNewAnnotation(MyService.class, aClass);
  97.         addNewAnnotation(MyRepository.class, aClass);
  98.     }
  99.     public static <A extends Annotation> void addNewAnnotation(Class<A> annotationClass, Class<?> aClass) throws ClassNotFoundException {
  100.         //如果类上有注解，判断属性上有没有注解
  101.         if (!AnnotationUtils.isEmpty(aClass.getAnnotation(annotationClass))) {
  102.             Field[] fields = aClass.getDeclaredFields();
  103.             if (fields == null || fields.length == 0) {
  104.                 ListAddUtils.add(componentList, aClass.getName());
  105.             } else {
  106.                 //跳出递归的语句，也就是最底层的类，如果所有属性没有@MyAutowired注解，则注入到链表中
  107.                 if (isEmptyAutowired(fields)) {
  108.                     ListAddUtils.add(componentList, aClass.getName());
  109.                 } else {
  110.                     //如果属性上有@MyAutowired，则继续递归
  111.                     for (Field field :
  112.                             fields) {
  113.                         //递归具体的查找到底哪个属性上有@MyAutowired。
  114.                         if (field.getAnnotation(MyAutowired.class) != null) {
  115.                             //如果有则根据类名查找类，然后去对应的类中递归此过程
  116.                             String newFieldName = field.getType().getName();
  117.                             //如果是接口，则用其实现类注入
  118.                             if (Class.forName(newFieldName).isInterface()) {
  119.                                 String nextName = convertInterfaceToImpl(newFieldName);
  120.                                 if (!componentList.contains(nextName)) {
  121.                                     resolveComponent(nextName);
  122.                                 }
  123.                             } else {
  124.                                 resolveComponent(newFieldName);
  125.                             }
  126.                         }
  127.                     }
  128.                     ListAddUtils.add(componentList, aClass.getName());
  129.                 }
  130.             }
  131.         }
  132.         //如果是需要动态的代理注入的接口，加入到实例化的链表中
  133.         else if (aClass.isInterface() && interfaceAndImplMap.get(aClass.getName()).equals("proxy")) {
  134.             ListAddUtils.add(componentList, aClass.getName());
  135.         }
  136.     }
  137.     /**
  138.      * 判断一组属性里面有没有注解
  139.      *
  140.      * @param fields
  141.      * @return
  142.      */
  143.     private static boolean isEmptyAutowired(Field[] fields) {
  144.         for (Field field :
  145.                 fields) {
  146.             if (!AnnotationUtils.isEmpty(field.getAnnotation(MyAutowired.class))) {
  147.                 return false;
  148.             }
  149.         }
  150.         return true;
  151.     }
  152.     /**
  153.      * 工具类，组装接口和实现类
  154.      *
  155.      * @param classNameList
  156.      * @return
  157.      */
  158.     private static Map<String, String> makeInterfaceAndImplMap(List<String> classNameList) {
  159.         Class<?> aClass = null;
  160.         //interfaceNameList是所有接口类名的链表
  161.         List<String> interfaceNameList = new ArrayList<>();
  162.         //这个链表保存的是有实现类的接口的链表名，默认没有实现类的接口即为需要动态注的链表
  163.         List<String> interfaceExist = new ArrayList<>();
  164.         //循环类名，将类名注入到链表中
  165.         for (String className :
  166.                 classNameList) {
  167.             try {
  168.                 aClass = Class.forName(className);
  169.             } catch (ClassNotFoundException e) {
  170.                 e.printStackTrace();
  171.             }
  172.             if (aClass.isInterface()) {
  173.                 interfaceNameList.add(aClass.getName());
  174.             }
  175.         }
  176.         for (String className :
  177.                 classNameList) {
  178.             Class<?> bClass = null;
  179.             try {
  180.                 bClass = Class.forName(className);
  181.             } catch (ClassNotFoundException e) {
  182.                 e.printStackTrace();
  183.             }
  184.             Class<?>[] interfaces = bClass.getInterfaces();
  185.             //如果是接口的实现类
  186.             if (interfaces != null && interfaces.length != 0) {
  187.                 for (String interfaceName :
  188.                         interfaceNameList) {
  189.                     for (Class<?> interfaceClass :
  190.                             interfaces) {
  191.                         //如果既有接口，也有实现类，则组成map
  192.                         if (interfaceName.equals(interfaceClass.getName())) {
  193.                             interfaceAndImplMap.put(interfaceName, className);
  194.                             interfaceExist.add(interfaceName);
  195.                         }
  196.                     }
  197.                 }
  198.             }
  199.         }
  200.         //需要动态代理注入的接口，在map中用value = proxy来识别
  201.         interfaceNameList.removeAll(interfaceExist);
  202.         if (interfaceNameList != null && interfaceNameList.size() > 0) {
  203.             for (String spareInterfaceName :
  204.                     interfaceNameList) {
  205.                 interfaceAndImplMap.put(spareInterfaceName, "proxy");
  206.             }
  207.             System.out.println("已经存在的" + interfaceNameList);
  208.         }
  209.         return null;
  210.     }
  211.     /**
  212.      * 工具类:接口转换为实现类
  213.      *
  214.      * @param newFileName
  215.      * @return
  216.      */
  217.     private static String convertInterfaceToImpl(String newFileName) {
  218.         Set<Map.Entry<String, String>> entries = interfaceAndImplMap.entrySet();
  219.         for (Map.Entry<String, String> entry :
  220.                 entries) {
  221.             if (newFileName.equals(entry.getKey()) && !entry.getValue().equals("proxy")) {
  222.                 return entry.getValue();
  223.             } else if (newFileName.equals(entry.getKey()) && entry.getValue().equals("proxy")) {
  224.                 return entry.getKey();
  225.             }
  226.         }
  227.         return null;
  228.     }
  229. }

这样获得实例化顺序的链表ComponentList之后，开始实例化，也就是initBean这个类。实例化通过反射new Instance()方法获得对象，绑定后的对象用beanContainerMap来保存，但是这里存在一个问题，就是我们动态代理添加到ComponentList的是接口名称，接口名称不能直接new Instance()，所以这里标红处用的是动态代理实例化的对象，这部分代码是针对Mybatis的接口注入的。先不用管具体是什么意思，后续会讲解。

这里还要注意的是先解析xml还是先解析注解扫描的问题，spring是优先解析xml文件的bean，然后执行的注解注入。和这里的顺序一致。

  1. package spring.factory;
  2.  
  3. import lombok.extern.slf4j.Slf4j;
  4. import spring.Utils.AnnotationUtils;
  5. import spring.annotation.MyAutowired;
  6. import spring.constants.Constants;
  7. import spring.mybatis.MySqlSession;
  8. import java.lang.reflect.Field;
  9. import java.util.List;
  10. import java.util.Map;
  11. import java.util.Set;
  12. import java.util.concurrent.ConcurrentHashMap;
  13. /**
  14.  * Created by Xiao Liang on 2018/6/27.
  15.  */
  16. @Slf4j
  17. public class InitBean extends BeanDefinition {
  18.     //初始化后的bean容器 key为class名，value为实例化对象
  19.     public Map<String, Object> beanContainerMap = new ConcurrentHashMap<>();
  20.     /**
  21.      * 初始化bean容器方法
  22.      * 注意，扫描的bean会覆盖xml中配置的bean，spring也是这样，扫描的注入和装配都是在xml之后
  23.      * MyAutowired暂时是根据名称装配和扫描
  24.      */
  25.     public void initBeans() {
  26.         //初始化xml配置
  27.         initXmlBeans(Constants.contextConfigLocation);
  28.         initXmlBeans(Constants.springmvcConfigLocation);
  29.         //初始化扫描注解的配置
  30.         initAutowiredBeans(Constants.contextConfigLocation);
  31.     }
  32.     /**
  33.      * 初始化xml中bean内容的方法
  34.      */
  35.     public void initXmlBeans(String contextConfigLocation) {
  36.         ApplicationContext applicationContext = new ApplicationContext(contextConfigLocation);
  37.         Class<?> aClass = null;
  38.         //从容器中取出bean，用application的getbean方法依次加载bean
  39.         Map<String, GenericBeanDefinition> beanDefinitionMap = super.getbeanDefinitionXmlMap(contextConfigLocation);
  40.         Set<Map.Entry<String, GenericBeanDefinition>> entries = beanDefinitionMap.entrySet();
  41.         for (Map.Entry<String, GenericBeanDefinition> entry :
  42.                 entries) {
  43.             String beanId = entry.getKey();
  44.             String className = entry.getValue().getClassName();
  45.             try {
  46.                 aClass = Class.forName(className);
  47.  
  48.             } catch (ClassNotFoundException e) {
  49.                 log.error("xml中{}无法实例化", className);
  50.                 e.printStackTrace();
  51.             }
  52.             beanContainerMap.put(className, aClass.cast(applicationContext.getBean(beanId)));
  53.         }
  54.     }
  55.     /**
  56.      * 将所有的componentList(也就是加注解的类)里面的bean实例化
  57.      *
  58.      * @return
  59.      */
  60.     public void initAutowiredBeans(String contextConfigLocation) {
  61.         List<String> componentList = super.getComponentList(contextConfigLocation);
  62.         System.out.println("实例化的顺序" + componentList);
  63.         //扫描到有注解的类，初始化类的名单
  64.         for (String className :
  65.                 componentList) {
  66.             //将每一个类初始化
  67.             try {
  68.                 initClass(className);
  69.             } catch (ClassNotFoundException e) {
  70.                 log.error("{}没有找到", className);
  71.                 e.printStackTrace();
  72.             } catch (IllegalAccessException e) {
  73.                 e.printStackTrace();
  74.             } catch (InstantiationException e) {
  75.                 e.printStackTrace();
  76.             }
  77.         }
  78.     }
  79.     /**
  80.      * 初始化每一个类的方法,初始化的时候由于spring要实现使用接口注入，所以比较麻烦
  81.      * 需要根据类名来判断是否有接口，然后在将接口名和实现类对应上装配到容器中
  82.      *
  83.      * @param className
  84.      */
  85.     public void initClass(String className) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
  86.         Class<?> aClass = Class.forName(className);
  87.         //先判断这个类有没有接口，如果有接口，将接口装配
  88.         Class<?>[] interfaces = aClass.getInterfaces();
  89.        //如果类是接口，注入的对象是动态代理的对象
  90.         if (aClass.isInterface()){
  91.             MySqlSession mySqlSession = new MySqlSession();
  92.             beanContainerMap.put(aClass.getName(),mySqlSession.getMapper(aClass, Constants.mybatisConfigLocation));
  93.         }
  94.        //如果不是接口的实现类，也就是controller层
  95.         else if (interfaces == null || interfaces.length == 0) {
  96.             noInterfaceInit(className, className);
  97.         }
  98.         else {
  99.             for (Class<?> interfaceClass :
  100.                     interfaces) {
  101.                 boolean flag = isExistInContainer(className);
  102.                 //容器中如果有，则直接使用这个对象进行装配
  103.                 if (flag) {
  104.                     beanContainerMap.put(interfaceClass.getName(), aClass.newInstance());
  105.                 } else {
  106.                     //如果容器中没有，则先实例化实现类，然后再装配到容器中
  107.                     noInterfaceInit(className, interfaceClass.getName());
  108.                 }
  109.             }
  110.         }
  111.     }
  112.     /**
  113.      * @param className
  114.      * @param interfaceName
  115.      */
  116.     public void noInterfaceInit(String className, String interfaceName) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
  117.         Class<?> aClass = Class.forName(className);
  118.         //bean实例化
  119.         System.out.println("实例化的名字"+aClass.getName());
  120.         Object object = aClass.newInstance();
  121.         Field[] declaredFields = aClass.getDeclaredFields();
  122.         for (Field field :
  123.                 declaredFields) {
  124.             //如果属性上有MyAutowired注解，则先将属性注入进去
  125.             if (!AnnotationUtils.isEmpty(field.getAnnotation(MyAutowired.class))) {
  126.                 //System.out.println("发现注解");
  127.                 //设置私有属性可见
  128.                 field.setAccessible(true);
  129.                 //如果有注解，在实例化链表里面搜寻类名
  130.                 Set<Map.Entry<String, Object>> entries = beanContainerMap.entrySet();
  131.                 for (Map.Entry<String, Object> entry :
  132.                         entries) {
  133.                     String type = field.getType().getName();
  134.                     if (entry.getKey().equals(type)){
  135.                         field.set(object, entry.getValue());
  136.                     }
  137.                 }
  138.             }
  139.         }
  140.         beanContainerMap.put(interfaceName, object);
  141.     }
  142.     /**
  143.      * 属于工具类，不是很重要
  144.      * 在实例化该类之前先判断该类在容器中是否存在
  145.      *
  146.      * @param className
  147.      * @return
  148.      */
  149.     public boolean isExistInContainer(String className) {
  150.         Set<Map.Entry<String, Object>> entries = beanContainerMap.entrySet();
  151.         if (entries != null) {
  152.             for (Map.Entry<String, Object> map :
  153.                     entries) {
  154.                 if (map.getKey().equals(className)) {
  155.                     return true;
  156.                 } else {
  157.                     return false;
  158.                 }
  159.             }
  160.         }
  161.         return false;
  162.     }
  163. }

至此，spring容器的开发暂时告一段落，下一篇介绍springmvc的实现。

我将此项目上传到了github，需要的童鞋可以自行下载。

https://github.com/836219171/MySSM


本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号