spring-第十章 模仿手写springIOC

spring

---

---

媒介

本章我们模仿实现springIOC的功能，以此加深对IOC实现原理的明白。
Spring IoC容器的实现原理：工厂模式 + 分析XML + 反射机制。

---

第一步：创建模块myspring

就是创建一个新的项目，不外创建过程不多说，值得一提的是，我们须要导入以下依赖：

上面的两个包可以让我们可以或许利用xpath格式读取xml文件设置。
第二步：预备好我们要管理的Bean

这里利用User、UserDao、UserService三个类来模仿三层架构，也是我们须要管理的bean。
User

UserDao

UserService

第三步：预备myspring.xml设置文件

我们须要预备一个xml框架设置文件，在内里设置好各个bean的注入关系等。

1. <?xml version="1.0" encoding="UTF-8"?>
2. <beans>
4.     <bean id="userBean" class="org.example.powernode.myspring.bean.User">
5.         <property name="name" value="张三"/>
6.         <property name="age" value="20"/>
7.     </bean>
9.     <bean id="userService" class="org.example.myspring.bean.UserService">
10.         <property name="userDao" ref="userDaoBean"/>
11.     </bean>
12.   
13.     <bean id="userDaoBean" class="org.example.myspring.bean.UserDao"/>
15. </beans>

复制代码

第四步：编写ApplicationContext接口

这里编写ApplicationContext接口，原来的spring框架的ApplicationContext接口中getBean()方法是源自BeanFactory()接口，但这里省略写步调，直接将该方法界说在ApplicationContext接口中。

1. package org.example.powernode.myspring.framework;
3. public interface ApplicationContext {
4.     Object getBean(String beanName);
5. }

复制代码

第五步：编写ClassPathXmlApplicationContext

该类是ApplicationContext接口的实现类，也会实现getBean()方法，是最告急的一步，我们会在构造方法中读取xml中的设置信息，天生对应的bean存放到容器中。然后让getBean()方法可以或许乐成取出实例化完成的bean。
这里就不完备的模仿spring中的三层缓存了，只用一个HashMap聚集即可。
这里我们重要完成以下几步：

• 确定接纳Map聚集存储Bean
  
• 分析设置文件实例化全部Bean，并放进聚会合
  
• 给Bean的属性赋值
  

1. package org.example.powernode.myspring.framework;
3. import org.dom4j.Document;
4. import org.dom4j.Element;
5. import org.dom4j.Node;
6. import org.dom4j.io.SAXReader;
8. import java.io.InputStream;
9. import java.lang.reflect.Field;
10. import java.lang.reflect.Method;
11. import java.util.HashMap;
12. import java.util.List;
14. public class ClassPathXmlApplicationContext implements ApplicationContext{
15. //    创建map集合存储实例化的对象
16.     private HashMap<String, Object> singletonObjects = new HashMap<>();
17.     @Override
18.     public Object getBean(String beanName) {
19. //        从map集合中取出实例化的对象
20.         return singletonObjects.get(beanName);
21.     }
23. //    解析参数传入的配置文件，然后初始化所有bean对象
24.     public ClassPathXmlApplicationContext(String configLocation) {
25.         try {
26. //            引入dom4j读取器
27.             SAXReader reader = new SAXReader();
28. //            根据传入的配置文件类路径读取配置
29.             InputStream resourceAsStream = ClassLoader.getSystemClassLoader().getResourceAsStream(configLocation);
30.             Document document = reader.read(resourceAsStream);
31. //            使用xpath表达式获取所有的bean对象
32.             List<Node> nodes = document.selectNodes("//bean");
33. //            遍历每个bean标签,完成对象实例化操作
34.             nodes.forEach(node -> {
35.                 try {
36. //                    从node类型转换为更具体的Element类型，可用方法更多
37.                     Element beanElt = (Element) node;
38. //                    读取bean标签中的id和class属性值
39.                     String beanName = beanElt.attributeValue("id");
40.                     String className = beanElt.attributeValue("class");
41. //                    通过从class属性中读取到的类路径创建Class对象
42.                     Class<?> aClass = Class.forName(className);
43. //                    获取构造器创建实例
44.                     Object o = aClass.getDeclaredConstructor().newInstance();
45. //                    把创建好的实例存储进map集合,提前"曝光"
46.                     singletonObjects.put(beanName,o);
47.                 }catch (Exception e) {
48.                     e.printStackTrace();
49.                 }
50.             });
51. //            遍历每个bean标签,获取所有的set方法
52.             nodes.forEach(node -> {
53.                 try {
54.                     Element beanElt = (Element) node;
55. //                    获取bean标签id
56.                     String beanName = beanElt.attributeValue("id");
57. //                    获取bean标签类名
58.                     String className = beanElt.attributeValue("class");
59. //                    通过类名创建Class对象
60.                     Class<?> aClass = Class.forName(className);
61. //                    获取bean标签中的所有property标签
62.                     List<Element> propertys = beanElt.elements("property");
63. //                    遍历property标签
64.                     propertys.forEach(property -> {
65.                         try {
66. //                    获取name属性值,也是我们bean的属性名
67.                             String propertyName = property.attributeValue("name");
68. //                            通过属性名利用反射机制获取属性对象
69.                             Field field = aClass.getDeclaredField(propertyName);
70. //                    拼接得到我们要获取的set方法名
71.                             String setName="set"+propertyName.substring(0,1).toUpperCase()+propertyName.substring(1);
72. //                    通过反射传入方法名和参数类型获取set方法对象
73.                             Method setMethod = aClass.getDeclaredMethod(setName, field.getType());
74. //                    获取要设置的set参数值
75.                             String propertyValue = property.attributeValue("value");
76.                             String ref = property.attributeValue("ref");
77.                             Object propertyVal = null;
78.                             if (propertyValue!=null){
79. //                                简单类型注入，需要判断该简单类型具体的类型来进行把value字符串进行类型转换
80. //                                支持的简单类型有
81. //                                byte short int long float double boolean char
82. //                                Byte Short Integer Long Float Double Boolean Character
83. //                                String
84. //                                获取属性类型名
85.                                 String propertyTypeSimpleName = field.getType().getSimpleName();
86. //                                根据属性类型名把参数转换为对应的类型
87.                                 switch (propertyTypeSimpleName){
88.                                     case "byte": case "Byte":
89.                                         propertyVal = Byte.valueOf(propertyValue);
90.                                         break;
91.                                     case "short": case "Short":
92.                                         propertyVal = Short.valueOf(propertyValue);
93.                                         break;
94.                                     case "int": case "Integer":
95.                                         propertyVal = Integer.valueOf(propertyValue);
96.                                         break;
97.                                     case "long": case "Long":
98.                                         propertyVal = Long.valueOf(propertyValue);
99.                                         break;
100.                                     case "float": case "Float":
101.                                         propertyVal = Float.valueOf(propertyValue);
102.                                         break;
103.                                     case "double": case "Double":
104.                                         propertyVal = Double.valueOf(propertyValue);
105.                                         break;
106.                                     case "boolean": case "Boolean":
107.                                         propertyVal = Boolean.valueOf(propertyValue);
108.                                         break;
109.                                     case "char": case "Character":
110.                                         propertyVal = propertyValue.charAt(0);
111.                                         break;
112.                                     case "String":
113.                                         propertyVal = propertyValue;
114.                                         break;
115.                                 }
116. //                                使用转换完成的参数调用set方法完成属性注入
117.                                 setMethod.invoke(singletonObjects.get(beanName),propertyVal);
118.                             }
119.                             if (ref!=null){
120. //                                非简单类型注入，从map集合中取出具体的实例对象注入即可
121.                                 setMethod.invoke(singletonObjects.get(beanName),singletonObjects.get(ref));
122.                             }
124.                         }catch (Exception e) {
125.                             e.printStackTrace();
126.                         }
127.                     });
128.                 } catch (Exception e) {
129.                     e.printStackTrace();
130.                 }
132.             });
133.         }catch (Exception e) {
134.             e.printStackTrace();
135.         }
137.     }
138. }

复制代码

第六步：打包发布

完成后可以创建一个测试类来调用getBean()查察功能是否正常，确认无误可以利用maven打包成jar包，就完成了模仿spring框架编写的全部操纵。

---

总结

本章我们模仿实现springIOC的功能，以此加深对springIOC的明白。