基于注解的Spring容器源码分析

    从spring3.0版本引入注解容器类之后，Spring注解的使用就变得异常的广泛起来，到如今流行的SpringBoot中，几乎是全部使用了注解。Spring的常用注解有很多，有@Bean，@Compont，@Autowired等。这些注解的使用和基于xml文件的使用的方式如出一辙，只是一个是用注解一个是用配置文件而已。那么要学习Spring注解的原理，那么我们就得从基于注解spring容器类AnnotationConfigApplicationContext开始，接下来我们来分析：

第一步：看他的构造器

 
  public AnnotationConfigApplicationContext() {
        this.reader = new AnnotatedBeanDeFinitionReader(this);
        this.scanner = new ClasspathBeanDeFinitionScanner();
    }

    

 //给定一个beanfactory

public AnnotationConfigApplicationContext(DefaultListablebeanfactory beanfactory) { 
　　super(beanfactory); 
　　this.reader = ); 
　　this.scanner = ); 

}

     //用一个被注解的类创建一个AnonotationConfigApplicationContext
    public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
        ();
        register(annotatedClasses);
        refresh();
    }

    //扫描包名及子包类的被注解的类
     AnnotationConfigApplicationContext(String... basePackages) {
        ();
        scan(basePackages);
        refresh();
    }

 第二步：实际分析，我们构造一个AnnotationConfigApplicationContext对象，内部会做什么具体的操作。

我写了一个测试类，代码如下：

 AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyBeanConfig.class);

他调用的构造器是这个：

... annotatedClasses) {
        
 //初始化了AnnotatedBeanDeFinitionReader和ClasspathBeanDeFinitionScanner
        this();
 //注册类
        register(annotatedClasses);
 //刷新
        refresh();
    }

重点就是register方法和refresh方法分别都做了什么。

先来看register方法，点进去之后的代码如下：

<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 (.conditionEvaluator.shouldSkip(abd.getMetadata())) {
            return;
        }
        //supplier有返回值无参数的接口
        abd.setInstancesupplier(instancesupplier);
 //检查scope，实例中没有指定，默认是singleton
        ScopeMetadata scopeMetadata = .scopeMetadataResolver.resolveScopeMetadata(abd);
        abd.setScope(scopeMetadata.getScopeName());
  //获取bean的名字，实例中这里是MyBeanConfig
        String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd,.registry));
         //对于是否是@lazy，是否使用了@primary
        AnnotationConfigUtils.processCommonDeFinitionAnnotations(abd);
//是否使用了@qualifier
        if (qualifiers != null) {
            for (Class<?  qualifier : qualifiers) {
                if (Primary.class == qualifier) {
                    abd.setPrimary(true);
                }
                else if (Lazy. qualifier) {
                    abd.setLazyInit(else {
                    abd.addQualifier( AutowireCandidateQualifier(qualifier));
                }
            }
        }
for (BeanDeFinitionCustomizer customizer : deFinitionCustomizers) {
            customizer.customize(abd);
        }
        
        BeanDeFinitionHolder deFinitionHolder =  BeanDeFinitionHolder(abd,beanName);
 //根据Bean的作用域，创建相应的代理对象
        deFinitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata,deFinitionHolder,1)">.registry);
 //将Bean加入到beanDeFinitionMap中
        BeanDeFinitionReaderUtils.registerBeanDeFinition(deFinitionHolder,.registry);
    }

到这里register方法就介绍完了。

然后看refresh方法：

public void refresh() throws BeansException,IllegalStateException {
        synchronized (.startupShutdownMonitor) {
            // 刷新前的准备
            prepareRefresh();

             创建并获取一个beanFanctory
            ConfigurableListablebeanfactory beanfactory = obtainFreshbeanfactory();

             使用beanfactory之前的准备
            preparebeanfactory(beanfactory);

            try {
                给子类实现用的，默认是空方法
                postProcessbeanfactory(beanfactory);

                //执行beanfactory的后处理
                invokebeanfactoryPostProcessors(beanfactory);

                 注册BeanPostProcessor，对bean进行初始化的前后可以调用
                registerBeanPostProcessors(beanfactory);

                 初始化MessageSource
                initMessageSource();

                 初始化application事件派发器
                initApplicationEventMulticaster();

                 预留给子类来实现
                onRefresh();

                 添加application监听器
                registerListeners();

                初始化最后所有剩下的单实例bean
                finishbeanfactoryInitialization(beanfactory);

                 完成bean和beanfactory初始化。
                finishRefresh();
            }

            catch (BeansException ex) {
                if (logger.isWarnEnabled()) {
                    logger.warn("Exception encountered during context initialization - " +
                            "cancelling refresh attempt: " + ex);
                }

                 Destroy already created singletons to avoid dangling resources.
                destroyBeans();

                 Reset 'active' flag.
                cancelRefresh(ex);

                 Propagate exception to caller.
                throw ex;
            }

            finally Reset common introspection caches in Spring's core,since we
                 might not ever need Metadata for singleton beans anymore...
                resetCommonCaches();
            }
        }
    }

所有的bean都放入到了容器中了。还有部分内容不准确不详尽，等以后埋坑。。。