Springboot启动流程(五):Context

Springboot启动流程(五)
前面我们看了Spring的environment和banner.下面就到了同样重要的Context,
Context是做什么的?我的理解就是存放上下文需要用到的对象的,Spring是单利模式所以我们获取的对象要放在一块儿地方供以后调用,这个地方就是Context
接下来我们看下创建context的具体流程:
Application 类
public ConfigurableApplicationContext run(String... args) {
    ConfigurableApplicationContext context = null;
    try{
        // 省略已研究代码    
        context = createApplicationContext();
        exceptionReporters = getSpringFactoriesInstances(
                SpringBootExceptionReporter.class,
                new Class[] { ConfigurableApplicationContext.class }, context);
        prepareContext(context, environment, listeners, applicationArguments,
                printedBanner);
        refreshContext(context);
        afterRefresh(context, applicationArguments);
        stopWatch.stop();
        if (this.logStartupInfo) {
            new StartupInfoLogger(this.mainApplicationClass)
                    .logStarted(getApplicationLog(), stopWatch);
        }
        listeners.started(context);
        callRunners(context, applicationArguments);
    }
    catch (Throwable ex) {
        handleRunFailure(context, ex, exceptionReporters, listeners);
        throw new IllegalStateException(ex);
    }
    try {
        listeners.running(context);
    }
    catch (Throwable ex) {
        handleRunFailure(context, ex, exceptionReporters, null);
        throw new IllegalStateException(ex);
    }
    return context;
}
在run方法处理完environment和banner后,我们创建了一个context对象:
protected ConfigurableApplicationContext createApplicationContext() {
    Class<?> contextClass = this.applicationContextClass;
    if (contextClass == null) {
        try {
            switch (this.webApplicationType) {
            case SERVLET:
                contextClass = Class.forName(DEFAULT_SERVLET_WEB_CONTEXT_CLASS);
                break;
            case REACTIVE:
                contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS);
                break;
            default:
                contextClass = Class.forName(DEFAULT_CONTEXT_CLASS);
            }
        }
        catch (ClassNotFoundException ex) {
            throw new IllegalStateException(
                    "Unable create a default ApplicationContext, "
                            + "please specify an ApplicationContextClass",
                    ex);
        }
    }
    return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);
}
由于applicationContextClass没有赋值并且webApplicationType==SERVLET(参考启动流程(一)),所以会直接创建DEFAULT_SERVLET_WEB_CONTEXT_CLASS
的对象:
org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext
在创建context的时候先调用了父类 GenericApplicationContext 的构造方法:
public GenericApplicationContext() {
    this.beanFactory = new DefaultListableBeanFactory();
}
直接创建了一个 DefaultListableBeanFactory :
DefaultListableBeanFactory 类:
public DefaultListableBeanFactory() {
    super();
}
AbstractAutowireCapableBeanFactory 类:
public AbstractAutowireCapableBeanFactory() {
    super();
    ignoreDependencyInterface(BeanNameAware.class);
    ignoreDependencyInterface(BeanFactoryAware.class);
    ignoreDependencyInterface(BeanClassLoaderAware.class);
}
public void ignoreDependencyInterface(Class<?> ifc) {
    this.ignoredDependencyInterfaces.add(ifc);
}
AbstractBeanFactory 类:
public AbstractBeanFactory() {
}
这一段代码最有用的就是ignoreDependencyInterface()方法,他会把传入的class放入ignoredDependencyInterfaces中
/**
 * Dependency interfaces to ignore on dependency check and autowire, as Set of
 * Class objects. By default, only the BeanFactory interface is ignored.
 */
private final Set<Class<?>> ignoredDependencyInterfaces = new HashSet<>();
加入ignore去避免检查和和制动注入?
AnnotationConfigServletWebServerApplicationContext 类:
public AnnotationConfigServletWebServerApplicationContext() {
    this.reader = new AnnotatedBeanDefinitionReader(this);
    this.scanner = new ClassPathBeanDefinitionScanner(this);
}
创建了一个 AnnotatedBeanDefinitionReader 对象和一个 ClassPathBeanDefinitionScanner 对象,并赋值给 AnnotationConfigApplicationContext 对象
public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
    this(registry, getOrCreateEnvironment(registry));
}
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);
}

private static Environment getOrCreateEnvironment(BeanDefinitionRegistry registry) {
    Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
    if (registry instanceof EnvironmentCapable) {
        return ((EnvironmentCapable) registry).getEnvironment();
    }
    return new StandardEnvironment();
}
因为 AnnotationConfigServletWebServerApplicationContext 是间接继承 EnvironmentCapable 的(ApplicationContext)
所以会从registry里getEnvironment();
AbstractApplicationContext 类:
@Override
public ConfigurableEnvironment getEnvironment() {
    if (this.environment == null) {
        this.environment = createEnvironment();
    }
    return this.environment;
}
environment 是空的所以会调用createEnvironment,但是调用的是 GenericWebApplicationContext 类的createEnvironment方法,
这是为什么?
我的理解是:首先调用 getEnvironment 对象是 AnnotationConfigServletWebServerApplicationContext,但这个类里没有getEnvironment
方法,会调用他的父类的 AbstractApplicationContext ,然后获取的是是空,调用 createEnvironment 这个方法
AnnotationConfigServletWebServerApplicationContext 里还是没有,在调用父类,但这次在 GenericWebApplicationContext 里就有了,
所以会出现调用 GenericWebApplicationContext 类的 createEnvironment 方法的情况.
为了验证我写了个小demo,在我的github上,最后结果确实如我所料!
GenericWebApplicationContext 类:
@Override
protected ConfigurableEnvironment createEnvironment() {
    return new StandardServletEnvironment();
}
所以我们就直接获取了一个新的 StandardServletEnvironment 对象
接下来调用构造方法创建 AnnotatedBeanDefinitionReader:
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 对象:
ConditionEvaluator 类:
public ConditionEvaluator(@Nullable BeanDefinitionRegistry registry,
        @Nullable Environment environment, @Nullable ResourceLoader resourceLoader) {

    this.context = new ConditionContextImpl(registry, environment, resourceLoader);
}
ConditionContextImpl 类:
public ConditionContextImpl(@Nullable BeanDefinitionRegistry registry,
                @Nullable Environment environment, @Nullable ResourceLoader resourceLoader) {
    this.registry = registry;
    this.beanFactory = deduceBeanFactory(registry);
    this.environment = (environment != null ? environment : deduceEnvironment(registry));
    this.resourceLoader = (resourceLoader != null ? resourceLoader : deduceResourceLoader(registry));
    this.classLoader = deduceClassLoader(resourceLoader, this.beanFactory);
}

@Nullable
private ConfigurableListableBeanFactory deduceBeanFactory(@Nullable BeanDefinitionRegistry source) {
    if (source instanceof ConfigurableListableBeanFactory) {
        return (ConfigurableListableBeanFactory) source;
    }
    if (source instanceof ConfigurableApplicationContext) {
        return (((ConfigurableApplicationContext) source).getBeanFactory());
    }
    return null;
}

private ResourceLoader deduceResourceLoader(@Nullable BeanDefinitionRegistry source) {
    if (source instanceof ResourceLoader) {
        return (ResourceLoader) source;
    }
    return new DefaultResourceLoader();
}

@Nullable
private ClassLoader deduceClassLoader(@Nullable ResourceLoader resourceLoader,
        @Nullable ConfigurableListableBeanFactory beanFactory) {

    if (resourceLoader != null) {
        ClassLoader classLoader = resourceLoader.getClassLoader();
        if (classLoader != null) {
            return classLoader;
        }
    }
    if (beanFactory != null) {
        return beanFactory.getBeanClassLoader();
    }
    return ClassUtils.getDefaultClassLoader();
}
这一串代码非常好理解,首先获取registry的Beanfactory,然后赋值environment,获取一个DefaultResourceLoader(当前线程的classLoader).
然后 AnnotatedBeanDefinitionReader 类调用方法
AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
public static void registerAnnotationConfigProcessors(BeanDefinitionRegistry registry) {
    registerAnnotationConfigProcessors(registry, null);
}
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<>(8);

    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));
    }

    // 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;
}

@Nullable
private static DefaultListableBeanFactory unwrapDefaultListableBeanFactory(BeanDefinitionRegistry registry) {
    if (registry instanceof DefaultListableBeanFactory) {
        return (DefaultListableBeanFactory) registry;
    }
    else if (registry instanceof GenericApplicationContext) {
        return ((GenericApplicationContext) registry).getDefaultListableBeanFactory();
    }
    else {
        return null;
    }
}
这里面涉及的类很多,我们先来看unwrapDefaultListableBeanFactory方法,直接返回beanFactory,然后判断
if (beanFactory != null) {
    if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
        beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
    }
    if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
        beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
    }
}
首先beanFactory是不为空的,所以getDependencyComparator,获取到的是空,不属于 AnnotationAwareOrderComparator,
运行:beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE),
AnnotationAwareOrderComparator 类:
public static final AnnotationAwareOrderComparator INSTANCE = new AnnotationAwareOrderComparator();
直接创建了 AnnotationAwareOrderComparator 对象.
然后getAutowireCandidateResolver,获取到的是一个 SimpleAutowireCandidateResolver 对象:
DefaultListableBeanFactory 类:
private AutowireCandidateResolver autowireCandidateResolver = new SimpleAutowireCandidateResolver();
不属于 ContextAnnotationAutowireCandidateResolver 类,放入 对象.
然后
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));
}
因为beanDefinitionMap是个空的map所以,返回false,进入内部代码:
创建了 RootBeanDefinition 对象
RootBeanDefinition 类:
public RootBeanDefinition(@Nullable Class<?> beanClass) {
    super();
    setBeanClass(beanClass);
}
AbstractBeanDefinition 类:
protected AbstractBeanDefinition() {
    this(null, null);
}
放入两个null
protected AbstractBeanDefinition(@Nullable ConstructorArgumentValues cargs, @Nullable MutablePropertyValues pvs) {
    this.constructorArgumentValues = cargs;
    this.propertyValues = pvs;
}
然后 setBeanClass(beanClass); 
public void setBeanClass(@Nullable Class<?> beanClass) {
    this.beanClass = beanClass;
}
把beanClass对象赋值,传入的是 ConfigurationClassPostProcessor.class 
然后def.setSource(source),source是空,放入一个空,
在调用registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)方法:

private static BeanDefinitionHolder registerPostProcessor(
            BeanDefinitionRegistry registry, RootBeanDefinition definition, String beanName) {

    definition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
    registry.registerBeanDefinition(beanName, definition);
    return new BeanDefinitionHolder(definition, beanName);
}
在root中放入 BeanDefinition.ROLE_INFRASTRUCTURE (2),然后注册beanName和definition到context中,
@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
        throws BeanDefinitionStoreException {

    Assert.hasText(beanName, "Bean name must not be empty");
    Assert.notNull(beanDefinition, "BeanDefinition must not be null");

    if (beanDefinition instanceof AbstractBeanDefinition) {
        try {
            ((AbstractBeanDefinition) beanDefinition).validate();
        }
        catch (BeanDefinitionValidationException ex) {
            throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
                    "Validation of bean definition failed", ex);
        }
    }

    BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
    if (existingDefinition != null) {
        if (!isAllowBeanDefinitionOverriding()) {
            throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
        }
        else if (existingDefinition.getRole() < beanDefinition.getRole()) {
            // e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
            if (logger.isInfoEnabled()) {
                logger.info("Overriding user-defined bean definition for bean '" + beanName +
                        "' with a framework-generated bean definition: replacing [" +
                        existingDefinition + "] with [" + beanDefinition + "]");
            }
        }
        else if (!beanDefinition.equals(existingDefinition)) {
            if (logger.isDebugEnabled()) {
                logger.debug("Overriding bean definition for bean '" + beanName +
                        "' with a different definition: replacing [" + existingDefinition +
                        "] with [" + beanDefinition + "]");
            }
        }
        else {
            if (logger.isTraceEnabled()) {
                logger.trace("Overriding bean definition for bean '" + beanName +
                        "' with an equivalent definition: replacing [" + existingDefinition +
                        "] with [" + beanDefinition + "]");
            }
        }
        this.beanDefinitionMap.put(beanName, beanDefinition);
    }
    else {
        if (hasBeanCreationStarted()) {
            // Cannot modify startup-time collection elements anymore (for stable iteration)
            synchronized (this.beanDefinitionMap) {
                this.beanDefinitionMap.put(beanName, beanDefinition);
                List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
                updatedDefinitions.addAll(this.beanDefinitionNames);
                updatedDefinitions.add(beanName);
                this.beanDefinitionNames = updatedDefinitions;
                if (this.manualSingletonNames.contains(beanName)) {
                    Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
                    updatedSingletons.remove(beanName);
                    this.manualSingletonNames = updatedSingletons;
                }
            }
        }
        else {
            // Still in startup registration phase
            this.beanDefinitionMap.put(beanName, beanDefinition);
            this.beanDefinitionNames.add(beanName);
            this.manualSingletonNames.remove(beanName);
        }
        this.frozenBeanDefinitionNames = null;
    }

    if (existingDefinition != null || containsSingleton(beanName)) {
        resetBeanDefinition(beanName);
    }
}
又是一大段代码,不要慌,跟着流程走就行,
首先:
if (beanDefinition instanceof AbstractBeanDefinition) {
    try {
        ((AbstractBeanDefinition) beanDefinition).validate();
    }
    catch (BeanDefinitionValidationException ex) {
        throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
                "Validation of bean definition failed", ex);
    }
}
beanDefinition 就是我们刚刚传入的 RootBeanDefinition ,继承了 AbstractBeanDefinition 所以进入
((AbstractBeanDefinition) beanDefinition).validate(); 代码中,
AbstractBeanDefinition 类:
public void validate() throws BeanDefinitionValidationException {
    if (hasMethodOverrides() && getFactoryMethodName() != null) {
        throw new BeanDefinitionValidationException(
                "Cannot combine static factory method with method overrides: " +
                "the static factory method must create the instance");
    }

    if (hasBeanClass()) {
        prepareMethodOverrides();
    }
}
判断hasMethodOverrides和getFactoryMethodName
public boolean hasMethodOverrides() {
    return (this.methodOverrides != null && !this.methodOverrides.isEmpty());
}
@Override
@Nullable
public String getFactoryMethodName() {
    return this.factoryMethodName;
}
因为methodOverrides == null 所以返回false,factoryMethodName是空,所以不会判处异常,
然后
if (hasBeanClass()) {
    prepareMethodOverrides();
}
beanClass 是在root创建对象时set进去的(ConfigurationClassPostProcessor.class)所以进入prepareMethodOverrides方法:
public void prepareMethodOverrides() throws BeanDefinitionValidationException {
    // Check that lookup methods exists.
    if (hasMethodOverrides()) {
        Set<MethodOverride> overrides = getMethodOverrides().getOverrides();
        synchronized (overrides) {
            for (MethodOverride mo : overrides) {
                prepareMethodOverride(mo);
            }
        }
    }
}
同样调用 hasMethodOverrides ,这个方法返回false,所以什么都没有处理,所以validate所做的事儿仅仅是判断是否回抛出异常,
BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);这个方法获取existingDefinition,
beanDefinitionMap是一个空的map所以拿到的是空,beanName是传入的 CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME == 
org.springframework.context.annotation.internalConfigurationAnnotationProcessor.
走到底下:
if (hasBeanCreationStarted()) {
    // Cannot modify startup-time collection elements anymore (for stable iteration)
    synchronized (this.beanDefinitionMap) {
        this.beanDefinitionMap.put(beanName, beanDefinition);
        List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
        updatedDefinitions.addAll(this.beanDefinitionNames);
        updatedDefinitions.add(beanName);
        this.beanDefinitionNames = updatedDefinitions;
        if (this.manualSingletonNames.contains(beanName)) {
            Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
            updatedSingletons.remove(beanName);
            this.manualSingletonNames = updatedSingletons;
        }
    }
}

protected boolean hasBeanCreationStarted() {
    return !this.alreadyCreated.isEmpty();
}
alreadyCreated是一个空的set,hasBeanCreationStarted返回false,所以也不进这个if,然后下面的else的代码:
else {
    // Still in startup registration phase
    this.beanDefinitionMap.put(beanName, beanDefinition);
    this.beanDefinitionNames.add(beanName);
    this.manualSingletonNames.remove(beanName);
}
向beanDefinitionMap,beanDefinitionNames,里加数据,然后manualSingletonNames里remove数据.然后
this.frozenBeanDefinitionNames = null;把frozenBeanDefinitionNames赋值为空,下面的if
if (existingDefinition != null || containsSingleton(beanName)) {
    resetBeanDefinition(beanName);
}
因为existingDefinition是空的,所以也不走,这么一大段其实走的没有多少,把beanName和root注册到context中的beanFactory后
new BeanDefinitionHolder(definition, beanName) 创建一个BeanDefinitionHolder对象,
BeanDefinitionHolder 类:
public BeanDefinitionHolder(BeanDefinition beanDefinition, String beanName) {
    this(beanDefinition, beanName, null);
}
public BeanDefinitionHolder(BeanDefinition beanDefinition, String beanName, @Nullable String[] aliases) {
    Assert.notNull(beanDefinition, "BeanDefinition must not be null");
    Assert.notNull(beanName, "Bean name must not be null");
    this.beanDefinition = beanDefinition;
    this.beanName = beanName;
    this.aliases = aliases;
}
把参数赋值并返回就结束了.
beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) 方法加入返回的handle,
然后后面
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));
}
同样的套路,创建一个 RootBeanDefinition 对象,然后赋值beanClass对象为 AutowiredAnnotationBeanPostProcessor.class
然后放入source,在绑定,然后加入def
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));
}
这个是一样的.
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));
}
这一段代码因为jpaPresent是false直接跳过,
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));
}
这两段也是重复的代码,就不细看了,感觉这点儿可以优化一下的...
最后返回beanDefs,
AnnotatedBeanDefinitionReader 的对象到此就创建完了,
public AnnotationConfigServletWebServerApplicationContext() {
    this.reader = new AnnotatedBeanDefinitionReader(this);
    this.scanner = new ClassPathBeanDefinitionScanner(this);
}
之后创建 ClassPathBeanDefinitionScanner 类:

ClassPathBeanDefinitionScanner 类,
public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry) {
    this(registry, true);
}
public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters) {
    this(registry, useDefaultFilters, getOrCreateEnvironment(registry));
}
public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
            Environment environment) {

    this(registry, useDefaultFilters, environment,
            (registry instanceof ResourceLoader ? (ResourceLoader) registry : null));
}
因为之前放入过environment,所以直接get到environment,最后直接调用:
public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
        Environment environment, @Nullable ResourceLoader resourceLoader) {

    Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
    this.registry = registry;

    if (useDefaultFilters) {
        registerDefaultFilters();
    }
    setEnvironment(environment);
    setResourceLoader(resourceLoader);
}
因为前面 useDefaultFilters 给的是 true ,所以调用 registerDefaultFilters 方法:
protected void registerDefaultFilters() {
    this.includeFilters.add(new AnnotationTypeFilter(Component.class));
    ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();
    try {
        this.includeFilters.add(new AnnotationTypeFilter(
                ((Class<? extends Annotation>) ClassUtils.forName("javax.annotation.ManagedBean", cl)), false));
        logger.trace("JSR-250 'javax.annotation.ManagedBean' found and supported for component scanning");
    }
    catch (ClassNotFoundException ex) {
        // JSR-250 1.1 API (as included in Java EE 6) not available - simply skip.
    }
    try {
        this.includeFilters.add(new AnnotationTypeFilter(
                ((Class<? extends Annotation>) ClassUtils.forName("javax.inject.Named", cl)), false));
        logger.trace("JSR-330 'javax.inject.Named' annotation found and supported for component scanning");
    }
    catch (ClassNotFoundException ex) {
        // JSR-330 API not available - simply skip.
    }
}
创建 AnnotationTypeFilter 对象,并加入 includeFilters 中:
AnnotationTypeFilter 继承 AbstractTypeHierarchyTraversingFilter
public AnnotationTypeFilter(Class<? extends Annotation> annotationType, boolean considerMetaAnnotations) {
    this(annotationType, considerMetaAnnotations, false);
}

public AnnotationTypeFilter(
        Class<? extends Annotation> annotationType, boolean considerMetaAnnotations, boolean considerInterfaces) {
    super(annotationType.isAnnotationPresent(Inherited.class), considerInterfaces);
    this.annotationType = annotationType;
    this.considerMetaAnnotations = considerMetaAnnotations;
}

AbstractTypeHierarchyTraversingFilter 类:
protected AbstractTypeHierarchyTraversingFilter(boolean considerInherited, boolean considerInterfaces) {
    this.considerInherited = considerInherited;
    this.considerInterfaces = considerInterfaces;
}
所以上面这块儿代码吧传入的Component.class赋值给AnnotationTypeFilter类.然后把并加入includeFilters中.
之后调用 ClassPathBeanDefinitionScanner 构造方法的 setEnvironment(environment);方法:
public void setEnvironment(Environment environment) {
    Assert.notNull(environment, "Environment must not be null");
    this.environment = environment;
    this.conditionEvaluator = null;
}
把environment赋值,调用 setResourceLoader
@Override
public void setResourceLoader(@Nullable ResourceLoader resourceLoader) {
    this.resourcePatternResolver = ResourcePatternUtils.getResourcePatternResolver(resourceLoader);
    this.metadataReaderFactory = new CachingMetadataReaderFactory(resourceLoader);
    this.componentsIndex = CandidateComponentsIndexLoader.loadIndex(this.resourcePatternResolver.getClassLoader());
}
resourceLoader 是传入的 AnnotatedBeanDefinitionReader 对象,获取resourceLoader并放入对象中.
到此创建context完成.