在山的那边

  博客园  :: 首页  :: 新随笔  :: 联系 :: 订阅 订阅  :: 管理
  17 Posts :: 0 Stories :: 0 Comments :: 0 Trackbacks

     首先,本系列并不是以介绍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的处理逻辑,随后把我们的配置类也装载进去变完成了准备阶段的工作。

 

                                                                                                                                                    转载请注明出处。

 

posted on 2018-04-21 19:05  在山的那边  阅读(315)  评论(0编辑  收藏