Spring学习记录----手写Spring框架

╰半橙微兮° 2024-03-17 22:45 92阅读 0赞

**目录**

11、手写Spring框架

第一步：创建模块myspring

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

第三步：准备myspring.xml配置文件和log4j2.xml配置文件

第四步：编写ApplicationContext接口

第五步：编写ClassPathXmlApplicationContext

第六步：确定采用Map集合存储Bean

第七步：解析配置文件实例化所有Bean

第八步：测试能否获取到Bean

第九步：给Bean的属性赋值

执行测试程序：

第十步：打包发布

删得只剩下：

打包：

找到仓库:

第十一步：站在程序员角度使用myspring框架

新建模块：myspring-test

引入myspring框架的依赖（我们自己手写的）：

编写Bean

编写myspring.xml文件

编写测试程序

运行结果：

--------------------

## 11、手写Spring框架 ##

### 第一步：创建模块myspring ###

![b884335d74ac423b893c3aedd2feaa20.png][]

打包方式采用jar，并且引入dom4j和jaxen的依赖，因为要使用它解析XML文件，还有junit依赖。

pom.xml：

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>org.myspringframework</groupId>
        <artifactId>myspring</artifactId>
        <version>1.0.0</version>
        <packaging>jar</packaging>
    
        
        <dependencies>
            
            <dependency>
                <groupId>org.dom4j</groupId>
                <artifactId>dom4j</artifactId>
                <version>2.1.3</version>
            </dependency>
    
            <dependency>
                <groupId>jaxen</groupId>
                <artifactId>jaxen</artifactId>
                <version>1.2.0</version>
            </dependency>
    
            
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.12</version>
                <scope>test</scope>
            </dependency>
    
            
            <dependency>
                <groupId>org.apache.logging.log4j</groupId>
                <artifactId>log4j-core</artifactId>
                <version>2.19.0</version>
            </dependency>
            <dependency>
                <groupId>org.apache.logging.log4j</groupId>
                <artifactId>log4j-slf4j2-impl</artifactId>
                <version>2.19.0</version>
            </dependency>
        </dependencies>
    
        <properties>
            <maven.compiler.source>19</maven.compiler.source>
            <maven.compiler.target>19</maven.compiler.target>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        </properties>
    
    </project>

### 第二步：准备好我们要管理的Bean ###

*  准备好我们要管理的Bean（**这些Bean在将来开发完框架之后是要删除的**）
 *  注意包名，不要用org.myspringframework包，因为这些Bean不是框架内置的。是将来使用我们框架的程序员提供的。

**User.java:**

package com.dong.myspring.bean;
    
    public class User {
        private String name;
        private int age;
    
        public void setName(String name) {
            this.name = name;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

UserDao.java:

package com.dong.myspring.bean;
    
    public class UserDao {
        public void insert(){
            System.out.println("MySql数据库正在保存用户信息。");
        }
    }

UserService.java:

package com.dong.myspring.bean;
    
    public class UserService {
        private UserDao userDao;
    
        public void setUserDao(UserDao userDao) {
            this.userDao = userDao;
        }
    
        public void save(){
            userDao.insert();
        }
    }

### 第三步：准备myspring.xml配置文件和log4j2.xml配置文件 ###

*  将来在框架开发完毕之后，这个文件也是要删除的。因为这个配置文件的提供者应该是使用这个框架的程序员。
 *  文件名随意，我们这里叫做：myspring.xml
 *  文件放在类路径当中即可，我们这里把文件放到类的根路径下。

**myspring.xml:**

<?xml version="1.0" encoding="UTF-8"?>
    
    
    <beans>
           <bean id="user" class="com.dong.myspring.bean.User">
               <property name="name" value="张三"></property>
               <property name="age" value="30"></property>
           </bean>
    
        <bean id="userService" class="com.dong.myspring.bean.UserService">
            <property name="userDao" ref="userDaoBean"/>
        </bean>
    
        <bean id="userDaoBean" class="com.dong.myspring.bean.UserDao"></bean>
    </beans>

使用value给简单属性赋值。使用ref给非简单属性赋值。

记录日志---log4j2.xml:

<?xml version="1.0" encoding="UTF-8"?>
    <configuration>
        <loggers>
            
            <root level="DEBUG">
                <appender-ref ref="spring6log"/>
            </root>
        </loggers>
        <appenders>
            
            <console name="spring6log" target="SYSTEM_OUT">
                
                <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss SSS} [%t] %-3le
    vel %logger{1024} - %msg%n"/>
            </console>
        </appenders>
    </configuration>

### 第四步：编写ApplicationContext接口 ###

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

package org.myspringframework.core;
    
    /**
     * MySpring框架应用上下文接口
     */
    public interface ApplicationContext {
        /**
         * 根据bean的名称获取对应的bean对象
         * @param beanName myspring配置文件中bean标签的id
         * @return 对应的单例bean对象
         */
        Object getBean(String beanName);
    }

### 第五步：编写ClassPathXmlApplicationContext ###

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

package org.myspringframework.core;
    
    /**
     * @author dong
     * @version 1.0
     * @className ClassPathXmlApplicationContext
     * @since 1.0
     **/
    public class ClassPathXmlApplicationContext implements ApplicationContext{
        @Override
        public Object getBean(String beanId) {
            return null;
        }
    }

### 第六步：确定采用Map集合存储Bean ###

*  确定采用Map集合存储Bean实例。Map集合的key存储beanId，value存储Bean实例。Map<String,Object>
 *  在ClassPathXmlApplicationContext类中添加Map<String,Object>属性。
 *  并且在ClassPathXmlApplicationContext类中添加构造方法，该构造方法的参数接收myspring.xml文件。
 *  同时实现getBean方法。

package org.myspringframework.core;
    
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * @author dong
     * @version 1.0
     * @className ClassPathXmlApplicationContext
     * @since 1.0
     **/
    public class ClassPathXmlApplicationContext implements ApplicationContext{
        /**
         * 存储bean的Map集合
         */
        private Map<String,Object> beanMap = new HashMap<>();
    
        /**
         * 在该构造方法中，解析myspring.xml文件，创建所有的Bean实例，并将Bean实例存放到Map集合中。
         * @param resource 配置文件路径（要求在类路径当中）
         */
        public ClassPathXmlApplicationContext(String resource) {
    
        }
    
        @Override
        public Object getBean(String beanId) {
            return beanMap.get(beanId);
        }
    }

### 第七步：解析配置文件实例化所有Bean ###

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

/**
    * 在该构造方法中，解析myspring.xml文件，创建所有的Bean实例，并将Bean实例存放到Map集合中。
    * @param resource 配置文件路径（要求在类路径当中）
    */
    public ClassPathXmlApplicationContext(String resource) {
        try {
            SAXReader reader = new SAXReader();
            Document document = reader.read(ClassLoader.getSystemClassLoader().getResourceAsStream(resource));
            // 获取所有的bean标签
            List<Node> beanNodes = document.selectNodes("//bean");
            // 遍历集合
            beanNodes.forEach(beanNode -> {
                Element beanElt = (Element) beanNode;
                // 获取id
                String id = beanElt.attributeValue("id");
                // 获取className
                String className = beanElt.attributeValue("class");
                try {
                    // 通过反射机制创建对象
                    Class<?> clazz = Class.forName(className);
                    Constructor<?> defaultConstructor = clazz.getDeclaredConstructor();
                    Object bean = defaultConstructor.newInstance();
                    // 存储到Map集合
                    beanMap.put(id, bean);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            });
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

### 第八步：测试能否获取到Bean ###

编写测试程序。

package com.dong.myspring.Test;
    
    import com.dong.myspring.bean.UserService;
    import org.myspringframework.core.ApplicationContext;
    import org.myspringframework.core.ClassPathXmlApplicationContext;
    
    public class Test {
        @org.junit.Test
        public static void main(String[] args) {
            ApplicationContext applicationContext=new ClassPathXmlApplicationContext("myspring.xml");
    
            Object user = applicationContext.getBean("user");
            System.out.println(user);
    
            UserService userService = (UserService) applicationContext.getBean("userService");
            userService.save();
        }
    }

### 第九步：给Bean的属性赋值 ###

*  通过反射机制调用set方法，给Bean的属性赋值。
 *  继续在ClassPathXmlApplicationContext构造方法中编写代码。

package org.myspringframework.core;
    
    import org.dom4j.Document;
    import org.dom4j.Element;
    import org.dom4j.Node;
    import org.dom4j.io.SAXReader;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import java.io.InputStream;
    import java.lang.reflect.Constructor;
    import java.lang.reflect.Field;
    import java.lang.reflect.Method;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    public class ClassPathXmlApplicationContext implements ApplicationContext {
    
        private static final Logger logger = LoggerFactory.getLogger(ClassPathXmlApplicationContext.class);
        private Map<String, Object> singletonObject = new HashMap<>();
    
        /**
         * 解析myspring的配置文件，然后初始化所有的Bean对象
         *
         * @param configLocation ：spring的配置文件路径。注意：使用ClassPathXmlApplicationContext，配置文件应当放在类路径下
         */
        public ClassPathXmlApplicationContext(String configLocation) {
            try {
                //解析myspring.xml文件，然后实例化Bean，将Bean存放到singletonObject集合当中。
                //这是dom4j解析XML文件的核心对象
                SAXReader reader = new SAXReader();
                //获取一个输入流
                InputStream in = ClassLoader.getSystemClassLoader().getResourceAsStream(configLocation);
    
                //读文件
                Document document = reader.read(in);
                //获取所有Bean标签
                List<Node> nodes = document.selectNodes("//bean");
                //遍历bean标签
                nodes.forEach(node -> {
                    try {
                        //向下转型的目的是为了使用Element接口立更多的方法
                        Element beanElt = (Element) node;
                        //获取id属性
                        String id = beanElt.attributeValue("id");
                        //获取class属性
                        String className = beanElt.attributeValue("class");
                        logger.info("beanName=" + id);
                        logger.info("beanClassName=" + className);
    
                        //通过反射机制创建对象，将其放到Map集合中，提前曝光
                        //获取Class
                        Class<?> aClass = Class.forName(className);
                        //获取无参数构造方法
                        Constructor<?> defaultCon = aClass.getDeclaredConstructor();
                        //调用无参数构造方法实例化Bean
                        Object bean = defaultCon.newInstance();
                        //将Bean曝光，加入Map集合
                        singletonObject.put(id, bean);
                        //记录日志
                        logger.info(singletonObject.toString());
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    //再次重新把所有的bean标签遍历一次，这一次主要是给对象的属性赋值
                    nodes.forEach(node1 -> {
                        try {
                            Element beanElt = (Element) node1;
                            //获取id
                            String id = beanElt.attributeValue("id");
                            //获取className
                            String className = beanElt.attributeValue("class");
    
                            //获取Class
                            Class<?> aClass = Class.forName(className);
    
                            //获取该bean下的所有属性property标签
                            List<Element> properties = beanElt.elements("property");
                            //遍历所有的属性标签
                            properties.forEach(property -> {
                                try {
                                    //获取属性名
                                    String propertyName = property.attributeValue("name");
                                    //获取属性类型
                                    Field field = aClass.getDeclaredField(propertyName);
                                    logger.info("属性名：" + propertyName);
                                    //获取set方法名
                                    String setMethodName = "set" + propertyName.toUpperCase().charAt(0) + propertyName.substring(1);
                                    //获取set方法
                                    Method setMethod = aClass.getDeclaredMethod(setMethodName, field.getType());
                                    //获取具体的值
                                    String value = property.attributeValue("value");
                                    Object actualValue = null;//真值
    
                                    String ref = property.attributeValue("ref");
    
                                    if (value != null) {
                                        //说明这个值为简单类型
                                        //调用set方法(set方法没有返回值)
                                        /*
                                           我们myspring框架声明一下：我们只支持这些类型为简单类型
                                                byte short int long float double boolean char
                                                Byte Short Integer Long Float Double Boolean Character
                                                String
                                         */
                                        //获取属性类型名
                                        String propertyTypeSimpleName = field.getType().getSimpleName();
    
                                        switch (propertyTypeSimpleName) {
                                            case "byte":
                                                actualValue = Byte.parseByte(value);
                                                break;
                                            case "Byte":
                                                actualValue = Byte.valueOf(value);
                                                break;
                                            case "short":
                                                actualValue = Short.parseShort(value);
                                                break;
                                            case "Short":
                                                actualValue = Short.valueOf(value);
                                                break;
                                            case "int":
                                                actualValue = Integer.parseInt(value);
                                                break;
                                            case "Integer":
                                                actualValue = Integer.valueOf(value);
                                                break;
                                            case "long":
                                                actualValue = Long.parseLong(value);
                                                break;
                                            case "Long":
                                                actualValue = Long.valueOf(value);
                                                break;
                                            case "float":
                                                actualValue = Float.parseFloat(value);
                                                break;
                                            case "Float":
                                                actualValue = Float.valueOf(value);
                                                break;
                                            case "double":
                                                actualValue = Double.parseDouble(value);
                                                break;
                                            case "Double":
                                                actualValue = Double.valueOf(value);
                                                break;
                                            case "boolean":
                                                actualValue = Boolean.parseBoolean(value);
                                                break;
                                            case "Boolean":
                                                actualValue = Boolean.valueOf(value);
                                                break;
                                            case "char", "Character":
                                                actualValue = value.charAt(0);
                                                break;
                                            case "String":
                                                actualValue = value;
                                                break;
                                        }
    
                                        setMethod.invoke(singletonObject.get(id), actualValue);
    
                                    }
                                    if (ref != null) {
                                        //说明这个值为非简单类型
                                        //调用set方法(set方法没有返回值)
                                        if (singletonObject.get(ref) != null) {
                                            setMethod.invoke(singletonObject.get(id), singletonObject.get(ref));
                                        }
                                        /*
                                        setMethod.invoke(singletonObject.get(id), singletonObject.get(ref));
                                        //出现空指针问题，增加一个非空判断，再访问对象。
                                        */
                                    }
                                } catch (Exception e) {
                                    e.printStackTrace();
                                }
                            });
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    });
                });
            } catch (Exception e) {
                e.printStackTrace();
            }
    
        }
    
        @Override
        public Object getBean(String beanName) {
            return singletonObject.get(beanName);
        }
    }

#### 执行测试程序： ####

![8ad1addc82634b4dbfce125992750bf7.png][]

### 第十步：打包发布 ###

将多余的类以及配置文件删除，使用maven打包发布。

#### 删得只剩下： ####

![851ba5fd04ec4b3594254d854d55066b.png][]

#### 打包： ####

![image.png][]

#### 找到仓库: ####

![a0a4fc8a991f4bb2a29eb6d92957fd70.png][]

![image.png][image.png 1]

### 第十一步：站在程序员角度使用myspring框架 ###

#### 新建模块：myspring-test ####

![image.png][image.png 2]

#### 引入myspring框架的依赖（我们自己手写的）： ####

>     
>             <dependency>
>                 <groupId>org.myspringframework</groupId>
>                 <artifactId>myspring</artifactId>
>                 <version>1.0.0</version>
>             </dependency>

**pom.xml:**

#### 编写Bean ####

**Vip.java**

package com.dong.myspring.bean;
    
    public class Vip {
        private String name;
        private int age;
        private double height;
    
        @Override
        public String toString() {
            return "Vip{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    ", height=" + height +
                    '}';
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public void setHeight(double height) {
            this.height = height;
        }
    }

OrderDao.java

package com.dong.myspring.bean;
    
    public class OrderDao {
        public  void insert(){
            System.out.println("正在保存订单信息。。。。。");
        }
    }

OrderService.java

package com.dong.myspring.bean;
    
    public class OrderService {
        private OrderDao orderDao;
    
        public void setOrderDao(OrderDao orderDao) {
            this.orderDao = orderDao;
        }
    
        public void generate(){
            orderDao.insert();
        }
    }

#### 编写myspring.xml文件 ####

<?xml version="1.0" encoding="UTF-8"?>
    <beans>
    
        <bean id="vip" class="com.dong.myspring.bean.Vip">
            <property name="name" value="jackson"></property>
            <property name="age" value="30"></property>
            <property name="height" value="1.83"></property>
        </bean>
    
        <bean id="orderDaoBean" class="com.dong.myspring.bean.OrderDao"></bean>
    
        <bean id="orderService" class="com.dong.myspring.bean.OrderService">
            <property name="orderDao" ref="orderDaoBean"></property>
        </bean>
    </beans>

#### 编写测试程序 ####

package com.dong.myspring.test;
    
    import com.dong.myspring.bean.OrderService;
    import org.myspringframework.core.ApplicationContext;
    import org.myspringframework.core.ClassPathXmlApplicationContext;
    
    public class Test {
        @org.junit.Test
        public static void main(String[] args) {
            ApplicationContext applicationContext=new ClassPathXmlApplicationContext("myspring.xml");
            Object vip = applicationContext.getBean("vip");
            System.out.println(vip);
    
            OrderService orderService = (OrderService) applicationContext.getBean("orderService");
            orderService.generate();
        }
    }

#### 运行结果： ####

![e4d64d6b7f594b90aa9fdb010ccef813.png][]

![0b8f8209ec1644f1a9cfafde8d1281e3.png][]

[b884335d74ac423b893c3aedd2feaa20.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/446d74953b6a467ca267ce29e59673c7.png
[8ad1addc82634b4dbfce125992750bf7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/33ee9d03a5814ee7a2c8ef3f1e1ddf84.png
[851ba5fd04ec4b3594254d854d55066b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/8e710fe007ac4bb0a4a105f4f1ecc68c.png
[image.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/2278db272b7a430da1b364fa36a23d28.png
[a0a4fc8a991f4bb2a29eb6d92957fd70.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/94855c00b07d4410866b0748aa483912.png
[image.png 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/cf2c3e155b504302883bb91e2aa2985e.png
[image.png 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/b89e9f2ed73947308ff333b0d7a28c2f.png
[e4d64d6b7f594b90aa9fdb010ccef813.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/77f6849a8b8c4c3e9a99803536b384a8.png
[0b8f8209ec1644f1a9cfafde8d1281e3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/1de782e61fbd430b8fdf2b09fb024dcd.png