IOC

我们学Java的基本上都会使用Spring进行开发，而Spring中最为核心的又是IOC和AOP，接下来的内容是在学习手写Spring渐进式源码实践这本书后的学习总结，看是否我们能开发出一个mini-Spring。因为后期代码会很多，而且基本上都是在前一版的基础上进行扩展。这里我只声明每一章的目标扩展点是啥，具体从Github上获取源码：

第一章：实现一个简单的Spring Bean容器

先不深究Spring源码，我就看自己平时使用Spring时的体会，使用Spring时，通过XML配置文件或者通过注解，声明哪些类是需要注入到容器中的，到自己使用时，可以从容器中获取该类对象。那这不就是我们基础中学的Collection或者Map就能实现的操作嘛，因为我需要频繁的从容器中获取指定类对象，所以查询返回的效率需要非常高，那就我们就用Map来实现，先不要想那么多。

public class BeanFactory {
    // 用Map来存储Bean
    private Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>();
    // 获取
    public Object getBean(String name) {
        return beanDefinitionMap.get(name).getBean();
    }
    // 注册
    public void registerBeanDefinition(String name, BeanDefinition beanDefinition) {
        beanDefinitionMap.put(name, beanDefinition);
    }
}

这里我们使用BeanDefinition来包裹实际的对象，因为我们知道一个Bean不仅拥有自己属性，还拥有一些通用属性，比如：单例模式还是原型模式，Bean内需要填充的属性，这里我们只做包裹，其余的后面实现。

public class BeanDefinition {
    // 实际填充的对象
    private Object bean;
    // 省略 构造器 和 get方法。。
}

我们来测试一下：

/@Test
public void test_BeanFactory(){
    // 1.初始化 BeanFactory
    BeanFactory beanFactory = new BeanFactory();
    // 2.注入bean
    BeanDefinition beanDefinition = new BeanDefinition(new UserService());
    beanFactory.registerBeanDefinition("userService", beanDefinition);
    // 3.获取bean
    UserService userService = (UserService) beanFactory.getBean("userService");
    userService.queryUserInfo();
}

第二章：实现Bean对象的定义，注册和获取

在上面我们可以看到我是创建好了的UserService放入容器中，这和我们之前学的依赖倒置并不符合，我们应只指定哪些Bean需要加载到容器中，具体的对象实例应又BeanFactory自己管理，所以我们修改BeanDefinition，在内只存放Bean的Class对象。

public class BeanDefinition {
    private Class beanClass;
    // 构造器 get，set方法
}

BeanFactory也修改为接口，定义获取Bean的方式，具体Bean存储与获取交给子类来实现，使职责单一。

我们在这里先假设每个Bean都是单例的，创建SingletonBeanRegistry接口，定义注册和获取单例对象的方式，剩下的交给子类具体实现。

现在系统中有两个容器，一个是BeanDefinitionMap负责存储加载到容器的Bean信息，一个是singletonObjects负责存储已经创建好的单例对象。具体可看下面的UML类图，关系还是很清楚的。BeanFactory在实例化对象时，通过BeanDefinitionMap中的类信息，通过反射直接创建对象，并放入容器中。

Spring中有大量的接口与抽象类，我个人感觉是将职责划分清楚，容易未来系统的扩展性，有一点是通过抽象类去实现接口，并定义自己的抽象方法，而且可以实现一部分的接口方法，这样既可以扩容接口，又能保证自己可以只实现自己职责内的方法。

第三章：基于Cglib实现含有构造函数的类实例化策略

在第二章中我们在AbstractAutowireCapableBeanFactory::createBean中通过反射进行Bean的实例化，这一章我们引入了实例化策略：InstantiationStrategy，并通过JDK和Cglib两个种方式去实现。

JDK 和 Cglib实例化对象有什么区别

CGLib创建的动态代理对象性能比JDK创建的动态代理对象的性能高不少，但是CGLib在创建代理对象时所花费的时间却比JDK多得多，所以对于单例的对象，因为无需频繁创建对象，用CGLib合适，反之，使用JDK方式要更为合适一些。同时，由于CGLib由于是采用动态创建子类的方法，对于final方法，无法进行代理。

第四章：注入属性与依赖对象

比方说我UserService内需要注入UserDao来操作数据库，所以我在实例化Bean后，应将所需的属性和依赖注入到Bean中，而这部分信息通过PropertyValues记录，并封装到BeanDefinition中。在实例化后应通过对应BeanDefinition获取到需要哪些内容，并进行填充处理。

第五章：资源加载器解析文件注册对象

这里我们要加入XML解析，在上面我们都是手动将所有信息通过Java注册到BeanFactory的，这不利于维护，现实Spring中我们都是使用Xml进行配置或者注解开发，所以我们需要定义一个ResourceLoader去加载各种数据（XML文件，URL，Classpath）。

资源加载，读取指定资源，转化为Resource，核心是获取文件的二进制流为后面解析

资源解析：利用XML解析器解析Spring.xml文件,获取所有Bean信息定义，并将其封装为BeanDefinition并注册

容器初始化：完成实例的实例化与属性填充

这一章类扩展的很多，建议仔细读两遍源码，着重关注资源加载解析部分即可，其余流程大体不变。

第六章：实现应用上下文

重点：

引入应用上下文，进行资源扫描与加载，为Bean对象实例化过程添加扩展机制，允许加载Bean对象和在其实例化前后进行修改和扩展。

核心：

增加BeanPostProcessor 和 BeanFactoryPostProcessor

有啥用：

比如说我们想在Bean的实例化之前，对BeanDefinition做出记录或修改，影响Bean的实例化，或者在Bean的初始化方法前后进行一系列操作，这是后面章节的基础部分，实现容器感知，AOP等技术的实现

AbstractApplicationContext::refresh() 刷新容器

@Override
public void refresh() throws BeansException {
    // 1. 创建 BeanFactory，并加载 BeanDefinition
    refreshBeanFactory();
    // 2. 获取 BeanFactory
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    // 3. 在 Bean 实例化之前，执行 BeanFactoryPostProcessor ，这时候Bean还没有实例化，找到所有的BeanFactoryPostProcessor，进行处理，可以修改BeanDefinition ！！！
    invokeBeanFactoryPostProcessors(beanFactory);
    // 4. BeanPostProcessor 需要提前于其他 Bean 对象实例化之前执行注册操作，找到所有的BeanPostProcessor，添加到一个容器中，等对象实例化时进行处理  ！！！ 
    registerBeanPostProcessors(beanFactory);
    // 5. 提前实例化单例Bean对象
    beanFactory.preInstantiateSingletons();
}

加载出所有注册的BeanFactoryPostProcessor，普通Bean实例化前操作

private void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    Map<String, BeanFactoryPostProcessor> beanFactoryPostProcessorMap = beanFactory.getBeansOfType(BeanFactoryPostProcessor.class);
    for (BeanFactoryPostProcessor beanFactoryPostProcessor : beanFactoryPostProcessorMap.values()) {
        beanFactoryPostProcessor.postProcessBeanFactory(beanFactory);
    }
}

加载出所有注册的BeanPostProcessor，必须加载并注册，因为这些Bean是转为针对普通Bean实例化后操作的。

private void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    Map<String, BeanPostProcessor> beanPostProcessorMap = beanFactory.getBeansOfType(BeanPostProcessor.class);
    for (BeanPostProcessor beanPostProcessor : beanPostProcessorMap.values()) {
        beanFactory.addBeanPostProcessor(beanPostProcessor);
    }
}

public void preInstantiateSingletons() throws BeansException {
    // 实例化所有未实例化的Bean
    beanDefinitionMap.keySet().forEach(this::getBean);
}
protected <T> T doGetBean(final String name, final Object[] args) {
        // 先从单例工厂找，有则直接返回，这样就不担心之前加载的Processor再被加载处理了
        Object bean = getSingleton(name);
        if (bean != null) {
            return (T) bean;
        }
        // 获取Bean对应的定义信息
        BeanDefinition beanDefinition = getBeanDefinition(name);
        // 实例化Bean
        return (T) createBean(name, beanDefinition, args);
    }
@Override
    protected Object createBean(String beanName, BeanDefinition beanDefinition, Object[] args) throws BeansException {
        Object bean = null;
        try {
            // 将 Bean 实例化，执行构造器方法
            bean = createBeanInstance(beanDefinition, beanName, args);
            // 给 Bean 填充属性
            applyPropertyValues(beanName, bean, beanDefinition);
            // 执行 Bean 的初始化方法和 BeanPostProcessor 的前置和后置处理方法
            bean = initializeBean(beanName, bean, beanDefinition);
        } catch (Exception e) {
            throw new BeansException("Instantiation of bean failed", e);
        }
        // 将Bean注入单例容器中
        registerSingleton(beanName, bean);
        return bean;
    }
private Object initializeBean(String beanName, Object bean, BeanDefinition beanDefinition) {
        // 1. 执行 BeanPostProcessor Before 处理 ！！！
        Object wrappedBean = applyBeanPostProcessorsBeforeInitialization(bean, beanName);
        // 待完成内容：invokeInitMethods(beanName, wrappedBean, beanDefinition);  这里就是未来init方法调用的地方
        invokeInitMethods(beanName, wrappedBean, beanDefinition);
        // 2. 执行 BeanPostProcessor After 处理 ！！！
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
        return wrappedBean;
    }

第七章：Bean对象的初始化与销毁

<?xml version="1.0" encoding="UTF-8"?>
<beans>
    <bean id="userDao" class="cn.bugstack.springframework.test.bean.UserDao"
          init-method="initDataMethod"
          destroy-method="destroyDataMethod"/>
</beans>

在Bean定义信息中我们指定了初始化方法（和对象构造器方法无关）和销毁方法。加入了init-method 和 destroy-method。我们可以在Xml解析中，读取出该数据，并把该数据保存到BeanDefinition中。这里的销毁方法，我们利用JVM的Hook进行调用。

public class BeanDefinition {
    private Class beanClass;
    private PropertyValues propertyValues;
    private String initMethodName;
    private String destroyMethodName;
  // ...get/set/construct方法
}

除了在Xml中进行设置初始化和销毁方式外，我们也可以设计两个接口，让Bean来实现对应的方法，未来初始化时执行相应方法。

public interface InitializingBean {
    /**
     * Bean 处理了属性填充后调用
     */
    void afterPropertiesSet() throws Exception;
}
public interface DisposableBean {
    /**
     * Bean 销毁时执行
     */
    void destroy() throws Exception;
}

浅试实现mini-spring-ioc容器（上）

IOC

第一章：实现一个简单的Spring Bean容器

第二章：实现Bean对象的定义，注册和获取

第三章：基于Cglib实现含有构造函数的类实例化策略

第四章：注入属性与依赖对象

第五章：资源加载器解析文件注册对象

第六章：实现应用上下文

第七章：Bean对象的初始化与销毁

热门文章

最新文章

相关课程

相关电子书

相关实验场景