spring5之容器始末源码赏析 (一)总览

首先,本系列并不是以介绍spring5 的新特性为主,之所以以spring5为标题,是因为即将赏析的源码来自最新的spring版本.虽说是spring最新版本,但是容器的整个生命周期与之前版本相比,并没有很大的变化,我们主要来看spring是如何一步步构建自己的容器,一步步将混乱不堪,错综复杂的依赖关系管理的井井有条,一步步组建自己的spring帝国.

因为篇幅原因,并不能在一篇博客中将所有spring容器的内容都介绍完成,因此,将分为几个部分分别介绍,本篇会先从最顶层浏览一下spring的一些容器,以及spring抽象出的容器的组装过程,使我们对spring容器有一个整体上的认知.

　　先来介绍spring中几个重要的接口的作用:

1.BeanFactory

2.BeanDefinition

3.BeanDefinitionRegistry

4.ApplicationContext

先看BeanFactory,这个接口定义了所有beanfactory基础功能: 根据名称获取bean,获取bean的类型/别名,判断bean是否存在等,可以看到,所有实现了这个接口的类,都具备这个功能.

BeanDefinition,定义了容器管理的对象.这个接口是整个spring的核心.BeanDefinition可以看做spring的领域模型,它是对所有bean统一建模的产物,涵盖了bean的所有信息,所有注册进spring容器的bean均会被处理成各种beanDefinition的实现
存储起来.

BeanDefinitionRegistry定义了beanDefinition的注册功能.实现了这个接口的类,具备了注册beandefinition的能力,将组装好的beandefinition注册到容器中。

最后看ApplicationContext,这个是容器的接口,所有容器均实现了这个接口,它定义了容器的基本功能:获取容器名,获取父容器,获取beanfactory,注册bean,等等,来看一下继承关系:

我们发现它继承许多接口,这意味着实现这个接口的类,必须具备它所实现的所有类的功能,当然,这些功能正真实现的地方不会在application的实例中,这里用到了代理模式（百度）,将主要职责委托给其它实现接口的类去做，将调用者和实现者解耦，使代码具备良好的扩展性。

spring的容器有多种，我把它分两大类：应用类和web类。

应用类中常用的几个容器：

AnnotationConfigApplicationContext  （主要是注解驱动，spring3.0以后加入）

GenericXmlApplicationContext   （也是3.0以后加入的，可以作为下面两种的替代。相对与相面两个容器来说比较灵活，可以灵活设置xml）

ClassPathXmlApplicationContext  （和下面的容器基本一样，一个是类路径加载（主要特色是能加载jar中的xml文件），一个是文件路径加载。两者实现基本一样，所以会有GenericXmlApplicationContext的出现）

FileSystemXmlApplicationContext
web类的常用容器：
基本与上面一一对应，这里就简单列举一些：

AnnotationConfigWebApplicationContext

GenericWebApplicationContext

XmlWebApplicationContext

了解上面的基本概念以后，我们就要开始spring容器的探索之旅了，因为考虑到web容器还要考虑servlet版本，以及web.xml的配置，相对于应用容器来说稍微复杂一些。所以这次我们并不会以支持web容器为例去分析。
最近，springboot比较火爆（默认配置就是使用AnnotationConfigApplicationContext容器），我们就来看看AnnotationConfigApplicationContext这个容器，看它是如何把一个个注解都转化为自己认识的bean并管理起来，
并为我们提供各种各样的服务。（其实几个容器的底层实现都一样，毕竟是同一个爸生的。。。）
先看一个简单的栗子：

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.register(Level1Config.class);
context.refresh();
Level2Component l = (Level3Component) context.getBean("level2Component");
l.asd();

@Configuration
@ComponentScan("org.springframework.context.annotation.componentscan.level2")
public class Level1Config {
    @Bean
    public TestBean level1Bean() {
        return new TestBean("level1Bean");
    }
}

@Component
public class Level2Component {
    @Autowired
    SimpleComponent simpleComponent;
    public void asd(){
        simpleComponent.testq();
    }

}

@Component
public class SimpleComponent {

    public void testq(){
        System.out.println("asdf");
    }

    @Bean
    public String exampleBean() {
        return "example";
    }

}

这个栗子中，spring扫描了“org.springframework.context.annotation.componentscan.level2”包，装载了里面的Level2Component和SimpleComponent等，并将SimpleComponent实例化赋值给Level2Component，然后我们就可以通过context获取到Level2Component的实例，并调用SimpleComponent的方法。

我们看到从context的声明到bean实例被调用，只经过了4行代码，可谓简单至极，但在这背后却做了我们想象不到的许多事。

在深入源码之前，我们最好先从最顶层看一下它的架构，然后带着问题去看，这样才能有目的性的找到答案和学到东西，废话不多说，先看一下spring是如何装配AnnotationConfigApplicationContext的，个人总结如下：

准备 ——>初始化容器——>扫描装配beanDefinition(这里只是初步装配)——>组装实例化bean

因此，本系列也会分成四部分和大家一起来鉴赏各个流程的代码。

这里就先来介绍相对简单的一步：准备。

准备阶段，spring主要是为容器初始化一些bean，将一些配置文件读取，扫描器，beanfacotry，bean的一些默认处理工具类实例化并装配起来，看一下构造函数：

    public AnnotationConfigApplicationContext() {
        this.reader = new AnnotatedBeanDefinitionReader(this);
        this.scanner = new ClassPathBeanDefinitionScanner(this);
    }

还有它父类的构造函数：

    public GenericApplicationContext() {
        this.beanFactory = new DefaultListableBeanFactory();
    }

public AbstractApplicationContext() {
        this.resourcePatternResolver = getResourcePatternResolver();
    }

按照类初始化的顺序，我们可以看到，这里初始化了resourcePatternResolver，beanfactory，annotationBeanDefinitionReader,classPathBeanDefinitionScanner,这几个类，这些类的作用分别是：资源定位解析，定义bean容器，注解类解析，类路径资源扫描。它们的详细实现在后续讨论中依然会出现，这里我们只详细关注AnnotationBeanDefinitionReader,这个类，因为这个类参与了准备阶段的工作。

先看一下构造函数：

    public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
        Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
        Assert.notNull(environment, "Environment must not be null");
        this.registry = registry;
        this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
        AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
    }

ConditionEvaluator是@Conditional注解的解析的实现类，这里我们重点看

AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);

    public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
            BeanDefinitionRegistry registry, @Nullable Object source) {

        DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
        if (beanFactory != null) {
            if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
                beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
            }
            if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
                beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
            }
        }

        Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(4);

        if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
            RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
        }

        if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
            RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
        }

        if (!registry.containsBeanDefinition(REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
            RootBeanDefinition def = new RootBeanDefinition(RequiredAnnotationBeanPostProcessor.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
        }

        // Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
        if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
            RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
        }

        // Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
        if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
            RootBeanDefinition def = new RootBeanDefinition();
            try {
                def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
                        AnnotationConfigUtils.class.getClassLoader()));
            }
            catch (ClassNotFoundException ex) {
                throw new IllegalStateException(
                        "Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
            }
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
        }

        if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
            RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
        }
        if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
            RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
        }

        return beanDefs;
    }

在AnnotatedBeanDefinitionReader被实例化的时候spring洋洋洒洒注册了一堆bean，这些bean将在以后我们有新的bean加入的时候起关键性作用，比如改变bean的行为，比如监听发布事件，比如解析一个外部定义的配置类，等等，这些bean在后面的分析中均会一一出现，这里同样不做全面介绍，我们只要知道，这些bean实在这个时候就已经被spring装载进来了。

我们继续往下看：

接着就是注册我们自定义的bean了.

public void register(Class<?>... annotatedClasses) {
        Assert.notEmpty(annotatedClasses, "At least one annotated class must be specified");
        this.reader.register(annotatedClasses);
    }

在我们register配置类的时候reader（即AnnotationBeanDefinitionReader）的register方法会被调用，进而会调用它的doRegisterBean方法，将配置类注入容器中：

<T> void doRegisterBean(Class<T> annotatedClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,
            @Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {

        AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
        if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
            return;
        }

        abd.setInstanceSupplier(instanceSupplier);
        ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
        abd.setScope(scopeMetadata.getScopeName());
        String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));

        AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
        if (qualifiers != null) {
            for (Class<? extends Annotation> qualifier : qualifiers) {
                if (Primary.class == qualifier) {
                    abd.setPrimary(true);
                }
                else if (Lazy.class == qualifier) {
                    abd.setLazyInit(true);
                }
                else {
                    abd.addQualifier(new AutowireCandidateQualifier(qualifier));
                }
            }
        }
        for (BeanDefinitionCustomizer customizer : definitionCustomizers) {
            customizer.customize(abd);
        }

        BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
        definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
        BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
    }

按照顺序，首先我们可以看到，配置类会被放到AnnotatedGenericBeanDefinition中：

public AnnotatedGenericBeanDefinition(Class<?> beanClass) {
        setBeanClass(beanClass);
        this.metadata = new StandardAnnotationMetadata(beanClass, true);
    }

annotationGenericBeanDefinition实例会持有StandardAnnotationMetadata的实例，StandardAnnotationMetadata顾名思义，它是封装了这个类的注解的元数据。接着，spring会判断是否符合Condition注解的条件（spring4的加进来的一个注解），接下来会解析scope注解，来确定这个bean的作用域，接下来会调用processCommonDefinitionAnnotations方法处理一些常规的注解：@Primary，@DependsOn,@Rule.@Description，并将这些信息放入定义好的beanDefinition中，接着通过BeanDefinitionReaderUtils将beanDefinition注册到容器里。至此算是容器中的第一个我们自己的bean就注册完成。

我们看到，register方法实际上就是将配置类中一些我们不长用注解信息解析并放入beandefinition中，将注解元数据放入StandardAnnotationMetadata中，由beanDefinition持有，最终把beanDefinition放入容器中(beanFactory)，并没有发生什么不得了的事情，我们定义的注解类也只是初步解析，并没有进行扫描或者注入其它bean，事实上，在bean的准备阶段，spring确实没做多少事情，而是将一些十分重要的bean一一初始化进容器中，而我们自定义的配置类就是其中之一。

好了，第一阶段就到这里。第一阶段准备阶段，spring实例化了一个reader，并在实例化过程中装载了annotationConfigApplicationContext容器特有的bean的处理逻辑，随后把我们的配置类也装载进去变完成了准备阶段的工作。

转载请注明出处。