Spring BeanFactory和现实工厂的对比

本文不分析Spring的源码流程，只是介绍一些基础的概念，在阅读源码之前，我们应该首先明确研究的对象是什么，才能有的放矢。

Spring作为BeanFactory，和现实工厂有着许多类似之处。

需要各种原料Class，存在各个jar包内，jar包内又分为不同的Package。

每一种原料有相应的说明书------BeanDefinition

需要存储说明书的地方 BeanDefinitionRegistry

需要搬运工：BeanFactoryPostProcessor

需要按照说明书生产零件 newInstance .

各种零件 Singleton

半成品 BeanWrapper

成品 ExposedObject

零件和零件之间有依赖关系 Dependency

需要存储零件的地方

存储半成品的地方

需要存储成品的地方

需要各种工序Processor

需要决定Processor如何执行的地方PostProcessorRegistrationDelegate，

需要有存储工序的地方

需要对零件进行组装 AutowireCapableBeanFactory，这部分也就是注入依赖的过程。

需要对成品的一些功能进行增强。对Method进行增强。

顺着这条线看应该会容易很多。

1： BeanDefinition 一个Class对应一个BeanDefinition，有了BeanDefinition再构建instance。

可以理解为Class可以分为不同的功能。

1.1 普通的bean

1.2 能处理@Component的bean

1.3 能处理@Configuration的bean

ConfigurationClassBeanDefinition ，对应@Configuration 修饰的Class类。 ConfigurationClassBeanDefinitionReader 是负责分析ConfigurationClass。

spring 里面有一个非常常见的变量 mbd，意为getMergedLocalBeanDefinition 。

BeanDefinition 其实是相当复杂的一个类，需要考虑到Bean的各种可能潜在的属性以及整个生命周期。

@Nullable

private volatile Object beanClass;      代表的class

@Nullable

private String scope;                    作用域

private boolean abstractFlag;            是否是abstract类

private boolean lazyInit;                是否是懒加载

private int autowireMode;                autowireMode         

private int dependencyCheck;             是否检查依赖

@Nullable

private String[] dependsOn;               依赖那些其他的beanClass

private boolean autowireCandidate;        候选人

private boolean primary;                  是否是主类

private final Map<String, AutowireCandidateQualifier> qualifiers;        限定    

@Nullable

private Supplier<?> instanceSupplier;      供应商

private boolean nonPublicAccessAllowed;    

private boolean lenientConstructorResolution;    宽容的

@Nullable

private String factoryBeanName;

@Nullable

private String factoryMethodName;

@Nullable

private ConstructorArgumentValues constructorArgumentValues;        构造方法的参数

@Nullable

private MutablePropertyValues propertyValues;    属性

@Nullable

private MethodOverrides methodOverrides;        

@Nullable

private String initMethodName;        init方法

@Nullable

private String destroyMethodName;    销毁方法的名称

private boolean enforceInitMethod;

private boolean enforceDestroyMethod;

private boolean synthetic;        是否是人工合成的

private int role;                   角色

@Nullable

private String description;        描述

@Nullable

private Resource resource;         class文件的位置

@Nullable

private BeanDefinitionHolder decoratedDefinition;

@Nullable

private AnnotatedElement qualifiedElement;

boolean allowCaching = true;

boolean isFactoryMethodUnique = false;

@Nullable

volatile ResolvableType targetType;

@Nullable

volatile Class<?> resolvedTargetType;       //  resolvedTargetType 目标类型目标类型

@Nullable

volatile ResolvableType factoryMethodReturnType;

@Nullable

volatile Method factoryMethodToIntrospect;                 

final Object constructorArgumentLock = new Object();

@Nullable

Executable resolvedConstructorOrFactoryMethod;

boolean constructorArgumentsResolved = false;

@Nullable

Object[] resolvedConstructorArguments;

@Nullable

Object[] preparedConstructorArguments;

final Object postProcessingLock = new Object();

boolean postProcessed = false;

@Nullable

volatile Boolean beforeInstantiationResolved;

@Nullable

private Set<Member> externallyManagedConfigMembers;

@Nullable

private Set<String> externallyManagedInitMethods;

@Nullable

private Set<String> externallyManagedDestroyMethods;

能将事物的本质描述清楚实在是不容易。

2：既然有BeanDefinition ，那么就需要有存放BeanDefinition的地方(容器) ，称为BeanDefinitionRegistry

beanDefinitionMap 就是存放BeanDefinition的地方。 Map<String,BeanDefinition>

定义增删查等基本操作。

public interface BeanDefinitionRegistry extends AliasRegistry {

    void registerBeanDefinition(String var1, BeanDefinition var2) throws BeanDefinitionStoreException;

    void removeBeanDefinition(String var1) throws NoSuchBeanDefinitionException;

    BeanDefinition getBeanDefinition(String var1) throws NoSuchBeanDefinitionException;

    boolean containsBeanDefinition(String var1);

    String[] getBeanDefinitionNames();

    int getBeanDefinitionCount();

    boolean isBeanNameInUse(String var1);

}

除此之外还可以给BeanDefinition起一个别名。

3：Singleton

public interface SingletonBeanRegistry {

    void registerSingleton(String var1, Object var2);

    @Nullable

    Object getSingleton(String var1);

    boolean containsSingleton(String var1);

    String[] getSingletonNames();

    int getSingletonCount();

    Object getSingletonMutex();

}

很明显Singleton全部为Object类型，这意味着在@Autowired 注入依赖时，需要进行类型转换。注意这里没法进行进行强制类型转换。这也是spring推荐

使用构造方法注入依赖的原因吧，类型擦除之后还得再还原原始类型，很复杂。

Singleton 分为两种：

3.1: 不依赖其他Singleton的Singleton

3.2: 依赖其他Singleton的Singleton

存放Singleton的地方

4： ScopedObject

存放 ScopeObject的地方

5：Bean

从功能来看： Bean分为NamedBean DisposableBean InitializingBean 和 FactoryBean<T>

6：BeanWrapper

7：存放Singleton和Scope，以及对他们进行加工改造的地方称为BeanFactory ，实际上Singleton存储在SingletonBeanRegistry ，Scope存在

RequestContextHolder 中，BeanFactory 提供了桥接入口

FactoryBean和BeanFactory 的区别， FactoryBean<T> 带有参数T ， FactoryBean 只是生产T对应的BeanDefinition

FactoryBean的作用：有些Bean能够直接通过newInstance 直接构建，有些Bean需要通过反射进行构建，比如@Mapper，@Feign ，@Repository 修饰的

interface 。这些接口需要通过FactoryBean解析，bangding相应的MethodHandler，然后注入到BeanDefinition。注意此时只是注册到BeanDefinition。

8：BeanInstance

9： BeanFactoryPostProcessor 这命名真让人误解

FactoryBean 不能自己注入到spring中去，需要BeanFactoryPostProcessor才能注入到spring中去。

10： BeanPostProcessor

11: InstantiationStrategy

12： proxy

13： Interceptor

下面介绍一下Processor

了解一两个Processor会对Bean的加工过程有所了解。个人感觉这种模式和pipeline模式很像。

Processor 没法自行启动，需要委托给 PostProcessorRegistrationDelegate 进行启动。

Processor 的执行有先后顺序关系。

对于BeanFactoryPostProcessor 而言 registryProcessors > regularPostProcessors

对应BeanPostProcessor而言

priorityOrderedPostProcessors > orderedPostProcessorNames > nonOrderedPostProcessorNames > internalPostProcessors

和Aop相关的Processor

所有Processor接口的子类，

BeanFactoryProcessor接口的子类也十分多。

最后介绍一个超级大Boss DefaultListableBeanFactory

整个BeanFactory的继承体系也十分庞大。

spring 最终注入依赖的地方

InjectionMetadata

protected void inject(Object target, @Nullable String requestingBeanName, @Nullable PropertyValues pvs) throws Throwable {

    if (this.isField) {

        Field field = (Field)this.member;

        ReflectionUtils.makeAccessible(field);

        field.set(target, this.getResourceToInject(target, requestingBeanName));

    } else {

        if (this.checkPropertySkipping(pvs)) {

            return;

        }

        try {

            Method method = (Method)this.member;

            ReflectionUtils.makeAccessible(method);

            method.invoke(target, this.getResourceToInject(target, requestingBeanName));

        } catch (InvocationTargetException var5) {

            throw var5.getTargetException();

        }

    }

}

程序架构设计应该不只是顺序思维，更应该锻炼立体思维，思前顾后，承上启下，注重接口和继承体系的设计，还应该掌握一些基础基本的专业术语，设计模式。

你应该明确自己研究的对象，怎么描述它，怎么构建它，怎么增强它，怎么存储它，以及怎么使用它。

与AOP相关的概念

Advide 。

Advisor

巴特西

Spring BeanFactory和现实工厂的对比

最新文章

热门文章