spring源码学习（一）

由于本人水平有限，本文内容较为简单，仅供个人学习笔记，或者大家参考，如果能够帮助大家，荣幸之至！本文主要分析AnnotationConfigApplicationContext实例化之后，到底干了那些事情。

• 首先通过实例化applicationContext

　　

AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(Appconfig.class);
 
AnnotationConfigApplicationContext.getBean("beanName");

分析：第一句实例化annotationConfigApplicationContext，初始化了spring的环境，第二句就可以从spring ioc容器中获取bean。

• 接下来查看构造方法

public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
        this();
        register(annotatedClasses);
        refresh();
    }

• 分析：this()方法会先调用父类的构造函数，再调用当前类的默认构造方法，在父类的构造方法当中，实例化了DefaultListableBeanFactory对象，spring当中的默认工厂, 在当前类的构造函数当中实例化了一个reader和scanner。

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

• 这里的beanFactory很重要，后续实例化beanDefinition、beanName都存储在这里。

        this.reader = new AnnotatedBeanDefinitionReader(this);
        this.scanner = new ClassPathBeanDefinitionScanner(this);

• reader用来读取被加了注解的beanDenition,以及在当前的构造函数当中，会实例化spring当中非常重要的五个beanPostProcessor(后续分析),以及一个beanFactory，在本文最后会对其分析。
• scanner顾名思义是用来扫描的，只不过是提供外部程序员来调用的，spring内部并没有使用到。

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

• 这里的register方法就是调用了我们在构造函数当中初始化的reader，来完成注册beanDenifition。这里注册的类参数是一个数组，通过for循环来处理。注册一个bean之后需要调用refresh()方法，来完成实例化。如果注册了Appconfig类的话，如果不调用refresh()方法，项目会报错，如果注册的是普通的bean，在通过getBean来获取的时候，底层方法会手动调用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 (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);
    }

• 分析：首先会判断是否跳过解析，如果元数据为null，或者没有加condition注解则返回false。因为该beanDenifition是初始化new出来的，所以元数据永远不会为空。接下来获取bean的作用域范围，默认是单例，生成beanName,接下来解析类的通用注解，比如说lazy，primary，description等等注解。处理限定符注解，还有自定义注解。beanDefinitionHolder主要是为了传值，在注册beanDenifition时候可以少传一个参数。这里传的这几个参数永远为null，比如@Nullable Supplier<T> instanceSupplier, @Nullable String name, @Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers，所以不用解析，如果我们想要解析，只能获取到reader对象，手动调用传参数给他。

　　　　　　　　　　// Still in startup registration phase
                this.beanDefinitionMap.put(beanName, beanDefinition);
                this.beanDefinitionNames.add(beanName);
                this.manualSingletonNames.remove(beanName);

• map当中存储key:beanName,value:beanDefinition，beanDefinitionName集合当中存储所有的beanDenifitionName。

                // Register aliases for bean name, if any.
        String[] aliases = definitionHolder.getAliases();
        if (aliases != null) {
            for (String alias : aliases) {
                registry.registerAlias(beanName, alias);
            }
        }

• 源码当中处理类的别名，spring当中如果设置了别名，可以通过id或者别名从spring容器当中获取类的实例。

接下来查看最后一个refresh方法，spring当中的bean生命周期，就是从这里开始的

@Override
    public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            prepareRefresh();
 
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
 
            // Prepare the bean factory for use in this context.
            prepareBeanFactory(beanFactory);
 
            try {
                // Allows post-processing of the bean factory in context subclasses.
 
                postProcessBeanFactory(beanFactory);
 
                // Invoke factory processors registered as beans in the context.
                invokeBeanFactoryPostProcessors(beanFactory);
 
                // Register bean processors that intercept bean creation.
                registerBeanPostProcessors(beanFactory);
 
                // Initialize message source for this context.
                initMessageSource();
 
                // Initialize event multicaster for this context.
 
                initApplicationEventMulticaster();
 
                // Initialize other special beans in specific context subclasses.
                onRefresh();
 
                // Check for listener beans and register them.
                registerListeners();
 
                // Instantiate all remaining (non-lazy-init) singletons.
                finishBeanFactoryInitialization(beanFactory);
 
                // Last step: publish corresponding event.
                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();
            }
        }
    }

分析：ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();获取我们的beanFactory，bean的生命周期就是从这里开始的，prepareBeanFactory顾名思义准备beanfactory,包括设置类加载器、解析器（解析类似与el表达式的页面语句，由spring提供的）、属性编辑器（spring boot当中的yml配置）、这里最重要的是添加了一个BeanPostProcessor,beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));来看这里做了什么事情！

class ApplicationContextAwareProcessor implements BeanPostProcessor

该类继承自BeanPostProcessor,实现了这两个方法

    @Nullable
    default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
    @Nullable
    default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

缓存预热之时，我们会使用@PostConstruct注解初始化init()方法，在构造函数之后执行，@preDestroy在销毁之后执行。后置处理器spring提供给我们的扩展点，这两个方法会在init方法的前后执行，spring当中的AOP也是这样来完成对IOC的加强的，已经把bean暴漏出来了，在这里返回代理对象即可。接下来看ApplicationContextAwareProcessor实现后置处理器做了那些事情。

@Override
    @Nullable
    public Object postProcessBeforeInitialization(final Object bean, String beanName) throws BeansException {
        AccessControlContext acc = null;
 
        if (System.getSecurityManager() != null &&
                (bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
                        bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
                        bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)) {
            acc = this.applicationContext.getBeanFactory().getAccessControlContext();
        }
 
        if (acc != null) {
            AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                invokeAwareInterfaces(bean);
                return null;
            }, acc);
        }
        else {
            invokeAwareInterfaces(bean);
        }
 
        return bean;
    }
 
    private void invokeAwareInterfaces(Object bean) {
        if (bean instanceof Aware) {
            if (bean instanceof EnvironmentAware) {
 
                ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
            }
            if (bean instanceof EmbeddedValueResolverAware) {
                ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
            }
            if (bean instanceof ResourceLoaderAware) {
                ((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
            }
            if (bean instanceof ApplicationEventPublisherAware) {
                ((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
            }
            if (bean instanceof MessageSourceAware) {
                ((MessageSourceAware) bean).setMessageSource(this.applicationContext);
            }
            if (bean instanceof ApplicationContextAware) {
                if (!bean.getClass().getSimpleName().equals("IndexDao"))
                ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
            }
        }
    }

分析：这里主要判断是否实现了ApplicationContextAware接口，如果实现了，就把applicationContext注入给他。此时就可以解释为什么实现了applicationcontext接口，重写set方法，就可以获取applicationContext，解决单例模式下获取原型对象了。关于spring当中的其他后置处理器，会在后续文章中更新！