剖析Bean工厂接口，源码理解不复杂

剖析Bean工厂接口，源码理解并不难

前日在研习Spring框架的相关内容时，接触到了IOC部分，可彼时实在难以领会其内涵，虽说有提及源码方面的讲解，但并未完全弄通透，于是心想不妨自己去研读源码。

这是我绘制的Bean Factory大致关系图，为了便于理解，已删去了bean别名管理接口（AliasRegistry）和bean定义接口（BeanDefinitionRegistry）。

BeanFactory具备三个子类，分别是ListableBeanFactory、HierarchicalBeanFactory、ConfigurableBeanFactory以及AutowireCapableBeanFactory。

我们先来看BeanFactory，它仅仅实现了IOC容器的基本行为规范，就好比是让需求方提出对目标的诉求。

public interface BeanFactory {
    //用于区分由FactoryBean创建的bean，若指定名称的bean是FactoryBean，那么获取时返回的将是Factory本身，而非Factory所创建的实例。
    String FACTORY_BEAN_PREFIX = "&";

    Object getBean(String var1) throws BeansException;

    <T> T getBean(String var1, Class<T> var2) throws BeansException;

    Object getBean(String var1, Object... var2) throws BeansException;

    <T> T getBean(Class<T> var1) throws BeansException;

    <T> T getBean(Class<T> var1, Object... var2) throws BeansException;

    <T> ObjectProvider<T> getBeanProvider(Class<T> var1);

    <T> ObjectProvider<T> getBeanProvider(ResolvableType var1);

    boolean containsBean(String var1);

    boolean isSingleton(String var1) throws NoSuchBeanDefinitionException;

    boolean isPrototype(String var1) throws NoSuchBeanDefinitionException;

    boolean isTypeMatch(String var1, ResolvableType var2) throws NoSuchBeanDefinitionException;

    boolean isTypeMatch(String var1, Class<?> var2) throws NoSuchBeanDefinitionException;

    @Nullable
    Class<?> getType(String var1) throws NoSuchBeanDefinitionException;

    @Nullable
    Class<?> getType(String var1, boolean var2) throws NoSuchBeanDefinitionException;

    String[] getAliases(String var1);
}

ListableBeanFactory定义了工厂Bean的可列举特性，适用于对bean进行批量操作的情形。

public interface ListableBeanFactory extends BeanFactory {
    boolean containsBeanDefinition(String var1);

    int getBeanDefinitionCount();

    String[] getBeanDefinitionNames();

    <T> ObjectProvider<T> getBeanProvider(Class<T> var1, boolean var2);

    <T> ObjectProvider<T> getBeanProvider(ResolvableType var1, boolean var2);

    String[] getBeanNamesForType(ResolvableType var1);

    String[] getBeanNamesForType(ResolvableType var1, boolean var2, boolean var3);

    String[] getBeanNamesForType(@Nullable Class<?> var1);

    String[] getBeanNamesForType(@Nullable Class<?> var1, boolean var2, boolean var3);

    <T> Map<String, T> getBeansOfType(@Nullable Class<T> var1) throws BeansException;

    <T> Map<String, T> getBeansOfType(@Nullable Class<T> var1, boolean var2, boolean var3) throws BeansException;

    String[] getBeanNamesForAnnotation(Class<? extends Annotation> var1);

    Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> var1) throws BeansException;

    @Nullable
    <A extends Annotation> A findAnnotationOnBean(String var1, Class<A> var2) throws NoSuchBeanDefinitionException;

    @Nullable
    <A extends Annotation> A findAnnotationOnBean(String var1, Class<A> var2, boolean var3) throws NoSuchBeanDefinitionException;
}

HierarchicalBeanFactory定义了Bean Factory的分层能力，之前还不了解Bean Factory可以有父子容器之分，这有点像继承关系，子类能够调用父类的方法，但父类无法调用子类的方法。

在Spring MVC中存在这样的分层：根上下文（由ContextLoaderListener或者Spring Boot创建）作为父容器，用于放置服务层、数据访问层以及基础设施bean（如DataSource）；而DispatcherServlet的上下文作为子容器，用来定义Web层特定的bean，像控制器、HandlerMapping等。

public interface HierarchicalBeanFactory extends BeanFactory {
    @Nullable
    BeanFactory getParentBeanFactory();

    boolean containsLocalBean(String var1);
}

ConfigurableBeanFactory定义了自定义Bean工厂的能力，能够进行自定义类加载器的设置、bean定义的管理、作用域的配置以及依赖关系的处理等。

public interface ConfigurableBeanFactory extends HierarchicalBeanFactory, SingletonBeanRegistry {
    // 自定义类加载器
    void setBeanClassLoader(@Nullable ClassLoader var1);
    @Nullable
    ClassLoader getBeanClassLoader();
    void setTempClassLoader(@Nullable ClassLoader var1);
    @Nullable
    ClassLoader getTempClassLoader();

    // bean 定义
    void setCacheBeanMetadata(boolean var1);
    boolean isCacheBeanMetadata();
    BeanDefinition getMergedBeanDefinition(String var1) throws NoSuchBeanDefinitionException;
    boolean isFactoryBean(String var1) throws NoSuchBeanDefinitionException;

    // 作用域
    void registerScope(String var1, Scope var2);
    String[] getRegisteredScopeNames();
    @Nullable
    Scope getRegisteredScope(String var1);

    // 依赖关系
    void registerDependentBean(String var1, String var2);
    String[] getDependentBeans(String var1);
    String[] getDependenciesForBean(String var1);

    ......
    ......
}

AutowireCapableBeanFactory实现了Bean的自动装配能力。

public interface AutowireCapableBeanFactory extends BeanFactory {
    int AUTOWIRE_NO = 0;
    int AUTOWIRE_BY_NAME = 1;
    int AUTOWIRE_BY_TYPE = 2;
    int AUTOWIRE_CONSTRUCTOR = 3;
    /** @deprecated */
    @Deprecated
    int AUTOWIRE_AUTODETECT = 4;
    String ORIGINAL_INSTANCE_SUFFIX = ".ORIGINAL";

    <T> T createBean(Class<T> var1) throws BeansException;

    void autowireBean(Object var1) throws BeansException;

    Object configureBean(Object var1, String var2) throws BeansException;

    Object createBean(Class<?> var1, int var2, boolean var3) throws BeansException;

    Object autowire(Class<?> var1, int var2, boolean var3) throws BeansException;

    void autowireBeanProperties(Object var1, int var2, boolean var3) throws BeansException;

    void applyBeanPropertyValues(Object var1, String var2) throws BeansException;

    Object initializeBean(Object var1, String var2) throws BeansException;

    Object applyBeanPostProcessorsBeforeInitialization(Object var1, String var2) throws BeansException;

    Object applyBeanPostProcessorsAfterInitialization(Object var1, String var2) throws BeansException;

    void destroyBean(Object var1);

    <T> NamedBeanHolder<T> resolveNamedBean(Class<T> var1) throws BeansException;

    Object resolveBeanByName(String var1, DependencyDescriptor var2) throws BeansException;

    @Nullable
    Object resolveDependency(DependencyDescriptor var1, @Nullable String var2) throws BeansException;

    @Nullable
    Object resolveDependency(DependencyDescriptor var1, @Nullable String var2, @Nullable Set<String> var3, @Nullable TypeConverter var4) throws BeansException;
}

在看完这些接口类和接口方法后，对IOC容器有了更为拓展的认识。其实源码并没有那么难以理解，通常可以先通过一个类向上找到其基类，然后再往下深入查看详细的接口类以及实现类，从而对其形成全局的认知。