【Spring】手写 Spring 框架 IoC-阿里云开发者社区

Spring 相关文章整理汇总归纳于：https://www.yuque.com/u27599042/zuisie

回顾反射机制

调用方法的四要素

调用方法的四要素

第一要素：使用哪个对象进行方法的调用
第二要素：调用对象的哪个方法
第三要素：调用方法的时候，需要传递什么参数
第四要素：方法执行结束之后的返回结果

总结：调用哪个对象的哪个方法，需要传递什么参数，该方法返回什么值
即使是使用反射机制进行方法的调用，也同样需要具备着四要素

反射机制调用方法

/**
 * ClassName: SomeService
 * Package: PACKAGE_NAME
 * Description:
 *
 * @Author tcw
 * @Create 2023-05-27 10:46
 * @Version 1.0
 */
public class SomeService {
    public void doSome() {
        System.out.println(" public void doSome() 执行");
    }
    public String doSome(String s) {
        System.out.println(" public void doSome(String s) 执行");
        return s;
    }
    public String doSome(String s, Integer i) {
        System.out.println(" public void doSome(String s, Integer i) 执行");
        return s + " " + i;
    }
}

import java.lang.reflect.Method;
/**
 * ClassName: Main
 * Package: PACKAGE_NAME
 * Description:
 *
 * @Author tcw
 * @Create 2023-05-27 10:45
 * @Version 1.0
 */
public class Main {
    public static void main(String[] args) throws Exception {
        // 加载类，获取类对应的Class对象
        Class<?> someServiceClass = Class.forName("SomeService");
        // 创建对象
        // 调用类的无参构造方法创建对象
        SomeService someService = (SomeService) someServiceClass.getDeclaredConstructor().newInstance();
        // 获取方法 public String doSome(String s, Integer i)
        // 参数一：获取方法的方法名
        // 参数二：可变参数，获取方法的形参列表类型
        Method doSomeMethod = someServiceClass.getDeclaredMethod("doSome", String.class, Integer.class);
        // 调用方法（四要素：调用哪个对象的哪个方法，需要传递什么参数，该方法返回什么值）
        // 参数一：调用哪个对象的该方法  someService
        // 参数二：可变参数，调用方法需要传递的形参  "Hello World", 111
        // invoke 的返回值就是调用方法的返回值  Object res
        Object res = doSomeMethod.invoke(someService, "Hello World", 111);
        System.out.println(res);
    }
}

Spring DI 核心实现

需求：假设你现在已知以下信息：

1.有这样一个类，类名叫做：包名.User
2.这个类符合javabean规范。属性私有化，对外提供公开的setter和getter方法。
3.你还知道这个类当中有一个属性，属性的名字叫做 age
4.并且你还知道age属性的类型是int类型。

请使用反射机制调用set方法，给User对象的age属性赋值。

package cw.study.spring.pojo;
/**
 * ClassName: User
 * Package: cw.study.spring.pojo
 * Description:
 *
 * @Author tcw
 * @Create 2023-05-28 9:59
 * @Version 1.0
 */
public class User {
    private String name;
    private int age;
    public User() {
    }
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "User{" + "name='" + name + '\'' + ", age=" + age + '}';
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

import cw.study.spring.pojo.User;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
/**
 * ClassName: Main
 * Package: PACKAGE_NAME
 * Description:
 *
 * @Author tcw
 * @Create 2023-05-27 10:45
 * @Version 1.0
 */
public class Main {
    public static void main(String[] args) throws Exception {
        // 1.有这样一个类，类名叫做：包名.User
        String className = "cw.study.spring.pojo.User";
        // 2.这个类符合javabean规范。属性私有化，对外提供公开的setter和getter方法。
        // 3.你还知道这个类当中有一个属性，属性的名字叫做 age
        String fieldName = "age";
        // 4.并且你还知道age属性的类型是int类型。
        // 请使用反射机制调用set方法，给User对象的age属性赋值。
        // 加载类
        Class<?> userClass = Class.forName(className);
        // 创建对象
        User user = (User) userClass.getDeclaredConstructor().newInstance();
        // 获取属性
        Field field = userClass.getDeclaredField(fieldName);
        // 获取属性的类型
        Class<?> fieldType = field.getType();
        // 获取方法名
        String methodName = "set" + fieldName.toUpperCase().charAt(0) + fieldName.substring(1);
        // 获取方法
        Method method = userClass.getDeclaredMethod(methodName, fieldType);
        // 调用方法
        method.invoke(user, 22);
        System.out.println(user);
    }
}

手写 Spring 框架 IoC

Spring IoC 的实现原理：工厂模式 + 解析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>cw.study.spring</groupId>
  <artifactId>spring-study-011-myspring</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>jar</packaging>
  <dependencies>
    <!-- dom4j 解析XML文件 -->
    <dependency>
      <groupId>org.dom4j</groupId>
      <artifactId>dom4j</artifactId>
      <version>2.1.3</version>
    </dependency>
    <!-- jaxen 需要使用xpath -->
    <dependency>
      <groupId>jaxen</groupId>
      <artifactId>jaxen</artifactId>
      <version>1.2.0</version>
    </dependency>
    <!-- 单元测试 -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.13.2</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
  <properties>
    <maven.compiler.source>17</maven.compiler.source>
    <maven.compiler.target>17</maven.compiler.target>
  </properties>
</project>

JavaBean

这些JavaBean是使用框架的用户写的

package cw.study.spring.bean;
/**
 * ClassName: User
 * Package: cw.study.spring.bean
 * Description:
 *
 * @Author tcw
 * @Create 2023-05-31 12:06
 * @Version 1.0
 */
public class User {
    private String name;
    private Integer age;
    public User() {
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "User{" + "name='" + name + '\'' + ", age=" + age + '}';
    }
}

package cw.study.spring.bean;
/**
 * ClassName: UserDao
 * Package: cw.study.spring.bean
 * Description:
 *
 * @Author tcw
 * @Create 2023-05-31 12:07
 * @Version 1.0
 */
public class UserDao {
    public void insert() {
        System.out.println("数据库正在保存用户信息...");
    }
}

package cw.study.spring.bean;
/**
 * ClassName: UserService
 * Package: cw.study.spring.bean
 * Description:
 *
 * @Author tcw
 * @Create 2023-05-31 14:08
 * @Version 1.0
 */
public class UserService {
    private UserDao userDao;
    public void save() {
        userDao.insert();
    }
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
}

配置文件

这个配置文件是使用框架的用户写的

<?xml version="1.0" encoding="UTF-8" ?>
<beans>
  <bean id="user" class="cw.study.spring.bean.User">
    <property name="name" value="张三"/>
    <property name="age" value="21"/>
  </bean>
  <bean id="userDao" class="cw.study.spring.bean.UserDao"/>
  <bean id="userService" class="cw.study.spring.bean.UserService">
    <property name="userDao" ref="userDao"/>
  </bean>
</beans>

Spring 框架核心接口实现 ApplicationContext

package org.myspringframework.core;
/**
 * ClassName: ApplicationContext
 * Package: org.myspringframework.core
 * Description:
 * MySpring框架应用上下文接口
 *
 * @Author tcw
 * @Create 2023-05-31 14:22
 * @Version 1.0
 */
public interface ApplicationContext {
    /**
     * 通过Bean的id从容器中获取相应的Bean对象
     *      Bean的名称就是配置文件中Bean的id
     *
     * @param beanName Bean的id
     * @return Bean对象
     */
    Object getBean(String beanName);
}

Spring 框架核心接口实现类 ClassPathXmlApplicationContext

package org.myspringframework.core;
import org.dom4j.*;
import org.dom4j.io.SAXReader;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
 * ClassName: ClassPathXmlApplicationContext
 * Package: org.myspringframework.core
 * Description:
 *
 * @Author tcw
 * @Create 2023-05-31 14:25
 * @Version 1.0
 */
public class ClassPathXmlApplicationContext implements ApplicationContext{
    // 用于存放Bean对象的map集合，使用Bean的名称可以获取相应的Bean对象
    private Map<String, Object> singletonObjects = new HashMap<>();
    /**
     * 根据Spring配置文件创建Spring容器的构造方法
     * 该方法一执行就会对配置文件进行解析创建Bean对象
     * 使用ClassPathXmlApplicationContext，配置文件应该放在类路径下
     *
     * @param configLocation Spring配置文件的路径
     */
    public ClassPathXmlApplicationContext(String configLocation) {
        try {
            // 解析XML核心配置文件，实例化Bean，将Bean存放到map集合中
            // 获取dom4j解析xml文件的核心对象，读取xml文件中的内容
            SAXReader reader = new SAXReader();
            // 获取xml的输入流，通过类加载器以流的方式获取资源
            InputStream inputStream = ClassLoader.getSystemClassLoader().getResourceAsStream(configLocation);
            // 读取xml文件中的内容，获取xml对应的文档对象
            Document document = reader.read(inputStream);
            // 获取xml文件中所有的bean标签
            List<Node> beansNode = document.selectNodes("//bean");
            // 遍历所有的bean标签，创建相应的对象放到容器中
            beansNode.forEach(bean->{
                try {
                    // System.out.println(bean);
                    // org.dom4j.tree.DefaultElement@74ad1f1f
                    // bean实际上是Element类型，向下转型，因为Element中方法更丰富
                    Element beanElement = (Element) bean;
                    // 获取Bean id
                    String id = beanElement.attributeValue("id");
                    // 获取bean的类型
                    String className = beanElement.attributeValue("class");
                    // System.out.println(id + ": " + className);
                    // 利用反射机制进行对象的创建，并放到map集合中，进行提前曝光
                    Object beanInstance = createBeanObjectByReflect(className);
                    // 将创建的对象放入map集合中进行曝光
                    singletonObjects.put(id, beanInstance);
                    // System.out.println(singletonObjects);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            });
            // 再次遍历所有的bean标签，为创建的所有bean对象进行属性的赋值
            beansNode.forEach(bean->{
                try {
                    // 进行强转
                    Element beanElement= (Element) bean;
                    // 获取bean的id
                    String id = beanElement.attributeValue("id");
                    // // 判断bean是否已经被创建了
                    // if (!singletonObjects.containsKey(id)) {
                    //     // 如果没有创建bean对象，则进行bean对象的创建
                    //     Object beanInstance = createBeanObjectByReflect(className);
                    // }
                    // 获取bean的类名
                    String className = beanElement.attributeValue("class");
                    // 加载类
                    Class<?> clazz = Class.forName(className);
                    // 获取bean标签中的所有子标签属性标签
                    List<Element> properties = beanElement.elements("property");
                    // 遍历bean标签中的所有子标签属性标签，为bean的属性进行赋值
                    properties.forEach(property->{
                        try {
                            // 获取property标签的name属性值，获取要为哪个属性赋值
                            String fieldName = property.attributeValue("name");
                            // 获取property标签的value属性值，获取要为属性赋的值(标签中如果无value，返回null)
                            String fieldValue = property.attributeValue("value");
                            // 获取property标签的ref属性值，获取要为属性赋的值(标签中如果无ref，返回null)
                            String ref = property.attributeValue("ref");
                            // System.out.println(fieldName + " = " + fieldValue);
                            // 获取set方法的方法名
                            String setMethodName = "set" + fieldName.toUpperCase().charAt(0) + fieldName.substring(1);
                            // 获取set方法对应的属性的类型
                            Class<?> fieldType = clazz.getDeclaredField(fieldName).getType();
                            // 获取set方法
                            Method setMethod = clazz.getDeclaredMethod(setMethodName, fieldType);
                            // 如果属性的值是通过value进行赋值
                            if (fieldValue != null) {
                                // 值为简单类型
                                // 调用id对应的bean对象的set方法(set方法无返回值)
                                // 从标签的属性中获取的值都为字符串类型，但是set方法需要的参数有具体的数据类型，需要进行处理
                                // 获取set方法参数的简单类型名
                                String fieldTypeSimpleName = fieldType.getSimpleName();
                                String propertyValue = fieldValue; // 简单类型的属性值
                                // 进行数据类型匹配，对参数进行类型转换
                                Object propertyVal = null;
                                switch (fieldTypeSimpleName) {
                                    case "byte": case "Byte":
                                        propertyVal = Byte.valueOf(propertyValue);
                                        break;
                                    case "short": case "Short":
                                        propertyVal = Short.valueOf(propertyValue);
                                        break;
                                    case "int": case "Integer":
                                        propertyVal = Integer.valueOf(propertyValue);
                                        break;
                                    case "long": case "Long":
                                        propertyVal = Long.valueOf(propertyValue);
                                        break;
                                    case "float": case "Float":
                                        propertyVal = Float.valueOf(propertyValue);
                                        break;
                                    case "double": case "Double":
                                        propertyVal = Double.valueOf(propertyValue);
                                        break;
                                    case "boolean": case "Boolean":
                                        propertyVal = Boolean.valueOf(propertyValue);
                                        break;
                                    case "char": case "Character":
                                        propertyVal = propertyValue.charAt(0);
                                        break;
                                    case "String":
                                        propertyVal = propertyValue;
                                        break;
                                }
                                // 调用id对应的bean对象的set方法(set方法无返回值)
                                setMethod.invoke(singletonObjects.get(id), propertyVal);
                            }
                            // 如果属性的值是通过ref进行赋值
                            if (ref != null) {
                                // 值为非简单类型
                                // 调用id对应的bean对象的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();
        }
    }
    /**
     * 通过反射机制进行相应类的对象的创建
     *
     * @param className 类的全限定类名
     * @return 类的对象
     * @throws Exception 异常
     */
    private Object createBeanObjectByReflect(String className) throws Exception {
        // 加载类
        Class<?> clazz = Class.forName(className);
        // 获取类的无参构造器创建对象
        return clazz.getDeclaredConstructor().newInstance();
    }
    /**
     * 根据bean的id获取bean对象
     *
     * @param beanName Bean的id
     * @return bean对象
     */
    @Override
    public Object getBean(String beanName) {
        return singletonObjects.get(beanName);
    }
}

MySpring 框架测试

@org.junit.Test
public void test01() {
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("myspring.xml");
    UserService userService = (UserService) applicationContext.getBean("userService");
    userService.save();
    User user = (User) applicationContext.getBean("user");
    System.out.println(user);
}

【Spring】手写 Spring 框架 IoC

回顾反射机制

调用方法的四要素

反射机制调用方法

Spring DI 核心实现

手写 Spring 框架 IoC

环境准备

创建模块

打包方式与依赖引入

JavaBean

配置文件

Spring 框架核心接口实现 ApplicationContext

Spring 框架核心接口实现类 ClassPathXmlApplicationContext

MySpring 框架测试

热门文章

最新文章

相关课程

相关电子书

相关实验场景