【框架源码】手写Spring框架IOC容器核心流程

要是想要了解Spring IOC底层，首先我们就得先了解什么是IOC。

IOC就是控制反转，把对象创建和对象之间的调用过程交给Spring进行管理。

使用IOC目的就是之前我们创建对象的方式都是用new的方式创建，这个方式有个缺点，被创建对象的类的位置一旦被改动，new就会报错，类与类之间的关联度太大，为了降低耦合度，将创建对象交给IOC容器处理。

IOC底层原理也是运用主要技术包括:xml解析、工厂设计模式、反射。

IOC主要是通过内部工厂类解析配置文件id属性对应的class属性，利用反射Class.forName()方法，参数是class属性值，来回去对应的类，进而获取对象。

下面我们就来用自己的方式来实现Spring IOC的核心功能点。

Spring IOC 核心功能点如下：

• 支持读取xml文件，创建多个bean
• 提供接口根据id获取容器bean
• 根据xml配置，需要支持对象注入功能
• 支持判断容器里面是否存在bean和获取class类型
• 采用适当的接口抽取和封装，使用方式和spring框架基本类似

这是我们在Spring框架中创建Bean的方式：

接下来，我们就按照Spring的这中创建Bean的方式自定义一个简易的IOC框架。

创建一个maven项目。

首先，我们先加入一个依赖，然后创建一些环境测试类，OrderMapper、OrderService、OrderServiceImpl、beans.xml。

		<!--JDOM 是一种使用 XML 的独特 Java 工具包，用于快速开发 XML 应用程序。JDOM 是一个开源项目，它基于树形结构，利用纯 Java 的技术对 XML 文档实现解析、生成、序列化及多种操作。-->
		<dependencies>
        <dependency>
            <groupId>org.jdom</groupId>
            <artifactId>jdom</artifactId>
            <version>2.0.2</version>
        </dependency>
    </dependencies>

public class OrderMapper {
    
    

    public void saveOrder(String orderNo){
    
    
        System.out.println("当前订单："+orderNo+" 已经落入数据库。");
    }

}

public interface OrderService {
    
    

    void saveOrder(String orderNo);
}

public class OrderServiceImpl implements OrderService {
    
    

  	//注意这个OrderMapper 的 set、get方法一定要写，我们一会用反射的机制去设置属性。
    private OrderMapper orderMapper;

    public OrderMapper getOrderMapper() {
    
    
        return orderMapper;
    }

    public void setOrderMapper(OrderMapper orderMapper) {
    
    
        this.orderMapper = orderMapper;
    }

    @Override
    public void saveOrder(String orderNo) {
    
    
        orderMapper.saveOrder(orderNo);
    }
}

<?xml version="1.0" encoding="UTF-8" ?>
<beans>
    <bean id="orderMapper" class="com.lixiang.mapper.OrderMapper">
    </bean>

    <bean id="orderService" class="com.lixiang.service.impl.OrderServiceImpl">
        <property name="orderMapper" bean="orderMapper" />
    </bean>
</beans>

ok，准备完测试类，我们来定义BeanFactory，仿照Spring的方式，定义几个方法。

/**
 * @author lixiang
 * @date 2023/5/22 08:26
 */
public interface BeanFactory {
    
    

    /**
     * 根据名称获取bean
     * @param name
     * @return
     */
    Object getBean(String name);

    /**
     * 判断bean是否在容器里面
     * @param name
     * @return
     */
    boolean containsBean(String name);

    /**
     * 根据名称获取bean的类型
     * @param name
     * @return
     */
    Class<?> getType(String name) ;

}

然后创建ClassPathXmlApplicationContext，上下文对象，用于加载resources下的xml文件。

/**
 * @author lixiang
 * @date 2023/5/22 08:29
 */
public class ClassPathXmlApplicationContext implements BeanFactory{
    
    


    /**
     * 定义map用于存放bean
     */
    private Map<String,Object> beans = new HashMap<>();

    public ClassPathXmlApplicationContext() throws Exception {
    
    
        //init 方法 做 解析和注入
        init();
    }

    /**
     * 初始化,核心就在这个
     */
    private void init() throws Exception {
    
    

        SAXBuilder saxBuilder = new SAXBuilder();
        //获取资源路径的xml文件
        InputStream resourceAsStream = this.getClass().getClassLoader().getResourceAsStream(fileName);
        //将xml文件构建成Document
        Document document = saxBuilder.build(resourceAsStream);
        //获取根结点的Element，对应的就是beans
        Element rootElement = document.getRootElement();
        //获取下面的bean节点
        List<Element> elements = rootElement.getChildren("bean");
        //遍历
        for (int i = 0; i < elements.size(); i++) {
    
    
            Element element = elements.get(i);
            //获取id属性
            String id = element.getAttributeValue("id");
            //获取class信息
            String clazz = element.getAttributeValue("class");
            //反射创建对象
            Object obj = Class.forName(clazz).getDeclaredConstructor().newInstance();
            //放到map中存储
            beans.put(id, obj);
            //判断属性中是否有需要注入的对象
            for(Element propertyElement: element.getChildren("property")){
    
    
                //获取名称
                String name = propertyElement.getAttributeValue("name");
                //获取bean的定义
                String bean = propertyElement.getAttributeValue("bean");
                //获取bean
                Object beanObject = beans.get(bean);
                //设置set方法
                String methodName = "set" + name.substring(0,1).toUpperCase() + name.substring(1);
                Class<?> aClass = beanObject.getClass();
                //反射将属性设置进去
                Method m = obj.getClass().getMethod(methodName,aClass);
                m.invoke(obj, beanObject);
            }
        }
    }

    @Override
    public Object getBean(String name) {
    
    
        return beans.get(name);
    }

    @Override
    public boolean containsBean(String name) {
    
    
        return beans.containsKey(name);
    }

    @Override
    public Class<?> getType(String name) {
    
    
        if(beans.containsKey(name)){
    
    
            return beans.get(name).getClass();
        }
        return null;
    }
}

创建测试主函数，按照之前Spring 创建的方式写。

/**
 * @author lixiang
 * @date 2023/5/22 08:11
 */
public class Main {
    
    
    public static void main(String[] args) throws Exception {
    
    

        String fileName= "beans.xml";
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext(fileName);

        OrderService orderService = (OrderService)applicationContext.getBean("orderService");
        orderService.saveOrder("202388474754758834");
        boolean containsBean = applicationContext.containsBean("orderService");
        System.out.println(containsBean);
        Class<?> type = applicationContext.getType("orderService");
        System.out.println(type.getName());

    }
}

我们先看运行结果，没有问题，对象被创建，并且调用方法。

那么下面我们看debug看下它是怎么执行的，核心逻辑就在于init方法。

Spring中顶层类 BeanFactory

• 最核心的接口之一，主要负责创建和管理bean对象实例，具体包括定义、加载、实例化和维护Bean之间的依赖关系等
• 主要作用
  • 加载Bean的配置信息：BeanFactory根据XML文件中定义的Bean信息构造Bean实例，并装载到容器中。
  • 实例化Bean：BeanFactory在Bean的定义信息加载后，利用Java反射机制来实例化Bean，并根据依赖关系装配Bean实例。
  • 维护Bean之间的依赖关系：BeanFactory能够自动识别Bean之间的依赖关系，实现Bean的依赖注入
  • 提供统一的配置方式：BeanFactory可以将所有Bean的配置信息放在一起，提供统一的配置入口。
  • 对Bean进行作用域管理：BeanFactory负责对Bean的作用域进行管理，如：单例、多例等。

BeanFactory 只是个接口，并不是IOC容器的具体实现，Spring容器给出了很多种实现,

• ClassPathXmlApplicationContext 使用XML配置
• AnnotationConfigApplicationContext 使用注解配置
• ApplicationContext、ConfigurableApplicationContext
• BeanFactory、ListableBeanFactory
• 总结
  • BeanFactory是顶层接口，定义多数最基础的API，称为【基础容器】
  • 对应BeanFactory的子类ApplicationContext，可以基于不同需求拓展更多的功能，称为【高级容器】
  • 这样的设计避免全部功能都集中在一个类，分散到不同接口，实现的时候根据需求选择即可