Tiny-Spring——BeanFactory系列

详情请见 https://github.com/StrongChenYu/Tiny-Spring

Question

DefaultListableBeanFactory是关于Bean的接口中的第一个具体的实现，但是为什么Spring中设计这么复杂的接口继承和实现关系呢？这些不同的接口之间到底有什么作用呢？

1. 概览

首先贴一张自己复现的一个精简版的Spring的类结构。不过感觉总体上还是差不太多，核心思想都一样。

这四层接口要分层看待，根据不同的继承层次分别赋予了不同的功能。
第一层接口：

• BeanFactory

第二层接口：

• AutowireCapableBeanFactory
• HierarchicalBeanFactory
• ListableBeanFactory

第三层接口：

• ConfigurableBeanFactory

第四层接口：

• ConfigurableListableBeanFactory

2. 第一层接口——BeanFactory

BeanFactory顾名思义，即为构造Bean的工厂，所以这个最上层接口的必须要拥有的一个方法就是：

Bean getBean(params);

至于是根据类型获得Bean，还是根据Bean的名字获得Bean，还是其他的等等。那就涉及到了一系列方法的重载。源Spring中提供了以下这么多的方法。

public interface BeanFactory {
    Object getBean(String name) throws BeansException;
    <T> T getBean(String name, Class<T> requiredType) throws BeansException;
    Object getBean(String name, Object... args) throws BeansException;
    <T> T getBean(Class<T> requiredType) throws BeansException;
    <T> T getBean(Class<T> requiredType, Object... args) throws BeansException;
    ......
}

3. 第二层接口

第二层接口相当于在第一层接口上的功能拓展。

3.1 AutowireCapableBeanFactory

AutowireCapable的含义是自动装配，这个接口想表达的含义就是具有自动能力的BeanFactory。

public interface AutowireCapableBeanFactory extends BeanFactory {
    Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)throws BeansException;
    Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)throws BeansException;
}

Small-Spring中的AutowireCapableBeanFactory只提供了这两个方法，实际在源Spring中还有一系列的createBean相关的方法，真正体现Autowire的能力的方法。
那为什么不表示出来呢？
其实这个接口的虚实现AbstractAutowireCapableBeanFactory，继承了AbstactBeanFactory，已经有了一个createBean的protected方法。可以理解为防止重复。（源Spring代码中是都做了实现，并通过AutowireCapableBeanFactory的createBean去调用AbstactBeanFactory的createBean。

3.2 HierarchicalBeanFactory

故名思意，具有层次的BeanFactory，一看方法名就知道大概是什么意思了。不过感觉用处不太大，Small-Spring中默认为空接口。

public interface HierarchicalBeanFactory extends BeanFactory {
	/**
	 * Return the parent bean factory, or {@code null} if there is none.
	 */
	@Nullable
	BeanFactory getParentBeanFactory();
	boolean containsLocalBean(String name);

}

3.3 ListableBeanFactory

故名思意，就是要能把Bean以List的形式展现出来，Small-Spring中实现如下。（体现一个List able`)

public interface ListableBeanFactory extends BeanFactory {
    <T> Map<String, T> getBeansOfType(Class<T> type) throws BeansException;
    String[] getBeanDefinitionNames();
}

总结

这三个二级接口都是对一级接口的功能的扩展，除了BeanFactory具备的基本能力外，提供了不同类型的应用场景。

4. 第三层接口——ConfigurableBeanFactory

public interface ConfigurableBeanFactory extends HierarchicalBeanFactory, SingletonBeanRegistry {
    String SCOPE_SINGLETON = "singleton";
    String SCOPE_PROTOTYPE = "prototype";
    void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);
}

5. 第四层接口——ConfigurableListableBeanFactory

public interface ConfigurableListableBeanFactory extends ListableBeanFactory, ConfigurableBeanFactory, AutowireCapableBeanFactory {
    BeanDefinition getBeanDefinition(String beanName) throws BeansException;
    void preInstantiateSingletons() throws BeansException;
    void addBeanPostProcessor(BeanPostProcessor postProcessor);
}

6. 抽象类

AutowireCapable的含义

主要是看接口的设计，就能明白这个意思大概就是，能在Bean初始化前后，具有执行自己代码的能力

Configurable的含义

可以自己配置AutowireCapable中的BeanPostProcessor
根据上面AbstractAutowireCapableBeanFactory提到的两点，这个抽象类的功能和作用大概也就明白了。

需要注意的是bean初始化后执行的顺序

1. Bean初始化：CGLib动态代理，调用Bean中的构造函数
2. 填充Bean中的属性：将bean中的私有还是其他的成员填上值（如果也是一个ref，那么会触发ref的初始化**）（好了，循环调用问题！！！！！）**
3. 执行三个方法：BeforeInitialization -> init-method -> afterAfterInitialization

protected Object createBean(String beanName, BeanDefinition beanDefinition, Object[] args) throws BeansException {
    Object bean = null;
    try {
        //create bean
        bean = createBeanInstance(beanDefinition, beanName, args);

        //support bean property
        applyPropertyValues(beanName, bean, beanDefinition);

        bean = initializeBean(beanName, bean, beanDefinition);
    } catch (Exception e) {
        throw new BeansException("Instantiation of bean failed", e);
    }
    addSingleton(beanName, bean);
    return bean;
}

private Object initializeBean(String beanName, Object bean, BeanDefinition beanDefinition) {
    //前置处理
    Object wrappedBean = applyBeanPostProcessorsBeforeInitialization(bean, beanName);
    //调用初始化方法
    try {
        invokeInitMethods(beanName, wrappedBean, beanDefinition);
    } catch (Exception e) {
        throw new BeansException("Invocation of init method of bean[" + beanName + "] failed", e);
    }
    //后置处理
    wrappedBean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
    return wrappedBean;
}

7. 总结

体会

一看接口中的方法便可以知道这些接口各个的含义表示什么，有什么样子的功能，通过不同接口的继承组合来进行扩展。
然后将不同的实现放在不同的抽象类中，在DefaultListableBeanFactory中只需要实现属于自己的部分即可，虽然代码的结构复杂性增加了，但是可扩展性也随之增加。

设计模式

几个设计模式的体现

1. 模板方法模式：抽象类AbstractBeanFactory, AbstractAutowireCapableBeanFactory的设计
2. 单例模式：SingletonRegistry
3. 工厂模式：BeanFactory