Spring 框架源码解读6

title: Spring 框架源码解读6
date: 2020/04/17 14:54

本节内容 & 思考题

Spring 给了我们 3 个接口让我们在它初始化的时候，分别对 BeanFactory、BeanDefinitionRegistry 还有 Bean 进行干预，今天就让我们来实现这个吧。

还记得处理 @PostConstruct 注解那个地方吧，为什么在 Spring 中是采用后置处理器实现的？

开闭原则：后置处理器

BeanDefinitionRegistryPostProcessor

1、新增 BeanDefinitionRegistry 接口，ListableBeanFactory 接口继承它， ListableBeanFactoryImpl 实现它

public interface BeanDefinitionRegistry {

    /**
     * 注册 bd 到 bf
     */
    void registerBeanDefinition(String name, BeanDefinition beanDefinition);
}

ListableBeanFactoryImpl 中本身就有这个方法，我们只需要加上 @Overwirte 就好了。

2、新增 BeanDefinitionRegistryPostProcessor 接口

/**
 * 使我们可以在 BeanFactory 初始化好了之后，向其中注册 BD
 * <p>
 * 在 Spring 5.0 中它继承了 BeanFactoryPostProcessor 但是我觉得没必要
 */
public interface BeanDefinitionRegistryPostProcessor {
    
    void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry);

}

3、修改 AbstractApplicationContext#refresh()

所以要使用 BeanDefinitionRegistryPostProcessor 就必须要使用 ApplicationContext。

@Override
public void refresh() {

    // 初始化 BF，生成 BF，好在调用 getBeanFactory() 时返回
    this.refreshBeanFactory();

    // 执行 BeanDefinitionRegistryPostProcessor
    this.invokeBeanDefinitionRegistryPostProcessors();

    ...
}

private void invokeBeanFactoryPostProcessors() {
    ListableBeanFactory beanFactory = this.getBeanFactory();

    for (BeanFactoryPostProcessor beanFactoryPostProcessor : beanFactory.getBeansOfType(BeanFactoryPostProcessor.class).values()) {
        // beanFactory 就是那个 registry
        beanFactoryPostProcessor.postProcessBeanFactory(beanFactory);
    }
}

4、这个我没测试

集成 BeanFactoryPostProcessor

1、新增 BeanFactoryPostProcessor 接口

public interface BeanFactoryPostProcessor {

    /**
     * 在工厂实例化后做些什么
     */
    void postProcessBeanFactory(ListableBeanFactory beanFactory);

}

2、修改 AbstractApplicationContext#refresh()

所以要使用 BeanFactoryPostProcessor 也必须要使用 ApplicationContext。

@Override
public void refresh() {

    // 初始化 BF，生成 BF，好在调用 getBeanFactory() 时返回
    this.refreshBeanFactory();

    // 执行 BeanDefinitionRegistryPostProcessor
    this.invokeBeanDefinitionRegistryPostProcessors();

    // 执行 BeanFactoryPostProcessor
    this.invokeBeanFactoryPostProcessors();

    ...
}

private void invokeBeanFactoryPostProcessors() {
    ListableBeanFactory beanFactory = this.getBeanFactory();

    for (BeanFactoryPostProcessor beanFactoryPostProcessor : beanFactory.getBeansOfType(BeanFactoryPostProcessor.class).values()) {
        beanFactoryPostProcessor.postProcessBeanFactory(beanFactory);
    }
}

3、我也没测试

重头戏 BeanPostProcessor

1、新增接口 BeanPostProcessor

public interface BeanPostProcessor {

    /**
     * 在bean的初始化之前执行
     */
    default Object postProcessBeforeInitialization(Object bean, String beanName) {
        return bean;
    }

    /**
     * 在bean的初始化后执行
     */
    default Object postProcessAfterInitialization(Object bean, String beanName) {
        return bean;
    }

}

2、修改 AbstractBeanFactory#createBean 方法

所以， BeanPostProcessor 不依赖 ApplicationContext

// BeanFactory 新增方法

default void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) {
}

public abstract class AbstractBeanFactory implements BeanFactory {

    private final List<BeanPostProcessor> beanPostProcessors = new ArrayList<>();

    /**
    * 根据 bd 创建对象
    * <p>
    * 1）创建bean 日后需要对有参构造进行扩展
    * 2）注入属性（Spring 源码中 2 是在 3456 的后面）
    * 3）调用部分 Aware 的方法
    * 4）后置处理器的前置方法
    * 5）执行初始化操作
    * 6）后置处理器的后置方法
    * 7）注册销毁的处理
    */
    private Object createBean(BeanDefinition beanDefinition) {
        // 1、创建 bean
        BeanWrapper beanWrapper = this.createBeanInstance(beanDefinition);

        // 2、注入属性 DI （Spring 0.9 中当属性改变时会触发事件，但是默认是关闭的，暂时不知道它为了干啥）
        List<PropertyArgDefinition> properties = beanDefinition.getProperties();
        List<PropertyValue> propertyValueList = this.parseProperties(properties);
        beanWrapper.setPropertyValues(propertyValueList);
        Object bean = beanWrapper.getWrappedInstance();

        // 3、调用部分 Aware 的方法
        
        // 4、后置处理器的前置方法
        this.applyBeanPostProcessorsBeforeInitialization(bean, beanDefinition.getName());

        // 5、执行初始化操作（在 Spring 中是直接调用的该类中的 initializeBean 方法，为了让他面向对象一点，我给他抽出一个类）
        InitializeBeanAdapter initializeBeanAdapter = new InitializeBeanAdapter(bean, beanDefinition);
        initializeBeanAdapter.afterPropertiesSet();

        // 6、后置处理器的后置方法
        this.applyBeanPostProcessorsAfterInitialization(bean, beanDefinition.getName());

        // 7、注册销毁的处理
        if (this.check(beanDefinition, bean)) {
            registry.registerDisposableBean(beanDefinition.getName(), new DisposableBeanAdapter(bean, beanDefinition));
        }
        return bean;
    }

    // 后置方法
    private void applyBeanPostProcessorsAfterInitialization(Object bean, String name) {
        for (BeanPostProcessor beanPostProcessor : beanPostProcessors) {
            beanPostProcessor.postProcessAfterInitialization(bean, name);
        }
    }

    // 前置方法
    private void applyBeanPostProcessorsBeforeInitialization(Object bean, String name) {
        for (BeanPostProcessor beanPostProcessor : beanPostProcessors) {
            beanPostProcessor.postProcessBeforeInitialization(bean, name);
        }
    }

    @Override
    public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) {
        beanPostProcessors.add(beanPostProcessor);
    }

// 修改 JsonBeanFactoryImpl#loadBeanDefinitions 方法，在加载 BD 的时候，把后置处理器加到集合中。

public class JsonBeanFactoryImpl extends ListableBeanFactoryImpl {

    ...

    private void loadBeanDefinitions(JSONArray jsonArray) {
        List<DefaultBeanDefinition> beanDefinitionList = jsonArray.toList(DefaultBeanDefinition.class);
        for (DefaultBeanDefinition bd : beanDefinitionList) {
            super.registerBeanDefinition(bd.getName(), bd);
        }

        // 向 beanPostProcessors 中添加后置处理器
        for (BeanPostProcessor beanPostProcessor : super.getBeansOfType(BeanPostProcessor.class).values()) {
            super.addBeanPostProcessor(beanPostProcessor);
        }
    }

测试1：将 @PostConstruct 注解改为使用后置处理器

原来的地方记得删掉

1、新增 InitAnnotationBeanPostProcessor

/**
 * 此处只实现对 @PostConstruct 注解的处理，@PreDestroy 不实现（Spring 中通过 DestructionAwareBeanPostProcessor 实现）
 *
 * @author yujx
 * @date 2020/04/17 13:26
 */
public class InitAnnotationBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        for (Method method : ReflectUtils.getMethodsByAnnotation(bean.getClass(), PostConstruct.class)) {
            ReflectUtil.invoke(bean, method);
        }
        return bean;
    }
}

2、测试

public class AppleFactory {

    public Apple createApple() {
        Apple apple = new Apple();
        apple.setName("黄元帅");
        return apple;
    }

    @PostConstruct
    public void init() {
        System.out.println("AppleFactory...");
    }
}

apple.json

[
  {
    "name": "appleFactory",
    "className": "cn.x5456.summer.AppleFactory"
  },
  {
    "name": "initAnnotationBeanPostProcessor",
    "className": "cn.x5456.summer.InitAnnotationBeanPostProcessor"
  }
]

TestJsonAP 和 TestJsonBF 都行

完善 AbstractBeanFactory#createBean() 增加 Aware

/**
 * 根据 bd 创建对象
 * <p>
 * 1）创建bean 日后需要对有参构造进行扩展
 * 2）注入属性（Spring 源码中 2 是在 3456 的后面）
 * 3）调用部分 Aware 的方法
 * 4）后置处理器的前置方法
 * 5）执行初始化操作
 * 6）后置处理器的后置方法
 * 7）注册销毁的处理
 */
private Object createBean(BeanDefinition beanDefinition) {

    // 1、创建 bean
    BeanWrapper beanWrapper = this.createBeanInstance(beanDefinition);

    // 2、注入属性 DI （Spring 0.9 中当属性改变时会触发事件，但是默认是关闭的，暂时不知道它为了干啥）
    List<PropertyArgDefinition> properties = beanDefinition.getProperties();
    List<PropertyValue> propertyValueList = this.parseProperties(properties);
    beanWrapper.setPropertyValues(propertyValueList);
    Object bean = beanWrapper.getWrappedInstance();

    // 3、调用部分 Aware 的方法
    this.invokeAwareMethod(bean, beanDefinition.getName());

    ...
}

private void invokeAwareMethod(Object bean, String beanName) {
    if (bean instanceof Aware) {
        if (bean instanceof BeanNameAware) {
            ((BeanNameAware) bean).setBeanName(beanName);
        }
        // else if () ...
    }
}

因为在 BeanFactory 中没有 ApplicationContext 相关的东西，那么怎么注入呢，有一种方式就是在 ApplicationContext#getBean() 方法中对 BF 进行代理，在获取到 bean 之后注入，我们之前也是这样实现的，但是 Spring 逼格很高，它采用了 BeanPostProcessor 实现。

测试2：使用 ApplicationContextAwareProcessor 注入

也记得把之前注入 ApplicationContext 部分代码注释掉 AbstractApplicationContext#configureManagedObject

1、ApplicationContextAwareProcessor

/**
 * 与 ApplicationContext 中相关数据注入的后置处理器
 * <p>
 * 在 bean 初始化完成后注入相关实例
 *
 * @author yujx
 * @date 2020/04/17 14:34
 */
public class ApplicationContextAwareProcessor implements BeanPostProcessor {

    private ApplicationContext applicationContext;

    public ApplicationContextAwareProcessor(ApplicationContext applicationContext) {
        this.applicationContext = applicationContext;
    }

    /**
     * 在bean的初始化之前执行
     */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        if (bean instanceof Aware) {
            if (bean instanceof ApplicationContextAware) {
                ((ApplicationContextAware) bean).setApplicationContext(applicationContext);
            }
            // else if () ...
        }
        return bean;
    }
}

2、将新写好的处理器注入 BF 中

public class FileSystemJsonApplicationContext extends AbstractApplicationContext {


    // 与当前 ApplicationContext 相关联的 BF
    private ListableBeanFactory beanFactory;
    
    /**
     * 初始化当前 ApplicationContext 的 BF
     */
    @Override
    protected void refreshBeanFactory() {
        beanFactory = new JsonBeanFactoryImpl(configLocation, super.getParent());

        // beanFactory 初始化完成后，向其中添加一个后置处理器
        beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
    }

3、测试

public class TestJsonAP {

    public static void main(String[] args) {
        FileSystemJsonApplicationContext fileSystemJsonApplicationContext = new FileSystemJsonApplicationContext(new String[]{
                "/Users/x5456/IdeaProjects/Summer/src/test/resources/apple.json"
        });
    }
}

public class AppleFactory implements BeanNameAware, ApplicationContextAware {

    public Apple createApple() {
        Apple apple = new Apple();
        apple.setName("黄元帅");
        return apple;
    }

    @PostConstruct
    public void init() {
        System.out.println("AppleFactory...");
    }

    /**
     * 注入 ApplicationContext
     */
    @Override
    public void setApplicationContext(ApplicationContext ctx) {
        System.out.println("ctx = " + ctx);
    }

    @Override
    public void setBeanName(String name) {
        System.out.println("name = " + name);
    }
}

Spring 5.0

BeanFactoryPostProcessor & BeanDefinitionRegistryPostProcessor

Spring 考虑了各种注入方式（ap.add、注解、配置文件）和执行顺序问题（Order），导致代码过于复杂，不建议看。

BeanPostProcessor

AbstractAutowireCapableBeanFactory#doCreateBean

ApplicationContextAwareProcessor 实现注入功能

BPP 实现 Aware 的注入

思考题答案

因为一开始的时候 Spring 并没有考虑 @PostConsturce 注解，为了符合“开闭原则”，不修改原有代码，所以 Spring 采用了后置处理器完成。