[SSM]手写Spring框架

目录

十一、手写Spring框架

第一步：创建模块myspring

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

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

第四步：核心接口实现

第五步：实例化Bean

第六步：给Bean属性赋值

第七步：测试

第八步：打包发布

第十一步：使用myspring框架

---

十一、手写Spring框架

• Spring IoC容器的实现原理：工厂模式+解析XML+反射机制。

第一步：创建模块myspring

配置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>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
        <!--使用dom4j解析XML配置文件-->
        <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>
    </dependencies>
​
    <properties>
        <maven.compiler.source>20</maven.compiler.source>
        <maven.compiler.target>20</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
​
</project>

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

• 这些Bean在将来开发完框架之后是要删除的。

User

package com.hhb.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

package com.hhb.myspring.bean;
​
public class UserDao {
    public void insert() {
        System.out.println("保存用户信息");
    }
}

UserService

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

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

• 将来在框架开发完毕之后，这个文件也是要删除的。

• 文件放在类的根路径下。

myspring.xml

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

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

第四步：核心接口实现

ApplicationContext

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

ClassPathXmlApplicationContext

package org.myspringframework.core;
​
import java.util.HashMap;
import java.util.Map;
​
public class ClassPathXmlApplicationContext implements ApplicationContext {
​
    private Map<String, Object> singletonObjects = new HashMap<>();
​
    /**
     * 解析myspring的配置文件，然后初始化所有的Bean对象
     *
     * @param configLocation spring配置文件的路径
     */
    public ClassPathXmlApplicationContext(String configLocation) {
        //解析myspring.xml文件，然后实例化Bean，将Bean存放到singletonObjects集合当中
​
    }
​
    @Override
    public Object getBean(String beanName) {
        return singletonObjects.get(beanName);
    }
}

第五步：实例化Bean

ClassPathXmlApplicationContext

package org.myspringframework.core;
​
import org.dom4j.Document;
import org.dom4j.DocumentException;
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.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> singletonObjects = new HashMap<>();
​
    /**
     * 解析myspring的配置文件，然后初始化所有的Bean对象
     *
     * @param configLocation spring配置文件的路径
     */
    public ClassPathXmlApplicationContext(String configLocation) {
        try {
            // 解析myspring.xml文件，然后实例化Bean，将Bean存放到singletonObjects集合当中。
            // 这是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集合
                    singletonObjects.put(id, bean);
                    //记录日志
                    logger.info(singletonObjects.toString());
                } catch (Exception e) {
                    e.printStackTrace();
                }
            });
        } catch (DocumentException e) {
            e.printStackTrace();
        }
    }
​
    @Override
    public Object getBean(String beanName) {
        return singletonObjects.get(beanName);
    }
}

第六步：给Bean属性赋值

package org.myspringframework.core;
​
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;
​
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;
​
/**
 * @author 动力节点
 * @version 1.0
 * @className ClassPathXmlApplicationContext
 * @since 1.0
 **/
public class ClassPathXmlApplicationContext implements ApplicationContext{
​
    private static final Logger logger = LoggerFactory.getLogger(ClassPathXmlApplicationContext.class);
​
    private Map<String, Object> singletonObjects = new HashMap<>();
​
    /**
     * 解析myspring的配置文件，然后初始化所有的Bean对象。
     * @param configLocation spring配置文件的路径。注意：使用ClassPathXmlApplicationContext，配置文件应当放到类路径下。
     */
    public ClassPathXmlApplicationContext(String configLocation) {
        try {
            // 解析myspring.xml文件，然后实例化Bean，将Bean存放到singletonObjects集合当中。
            // 这是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集合
                    singletonObjects.put(id, bean);
                    // 记录日志
                    logger.info(singletonObjects.toString());
                } catch (Exception e) {
                    e.printStackTrace();
                }
            });
​
            // 再次重新把所有的bean标签遍历一次，这一次主要是给对象的属性赋值。
            nodes.forEach(node -> {
                try {
                    Element beanElt = (Element) node;
                    // 获取id
                    String id = beanElt.attributeValue("id");
                    // 获取className
                    String className = beanElt.attributeValue("class");
                    // 获取Class
                    Class<?> aClass = Class.forName(className);
                    // 获取该bean标签下所有的属性property标签
                    List<Element> propertys = beanElt.elements("property");
                    // 遍历所有的属性标签
                    propertys.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"); // "30"
                            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 "short":
                                        actualValue = Short.parseShort(value);
                                        break;
                                    case "int":
                                        actualValue = Integer.parseInt(value);
                                        break;
                                    case "long":
                                        actualValue = Long.parseLong(value);
                                        break;
                                    case "float":
                                        actualValue = Float.parseFloat(value);
                                        break;
                                    case "double":
                                        actualValue = Double.parseDouble(value);
                                        break;
                                    case "boolean":
                                        actualValue = Boolean.parseBoolean(value);
                                        break;
                                    case "char":
                                        actualValue = value.charAt(0);
                                        break;
                                    case "Byte":
                                        actualValue = Byte.valueOf(value);
                                        break;
                                    case "Short":
                                        actualValue = Short.valueOf(value);
                                        break;
                                    case "Integer":
                                        actualValue = Integer.valueOf(value);
                                        break;
                                    case "Long":
                                        actualValue = Long.valueOf(value);
                                        break;
                                    case "Float":
                                        actualValue = Float.valueOf(value);
                                        break;
                                    case "Double":
                                        actualValue = Double.valueOf(value);
                                        break;
                                    case "Boolean":
                                        actualValue = Boolean.valueOf(value);
                                        break;
                                    case "Character":
                                        actualValue = Character.valueOf(value.charAt(0));
                                        break;
                                    case "String":
                                        actualValue = value;
                                }
​
                                setMethod.invoke(singletonObjects.get(id), actualValue);
                            }
                            if (ref != null) {
                                // 说明这个值是非简单类型
                                // 调用set方法(set方法没有返回值)
                                setMethod.invoke(singletonObjects.get(id), singletonObjects.get(ref));
                            }
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    });
                } catch (Exception e) {
                    e.printStackTrace();
                }
            });
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
​
    @Override
    public Object getBean(String beanName) {
        return singletonObjects.get(beanName);
    }
}

第七步：测试

@Test
public void test1(){
    ApplicationContext applicationContext=new ClassPathXmlApplicationContext("myspring.xml");
    Object user = applicationContext.getBean("user");
    System.out.println(user);
​
    UserService userService = (UserService) applicationContext.getBean("userService");
    userService.save();
}

第八步：打包发布

第十一步：使用myspring框架

配置pom.xml

<dependencies>
    <!--用myspring框架，需要引入依赖-->
    <dependency>
        <groupId>org.myspringframework</groupId>
        <artifactId>myspring</artifactId>
        <version>1.0.0</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.2</version>
        <scope>test</scope>
    </dependency>
</dependencies>