手写Spring框架

1. 手写Spring框架

@
目次

• 1. 手写Spring框架
  
• 每博一文案
  
• 2. 反射机制的回顾
  
• 3. 开始手写 Spring 框架
  
  
  
  • 3.1 第一步：使用 IDE 创建模块myspring
    
  • 3.2 第二步：预备好我们要管理的Bean
    
  • 3.3 第三步：预备myspring.xml配置文件
    
  • 3.4 第四步：编写ApplicationContext接口
    
  • 3.5 第五步：编写ClassPathXmlApplicationContext
    
  • 3.6 第六步：确定接纳Map聚集存储Bean
    
  • 3.7 第七步：剖析配置文件，并实例化所有Bean
    
  • 3.8 第八步：测试可否获取到Bean
    
  • 3.9 第九步：给Bean的属性赋值
    
  • 3.10 第十步：测试是否能够正常赋值成功
    
  • 3.11 第十一步：打包发布
    
  • 3.12 第十二步: 站在程序员角度使用我们自己手写的 spring 的 myspring框架
    
  
  
• 4. 总结:
  
• 5. 最后:
  

每博一文案

1. 特别喜欢一种人
2. 他们的知识储备和信息密度，都远远高于我
3. 但还是愿意认真听我说，那些没有营养的废话
4. 我始终觉得，温柔浪漫跟博学，是人身上最难得的特性
5. 懂得向下兼容的人，走到哪里都是宝藏
6. 太喜欢哪些优秀，却不带优越感的人相处了

复制代码

2. 反射机制的回顾

我们知道框架一样平常是由 设计模式+注解+反射 来实现，并举行运用开发的。
所以我们要手写 Spring 框架，就需要先来回顾，回顾Java当中的反射机制，这里是简单的回顾反射 。关于反射机制更加详细的内容，大家可以移步至✏️✏️✏️ Java “框架 = 注解 + 反射 + 设计模式” 之 反射详解-CSDN博客 。
我们知道，想要调用一个方法，就需要明确知道该方法的四个要素：

• 调用的是哪个对象的
  
• 哪个方法
  
• 该方法传什么参数
  
• 有无返回值，有返回值的话，又该返回什么值
  

为了简单的回顾我们的反射机制，下面我们举行一个简单的任务。完成下面的需求

首先你知道以下这几条信息

1. 假设你现在以下信息:
2. 1.有这样一个类，类名叫做：com.rainbowsea.reflect.User
3. 2.这个类符合javabean规范，属性私有化，对外提供公开的setter和getter方法。
4. 3.你还知道这个类当中有一个属性，属性的名字叫做 age
5. 4.并且你还知道age属性的类型是 int 类型
6. 请使用反射机制调用set()方法，给 User 对象的age 属性赋值(age 属性赋值为 20 )

复制代码

1. package com.rainbowsea.reflect;
3. public class User {
4.     private String name;
5.     private int age;
8.     public String getName() {
9.         return name;
10.     }
12.     public void setName(String name) {
13.         this.name = name;
14.     }
16.     public int getAge() {
17.         return age;
18.     }
20.     public void setAge(int age) {
21.         this.age = age;
22.     }
24.     @Override
25.     public String toString() {
26.         return "User{" +
27.                 "name='" + name + '\'' +
28.                 ", age=" + age +
29.                 '}';
30.     }
31. }

复制代码

下面通过反射机制，获取到为 age 属性值举行赋值操纵。

1. package com.rainbowsea.test;
3. import java.lang.reflect.Constructor;
4. import java.lang.reflect.Field;
5. import java.lang.reflect.Method;
7. public class Test2 {
8.     /*
9.     需求：
10.     假设你现在以下信息:
11.     1.有这样一个类，类名叫做：com.powernode.reflect.User
12.     2.这个类符合javabean规范，属性私有化，对外提供公开的setter和getter方法。
13.     3.你还知道这个类当中有一个属性，属性的名字叫做 age
14.     4.并且你还知道age属性的类型是 int 类型
15.    请使用反射机制调用set()方法，给 User 对象的age 属性赋值
16.      */
18.     public static void main(String[] args) {
19.         String className = "com.rainbowsea.reflect.User";
20.         String propertyName = "age";
23.         try {
24.             // 通过 反射机制调用setAge(int) 方法
25.             // 获取到对应的类
26.             Class<?> clazz = Class.forName(className);
27.             // 获取对应的方法
28.             // 方法名: 这里我们知道set 方法格式为: setAge() set+属性名的首字母大小+后面属性名的小写字母
29.             String setMethodName = "set" + propertyName.toUpperCase().charAt(0)+ propertyName.substring(1);
30.             // 获取对应的方法名:
31.             // 我们知道的属性名就可以，根据属性名获取属性类型
32.             // 下面这里获取到的是一个完整的：private int com.rainbowsea.reflect.User.age 类型名
33.             Field field = clazz.getDeclaredField(propertyName);
35.             // field.getType() 获取到属性的类型，是个简单的类型 int
36.             Method declaredMethod = clazz.getDeclaredMethod(setMethodName, field.getType());
37.             //System.out.println(field.getType());
38.             
39.             // 准备对象
40.             Constructor<?> declaredConstructor = clazz.getDeclaredConstructor();
41.             Object obj = declaredConstructor.newInstance();
42.             // 调用set()方法赋值， 没有返回值(调用 obj 的对象中的，declaredMethod()方法，参数是 30,没有返回值)
43.             declaredMethod.invoke(obj,30);
45.             System.out.println(obj);
46.         } catch (Exception e) {
47.             e.printStackTrace();
48.             throw new RuntimeException(e);
49.         }
55.     }
56. }

复制代码

成功了，哪我们反射机制就算简单回顾完了，该上正菜了——》手写 Spring 框架
3. 开始手写 Spring 框架

Spring IoC容器的实现原理：工厂模式 + 剖析XML + 反射机制。
我们给自己的框架起名为：myspring（我的春天）
3.1 第一步：使用 IDE 创建模块myspring

这里我们接纳 IDE 当中的Maven 创建一个 名为 myspring的 Module。

注意：这里是 org.myspringframework  我们现在的角色是一个spring开发者职员。所以我们的包名的命名格式还是要规定一下的。

打包方式接纳 jar，并且还需要引入 dom4j 和 jaxen的依赖，由于要使用它剖析XML文件，还有junit依赖。(举行测试)。有上面三个就可以了，这里的话，我再引入一个  log4j2 的依赖，用于日志信息的显示记录。由于我们这里是，自己手写 Spring 框架，所以就不要再引入 Spring的 jar 包内容了。

1. <?xml version="1.0" encoding="UTF-8"?>
2. <project xmlns="http://maven.apache.org/POM/4.0.0"
3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
5.     <modelVersion>4.0.0</modelVersion>
7.     <groupId>com.rainbowsea</groupId>
8.     <artifactId>myspring</artifactId>
9.     <version>1.0-SNAPSHOT</version>
11.     <packaging>jar</packaging>
13.     <properties>
14.         <maven.compiler.source>17</maven.compiler.source>
15.         <maven.compiler.target>17</maven.compiler.target>
16.     </properties>
18.     <dependencies>
20.         <dependency>
21.             <groupId>org.dom4j</groupId>
22.             <artifactId>dom4j</artifactId>
23.             <version>2.1.3</version>
24.         </dependency>
26.         <dependency>
27.             <groupId>jaxen</groupId>
28.             <artifactId>jaxen</artifactId>
29.             <version>1.2.0</version>
30.         </dependency>
33.         <dependency>
34.             <groupId>junit</groupId>
35.             <artifactId>junit</artifactId>
36.             <version>4.13.2</version>
37.             <scope>test</scope>
38.         </dependency>
41.         <dependency>
42.             <groupId>org.apache.logging.log4j</groupId>
43.             <artifactId>log4j-core</artifactId>
44.             <version>2.19.0</version>
45.         </dependency>
47.         <dependency>
48.             <groupId>org.apache.logging.log4j</groupId>
49.             <artifactId>log4j-slf4j2-impl</artifactId>
50.             <version>2.19.0</version>
51.         </dependency>
52.     </dependencies>
54. </project>

复制代码

3.2 第二步：预备好我们要管理的Bean

预备好我们要管理的Bean（这些Bean在将来开发完框架之后是要删除的）
注意包名，不要用 org.myspringframework包了，由于这些Bean不是框架内置的，是将来使用我们写好 Spring 框架方便我们后续测试，基于便于我们手写 Spring 框架举行思考，所以这里我就定义为了。com.rainbowsea.myspring.bean  大家可以自行定义
一共定义了 三个 Bean ：User，UserService，UserDao

1. package com.rainbowsea.myspring.bean;
3. public class User {
4.     private String name;
5.     private int age;
8.     public void setName(String name) {
9.         this.name = name;
10.     }
12.     public void setAge(int age) {
13.         this.age = age;
14.     }
17.     @Override
18.     public String toString() {
19.         return "User{" +
20.                 "name='" + name + '\'' +
21.                 ", age=" + age +
22.                 '}';
23.     }
24. }

复制代码

1. package com.rainbowsea.myspring.bean;
3. public class UserDao {
4.     public void insert() {
5.         System.out.println("数据库插入数据");
6.     }
7. }

复制代码

1. package com.rainbowsea.myspring.bean;
3. public class UserService {
4.     private UserDao userDao;
6.     public void setUserDao(UserDao userDao) {
7.         this.userDao = userDao;
8.     }
11.     public void save() {
12.         userDao.insert();
13.     }
14. }

复制代码

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

将来在框架开发完毕之后，这个文件也是要删除的。由于这个配置文件的提供者应该是使用这个框架的程序员。这里我是同样也是为了，用于验证测试，我们手写额Spring框架的。文件名随意，我们这里叫做：myspring.xml。文件放在类路径当中即可，我们这里把文件放到类的根路径下。使用value给简单属性赋值。使用ref给非简单属性赋值。

由于上面我配置了引入一个  log4j2 的依赖，用于日志信息的显示记录。所以这里，我们还需配置一个关于 log4j2 的配置文件。

3.4 第四步：编写ApplicationContext接口

ApplicationContext 接口中提供一个getBean()方法，通过该方法可以获取Bean对象。
注意包名：这个接口就是myspring框架中的一员了。

3.5 第五步：编写ClassPathXmlApplicationContext

ClassPathXmlApplicationContext 是 ApplicationContext 接口的实现类。该类从类路径当中加载myspring.xml 配置文件。

1. package org.myspringframework.core;
3. public class ClassPathXmlApplicationContext implements ApplicationContext {
5.     @Override
6.     public Object getBean(String beanName) {
7.         return singletonObjects.get(beanName);
8.     }
9. }

复制代码

3.6 第六步：确定接纳Map聚集存储Bean

确定接纳Map聚集存储Bean实例。Map聚集的key存储 beanId，value存储Bean实例。Map
在ClassPathXmlApplicationContext类中添加 Map属性。
并且在ClassPathXmlApplicationContext类中添加构造方法，该构造方法的参数接收myspring.xml文件。
同时实现getBean方法。

1. package org.myspringframework.core;
3. import java.util.HashMap;
4. import java.util.Map;
7. public class ClassPathXmlApplicationContext implements ApplicationContext {
10.     // 解析myspring.xml文件，然后实例化Bean，将Bean存放到singletonObjects集合当中
11.     private Map<String, Object> singletonObjects = new HashMap<>();
13.     }
16.     @Override
17.     public Object getBean(String beanName) {
18.         return singletonObjects.get(beanName);
19.     }
20. }

复制代码

3.7 第七步：剖析配置文件，并实例化所有Bean

在 ClassPathXmlApplicationContext 的构造方法中剖析配置文件，获取所有bean的类名，通过反射机制调用无参数构造方法创建Bean。并且将Bean对象存放到Map聚集中。
增补:

首先我们需要，获取到一个名为 SAXReader(这是dom4j 剖析xml 文件的核心对象) 的对象以及Document ，用来读取我们当中的myspring.xml'所含的 bean 的配置信息。这两个对象可以读取到 xml 配置文件的信息。

同时需要：注意的是：在 java 当中一个 ”//“ 才体现为一个 / 。

注意一个向下转型：向下转型的目标是为了使用Element接口更加丰富的方法。
该 Element 可以获取到  标签当中的 id 的属性值，和 标签当中的 class 属性的值

1. package org.myspringframework.core;
3. import org.dom4j.Document;
4. import org.dom4j.Element;
5. import org.dom4j.Node;
6. import org.dom4j.io.SAXReader;
7. import org.slf4j.Logger;
8. import org.slf4j.LoggerFactory;
10. import java.io.InputStream;
11. import java.lang.reflect.Constructor;
12. import java.lang.reflect.Field;
13. import java.lang.reflect.Method;
14. import java.util.HashMap;
15. import java.util.List;
16. import java.util.Map;
19. public class ClassPathXmlApplicationContext implements ApplicationContext {
22.     // 解析myspring.xml文件，然后实例化Bean，将Bean存放到singletonObjects集合当中
23.     private Map<String, Object> singletonObjects = new HashMap<>();
25.     /**
26.      * 解析myspring的配置文件，然后初始化所有的Bean对象
27.      *
28.      * @param configLocation spring配置文件的路径，注意：使用的是ClassPathXmlApplicationContext ,所以
29.      *                       配置文件应当放到类路径下
30.      */
31.     public ClassPathXmlApplicationContext(String configLocation) {
32.         // 解析myspring.xml文件，然后实例化Bean，将Bean存放到singletonObjects集合当中
33.         // 这是dom4j 解析xml 文件的核心对象
34.         SAXReader saxReader = new SAXReader();
35.         Logger logger = LoggerFactory.getLogger(ClassPathXmlApplicationContext.class);
38.         // 获取一个输入流，指向配置文件
39.         InputStream in = ClassLoader.getSystemClassLoader().getResourceAsStream(configLocation);
40.         try {
41.             // 读文件
42.             Document document = saxReader.read(in);
44.             // 获取到所有的 <bean>标签
45.             // 注意要两个//，才能表示一个 /
46.             List<Node> nodes = document.selectNodes("//bean");
48.             // 遍历 bean标签
49.             nodes.forEach(node -> {
50.                 //System.out.println(node);
51.                 // 向下转型的目的是为了使用Element接口更加丰富的方法
52.                 Element beanElt = (Element) node;
54.                 // 获取 <bean>标签当中的id的属性
55.                 String id = beanElt.attributeValue("id");
57.                 // 获取 <bean>标签当中的 class 属性
58.                 String className = beanElt.attributeValue("class");
59.                 //logger.info("beanName" + id);
60.                 //logger.info("beanClassName " + className);
62.                 try {
63.                     // 通过反射机制创建对象，将其放到Map集合中，提前曝光
64.                     // 获取class对象
65.                     Class<?> aClass = Class.forName(className);
66.                     // 获取无参构造方法实例化Bean
67.                     Constructor<?> declaredCon = aClass.getDeclaredConstructor();
68.                     // 调用无参构造方法实例化Bean
69.                     Object bean = declaredCon.newInstance();
70.                     // 将Bean 曝光，加入 Map集合
71.                     singletonObjects.put(id, bean);
72.                     // 记录日志
73.                     logger.info(singletonObjects.toString());
74.                 } catch (Exception e) {
75.                 e.printStackTrace();
76.             }
77.         });
78.     } catch (Exception e) {
79.         e.printStackTrace();
80.     }
81. }
83.     @Override
84.     public Object getBean(String beanName) {
85.         return singletonObjects.get(beanName);
86.     }
87. }

复制代码

3.8 第八步：测试可否获取到Bean

1. package com.rainbowsea.myspring.test;
3. import com.rainbowsea.myspring.bean.UserService;
4. import org.junit.Test;
5. import org.myspringframework.core.ApplicationContext;
6. import org.myspringframework.core.ClassPathXmlApplicationContext;
8. public class MySpringTest {
9.     @Test
10.     public void testMySpring() {
11.         ApplicationContext applicationContext = new ClassPathXmlApplicationContext("myspring.xml");
12.         Object user = applicationContext.getBean("user");
13.         System.out.println(user);
15.     }
16. }

复制代码

我们的 myspring.xml 配置文件当中，有三个 bean 对象的配置信息，所以下面应当显示三个 Bean的实例对象。如下显示结果，我们可以看出，是成功获取到了 myspring.xml 配置文件当中所有的 Bean 对象了。

通过测试Bean已经实例化成功了，属性的值是null，这是我们能够想到的，究竟我们调用的是无参数构造方法，所以属性都是默认值。
下一步就是我们应该如何给Bean的属性赋值了。
3.9 第九步：给Bean的属性赋值

通过反射机制调用set方法，给Bean的属性赋值。
继承在ClassPathXmlApplicationContext构造方法中编写代码。
增补分析:

我们需要，再次重新把所有的 Bean 标签遍历一次，这一次重要是给对象属性赋值的

获取到 获取该标签下的所有的属性为 标签，由于 在  标签当中存放着，我们对属性赋值要的确切的值。

赋值，这里我们是通过 set 方法举行赋值的，这个简单，我们可以通过反射(对象,方法名，方法参数类型)获取到方法的对象，又可以通过属性名，获取到属性的类型。

这里最难的部分就是，在我们的 在  标签当中存放着，我们对属性赋值要的确切的值。但是这个值有两种：简单类型 value 的值，复杂类型 ref 的值。复杂类型就是引用类型，这个我们以及在曝光的时候，就存储到Map当中去了，我们只需要通过对应的beanName 从 Map当前取出来，再通过反射机制调用set方法举行一个赋值。

简单类型的赋值操纵：
简单类型的复杂点，就是一个转换，我们再 myspring.xml 配置文件当中的，属性值都是以字符串的形式存在的，而我们的现实属性的类型，大概是 int，char，double 等等类型的，String 字符串类型不可以直接赋值到其他 int，char 类型当中去，所以我们就需要对我们所赋值的属性举行一个判断，假如该类型是 int 类型，我们就需要将 String 字符串类型转换为我们所需要的 int 类型。
这里我们分析一下：

1. 我们myspring框架说明以下，我们只支持这些类型为简单类型
2. byte short int long float double boolean char
3. Byte Short Intger Long Float Double Boolean Character
4. String
5. */

复制代码

完备代码：

1. package org.myspringframework.core;
3. import org.dom4j.Document;
4. import org.dom4j.Element;
5. import org.dom4j.Node;
6. import org.dom4j.io.SAXReader;
7. import org.slf4j.Logger;
8. import org.slf4j.LoggerFactory;
10. import java.io.InputStream;
11. import java.lang.reflect.Constructor;
12. import java.lang.reflect.Field;
13. import java.lang.reflect.Method;
14. import java.util.HashMap;
15. import java.util.List;
16. import java.util.Map;
19. public class ClassPathXmlApplicationContext implements ApplicationContext {
22.     // 解析myspring.xml文件，然后实例化Bean，将Bean存放到singletonObjects集合当中
23.     private Map<String, Object> singletonObjects = new HashMap<>();
25.     /**
26.      * 解析myspring的配置文件，然后初始化所有的Bean对象
27.      *
28.      * @param configLocation spring配置文件的路径，注意：使用的是ClassPathXmlApplicationContext ,所以
29.      *                       配置文件应当放到类路径下
30.      */
31.     public ClassPathXmlApplicationContext(String configLocation) {
32.         // 解析myspring.xml文件，然后实例化Bean，将Bean存放到singletonObjects集合当中
33.         // 这是dom4j 解析xml 文件的核心对象
34.         SAXReader saxReader = new SAXReader();
35.         Logger logger = LoggerFactory.getLogger(ClassPathXmlApplicationContext.class);
38.         // 获取一个输入流，指向配置文件
39.         InputStream in = ClassLoader.getSystemClassLoader().getResourceAsStream(configLocation);
40.         try {
41.             // 读文件
42.             Document document = saxReader.read(in);
44.             // 获取到所有的 <bean>标签
45.             // 注意要两个//，才能表示一个 /
46.             List<Node> nodes = document.selectNodes("//bean");
48.             // 遍历 bean标签
49.             nodes.forEach(node -> {
50.                 //System.out.println(node);
51.                 // 向下转型的目的是为了使用Element接口更加丰富的方法
52.                 Element beanElt = (Element) node;
54.                 // 获取 <bean>标签当中的id的属性
55.                 String id = beanElt.attributeValue("id");
57.                 // 获取 <bean>标签当中的 class 属性
58.                 String className = beanElt.attributeValue("class");
59.                 //logger.info("beanName" + id);
60.                 //logger.info("beanClassName " + className);
62.                 try {
63.                     // 通过反射机制创建对象，将其放到Map集合中，提前曝光
64.                     // 获取class对象
65.                     Class<?> aClass = Class.forName(className);
66.                     // 获取无参构造方法实例化Bean
67.                     Constructor<?> declaredCon = aClass.getDeclaredConstructor();
68.                     // 调用无参构造方法实例化Bean
69.                     Object bean = declaredCon.newInstance();
70.                     // 将Bean 曝光，加入 Map集合
71.                     singletonObjects.put(id, bean);
72.                     // 记录日志
73.                     //logger.info(singletonObjects.toString());
74.                     //System.out.println(singletonObjects.toString());
75.                 } catch (Exception e) {
76.                     e.printStackTrace();
77.                     throw new RuntimeException(e);
78.                 }
81.             });
83.             // 再次重新把所有的 Bean 标签遍历一次，这一次主要是给对象属性赋值的
84.             nodes.forEach(node -> {
85.                 Element beanElt = (Element) node;
86.                 // 获取 <bean>标签当中的 id 属性
87.                 String id = beanElt.attributeValue("id");
89.                 // 获取<bean>标签当中的 class 属性的值
90.                 String className = beanElt.attributeValue("class");
92.                 // 获取Class 对象通过全限定类名+反射机制
95.                 try {
96.                     Class<?> aClass = Class.forName(className);
97.                     // 获取该<bean>标签下的所有的属性为 <property>标签
98.                     List<Element> propertys = beanElt.elements("property");
99.                     // 遍历<property> 的所有的属性标签
100.                     propertys.forEach(property -> {
101.                         // 获取 <property> 标签下的name 属性名下的值
102.                         String propertyName = property.attributeValue("name");
103.                         //logger.info(" <property> 标签下的name 属性名 " + propertyName);
104.                         // 获取 <property> 标签下的name 属性名下的值
106.                         // 获取 set 方法名 set+属性名第一个单词大写
107.                         String setMethodName = "set" + propertyName.toUpperCase().charAt(0) + propertyName.substring(1);
109.                         try {
110.                             //获取 set 方法
111.                             // 获取属性类型，通过属性名，可以获取到属性类型
112.                             Field declaredField = aClass.getDeclaredField(propertyName);
113.                             // 获取set方法
114.                             Method setMethod = aClass.getDeclaredMethod(setMethodName, declaredField.getType());
115.                             // 调用set方法(set方法没有返回值)
117.                             // 获取 <property> 标签当中的 value 或者是 ref 的具体的值
118.                             String value = property.attributeValue("value");
119.                             String ref = property.attributeValue("ref");
121.                             Object actualValue = null; // 真值
122.                             if (value != null) {
123.                                 // 说明在<property> 标签当中  这个值是简单类型
124.                                 /*
125.                                 我们myspring框架说明以下，我们只支持这些类型为简单类型
126.                                 byte short int long float double boolean char
127.                                 Byte Short Intger Long Float Double Boolean Character
128.                                 String
129.                                  */
130.                                 // 获取属性类型名
131.                                 String propertyTypeSimpleName = declaredField.getType().getSimpleName();
132.                                 switch (propertyTypeSimpleName) {
133.                                     case "byte":
134.                                         actualValue = Byte.parseByte(value);
135.                                         break;
136.                                     case "short":
137.                                         actualValue = Short.parseShort(value);
138.                                         break;
139.                                     case "int":
140.                                         actualValue = Integer.parseInt(value);
141.                                         break;
142.                                     case "long":
143.                                         actualValue = Long.parseLong(value);
144.                                         break;
145.                                     case "float":
146.                                         actualValue = Float.parseFloat(value);
147.                                         break;
148.                                     case "double":
149.                                         actualValue = Double.parseDouble(value);
150.                                         break;
151.                                     case "boolean":
152.                                         actualValue = Boolean.parseBoolean(value);
153.                                         break;
154.                                     case "char":
155.                                         actualValue = value.charAt(0);
156.                                         break;
157.                                     case "Byte":
158.                                         actualValue = Byte.valueOf(value);
159.                                         break;
160.                                     case "Short":
161.                                         actualValue = Short.valueOf(value);
162.                                         break;
163.                                     case "Integer":
164.                                         actualValue = Integer.valueOf(value);
165.                                         break;
166.                                     case "Long":
167.                                         actualValue = Long.valueOf(value);
168.                                         break;
169.                                     case "Float":
170.                                         actualValue = Float.valueOf(value);
171.                                         break;
172.                                     case "Double":
173.                                         actualValue = Double.valueOf(value);
174.                                         break;
175.                                     case "Boolean":
176.                                         actualValue = Boolean.valueOf(value);
177.                                         break;
178.                                     case "Character":
179.                                         // char 仅仅只是一个字符，所以要获取第一个字符
180.                                         actualValue = value.charAt(0);
181.                                         break;
182.                                     case "String":
183.                                         actualValue = value;
184.                                         break;
187.                                 }
188.                                 setMethod.invoke(singletonObjects.get(id), actualValue);
189.                             }
191.                             if (ref != null) {
192.                                 // 说明这个值是非简单类型
193.                                 // 因为是非简单类型，那么它提前曝光的，就存放到了集合当前去了。
194.                                 setMethod.invoke(singletonObjects.get(id), singletonObjects.get(ref));
196.                             }
197.                         } catch (Exception e) {
198.                             throw new RuntimeException(e);
199.                         }
200.                     });
202.                 } catch (ClassNotFoundException e) {
203.                     throw new RuntimeException(e);
204.                 }
206.             });
209.         } catch (Exception e) {
210.             e.printStackTrace();
211.             throw new RuntimeException(e);
212.         }
215.     }
218.     @Override
219.     public Object getBean(String beanName) {
220.         return singletonObjects.get(beanName);
221.     }
222. }

复制代码

3.10 第十步：测试是否能够正常赋值成功

注意： 不要导错包了，我们这里导入的是，我们自己手写的Spring框架的包。

3.11 第十一步：打包发布

将多余的类以及配置文件删除，当然，我们这里并不是真正的开发 Spring 框架，所以不删除也是没有关系的（只是需要注意不要导错jar 包了）。这里我们使用maven打包发布。关于 Maven 的使用上的内容，想要相识更多的。大家可以移步：✏️✏️✏️ Maven_ChinaRainbowSea的博客-CSDN博客。各种细节内容都是截屏标志了的，这个大家放心。

3.12 第十二步: 站在程序员角度使用我们自己手写的 spring 的 myspring框架

第一步： 我们新建一个名为： myspring-text 的模块，举行一个我们手写的Spring 的框架的测试。

第二步： 引入我们自己编写的Spring 框架，不要引错了。

第三步： 编写预备一些Bean 对象用于测试，我们自己编写的 Spring 框架

1. package com.rainbowsea.myspring.bean;
3. public class Vip {
5.     private String name;
6.     private int age;
7.     private double height;
10.     public void setName(String name) {
11.         this.name = name;
12.     }
14.     public void setAge(int age) {
15.         this.age = age;
16.     }
18.     public void setHeight(double height) {
19.         this.height = height;
20.     }
22.     @Override
23.     public String toString() {
24.         return "Vip{" +
25.                 "name='" + name + '\'' +
26.                 ", age=" + age +
27.                 ", height=" + height +
28.                 '}';
29.     }
30. }

复制代码

1. package com.rainbowsea.myspring.bean;
3. public class OrderDao {
4.     public void insert() {
5.         System.out.println("插入数据");
6.     }
7. }

复制代码

1. package com.rainbowsea.myspring.bean;
3. public class OrderService {
4.     private OrderDao orderDao;
6.     public void setOrderDao(OrderDao orderDao) {
7.         this.orderDao = orderDao;
8.     }
10.     public void generate() {
11.         orderDao.insert();
12.     }
13. }

复制代码

第四步： 运行，测试，我们编写的Spring 的框架是否成功。
注意：导入的是我们自己编写的Spring 框架。不要导错了。

从我们的运行结果上看，我们编写的Spring 框架是没有问题的。
4. 总结:

• 框架一样平常是由 设计模式+注解+反射 来实现，并举行运用开发的。而这里我们的Spring IoC容器的实现原理：工厂模式 + 剖析XML + 反射机制。
  
• 我们知道，想要调用一个方法，就需要明确知道该方法的四个要素：
  

  
  
  • 调用的是哪个对象的
    
  • 哪个方法
    
  • 该方法传什么参数
    
  • 有无返回值，有返回值的话，又该返回什么值
    

  
  
• 引入 dom4j 和 jaxen的依赖，由于要使用它剖析XML文件, SAXReader(这是dom4j 剖析xml 文件的核心对象) 的对象以及Document ，用来读取我们当中的myspring.xml'所含的 bean 的配置信息。这两个对象可以读取到 xml 配置文件的信息。
  
  
  
  
• 编写Spring 框架比较难的点，就是：简单类型的复杂点，就是一个转换，我们再 myspring.xml 配置文件当中的，属性值都是以字符串的形式存在的，而我们的现实属性的类型，大概是 int，char，double 等等类型的，String 字符串类型不可以直接赋值到其他 int，char 类型当中去，所以我们就需要对我们所赋值的属性举行一个判断，假如该类型是 int 类型，我们就需要将 String 字符串类型转换为我们所需要的 int 类型。
  
• 注意：我们手写的Spring 框架不并不是完完全全按照，真正的Spring框架来编写的，这是大部分思路是一致的，对应差别需要上的处理大概不太一致，这一点希望大家可以明白。
  
• 我们手写Spring 框架是为了，更好的理解Spring 框架的原理，从而不惧怕Spring的使用，在使用上更加的机动，得心易手。
  

5. 最后:

“在这个最后的篇章中，我要表达我对每一位读者的感激之情。你们的关注和回复是我创作的动力源泉，我从你们身上吸取了无尽的灵感与勇气。我会将你们的鼓励留在心底，继承在其他的领域奋斗。感谢你们，我们总会在某个时刻再次相遇。”

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。