createApplicationContext()实例AnnotationConfigServletWebServerApplicationContext

1. 创建应用上下文

在初始化SpringApplication实例中, 已经分析了当前模块web类型为SERVLET, 所以当前实例化了一个AnnotationConfigServletWebServerApplicationContext对象

public class SpringApplication {
    public ConfigurableApplicationContext run(String... args) {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        //应用上下文
        ConfigurableApplicationContext context = null;
        Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
        configureHeadlessProperty();
        SpringApplicationRunListeners listeners = getRunListeners(args);
        listeners.starting();
        try {
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(
                    args);
            ConfigurableEnvironment environment = prepareEnvironment(listeners,
                    applicationArguments);
            configureIgnoreBeanInfo(environment);
            Banner printedBanner = printBanner(environment);
            //本文的重点
            //创建应用上下文
            //AnnotationConfigServletWebServerApplicationContext
            context = createApplicationContext();
        //...
    }
    
    public static final String DEFAULT_SERVLET_WEB_CONTEXT_CLASS = "org.springframework.boot."
            + "web.servlet.context.AnnotationConfigServletWebServerApplicationContext";

    //创建应用上下文
    protected ConfigurableApplicationContext createApplicationContext() {
    Class<?> contextClass = this.applicationContextClass;
    if (contextClass == null) {
        try {
            switch (this.webApplicationType) {
            case SERVLET:
                //我们使用的是servlet web环境
                //实例化AnnotationConfigServletWebServerApplicationContext对象
                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);
        }
    }
    //返回的是一个AnnotationConfigServletWebServerApplicationContext对象
    return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);
}
}

由上面类图,我们可以看出, 类继承关系如下:

AnnotationConfigServletWebServerApplicationContext类继承了ServletWebServerApplicationContext
ServletWebServerApplicationContext继承了GenericWebApplicationContext
GenericWebApplicationContext继承了GenericApplicationContext
GenericApplicationContext继承了AbstractApplicationContext
AbstractApplicationContext继承了DefaultResourceLoader

2. DefaultResourceLoader

用来加载Resource, 初始化的过程中, 实例化了ClassLoader,

//默认的资源加载器
public class DefaultResourceLoader implements ResourceLoader {
   @Nullable
    private ClassLoader classLoader;

    //自定义ProtocolResolver, 用于获取资源
    private final Set<ProtocolResolver> protocolResolvers = new LinkedHashSet<>(4);

    //
    private final Map<Class<?>, Map<Resource, ?>> resourceCaches = new ConcurrentHashMap<>(4);
    
    //实例化ClassLoader
    public DefaultResourceLoader() {
        this.classLoader = ClassUtils.getDefaultClassLoader();
    }
    
    //加载资源
    @Override
    public Resource getResource(String location) {
        Assert.notNull(location, "Location must not be null");

        //自定义资源加载方式
        for (ProtocolResolver protocolResolver : this.protocolResolvers) {
            //调用ProtocolResolver的resolve方法
            Resource resource = protocolResolver.resolve(location, this);
            if (resource != null) {
                //如果获取到资源,立即返回
                return resource;
            }
        }
        
        if (location.startsWith("/")) {
            //先判断是否是根目录
            return getResourceByPath(location);
        }
        else if (location.startsWith(CLASSPATH_URL_PREFIX)) {
            //再判断是否是classpath下的资源
            return new ClassPathResource(location.substring(CLASSPATH_URL_PREFIX.length()), getClassLoader());
        }
        else {
            try {
                //先当做一个URL处理
                URL url = new URL(location);
                //先判断是否是一个file
                //不是file的话,再从URL中获取
                return (ResourceUtils.isFileURL(url) ? new FileUrlResource(url) : new UrlResource(url));
            }
            catch (MalformedURLException ex) {
                //获取不到资源的话
                //当做resource处理
                return getResourceByPath(location);
            }
        }
    }
}

3. AbstractApplicationContext

抽象ApplicationContext, 定义了ApplicationContext一些模板方法, 在实例化的过程中, 调用了getResourcePatternResolver()方法, 构造了一个PathMatchingResourcePatternResolver, 规定了如何查找资源, 例如从classpath, 根路径, 从war包等查找资源

public abstract class AbstractApplicationContext extends DefaultResourceLoader
        implements ConfigurableApplicationContext {
    
    private ResourcePatternResolver resourcePatternResolver;
    //初始化一个resourcePatternResolver
    public AbstractApplicationContext() {
        this.resourcePatternResolver = getResourcePatternResolver();
    }
    
    //该方法被GenericWebApplicationContext类重写
    //实际调用的是GenericWebApplicationContext的getResourcePatternResolver()方法
    protected ResourcePatternResolver getResourcePatternResolver() {
        //this实现了DefaultResourceLoader
        //可以作为PathMatchingResourcePatternResolver构造函数的参数
        return new PathMatchingResourcePatternResolver(this);
    }
}

4. GenericApplicationContext

初始化了一个DefaultListableBeanFactory

public class GenericApplicationContext extends AbstractApplicationContext implements BeanDefinitionRegistry {
    private final DefaultListableBeanFactory beanFactory;
    //初始化beanFactory
    public GenericApplicationContext() {
        this.beanFactory = new DefaultListableBeanFactory();
    }
}

由上面类图, 我们可以看出DefaultListableBeanFactory的继承关系:

DefaultListableBeanFactory继承了AbstractAutowireCapableBeanFactory
AbstractAutowireCapableBeanFactory继承了AbstractBeanFactory
AbstractBeanFactory继承了FactoryBeanRegistrySupport
FactoryBeanRegistrySupport继承了DefaultSingletonBeanRegistry
DefaultSingletonBeanRegistry继承了SimpleAliasRegistry

4.1 SimpleAliasRegistry

提供了bean别名的增删改查功能

public class SimpleAliasRegistry implements AliasRegistry {

    //key是bean别名
    //value是原始bean名称
    private final Map<String, String> aliasMap = new ConcurrentHashMap<>(16);
}

4.2 DefaultSingletonBeanRegistry

默认的单例Bean注册器, 提供了单例bean增删改查等功能

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {

    //缓存单例bean, key为bean名称,value为bean实例
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

    //缓存beanFactory, key为bean名称,value为beanFactory
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

    //早期单例缓存, key为bean名称,value为bean实例
    private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

    //单例bean名称set
    private final Set<String> registeredSingletons = new LinkedHashSet<>(256);

    //正在创建的单例bean名称set
    private final Set<String> singletonsCurrentlyInCreation =
            Collections.newSetFromMap(new ConcurrentHashMap<>(16));

    //当前在创建检查中排除的bean名称set
    private final Set<String> inCreationCheckExclusions =
            Collections.newSetFromMap(new ConcurrentHashMap<>(16));

    //异常set
    @Nullable
    private Set<Exception> suppressedExceptions;

    //正在销毁的bean名称set
    private boolean singletonsCurrentlyInDestruction = false;

    //一次性的bean实例
    private final Map<String, Object> disposableBeans = new LinkedHashMap<>();

    //bean包含关系map, key为bean名称, value为被包含的bean名称
    private final Map<String, Set<String>> containedBeanMap = new ConcurrentHashMap<>(16);

    //bean依赖关系缓存, key为bean名称,value为依赖该bean的bean名称
    private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<>(64);

    //bean依赖关系缓存,key为bean名称,value为该bean依赖的bean名称
    private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<>(64);
}

4.3 FactoryBeanRegistrySupport

提供了FactoryBean的增删改查方法

public abstract class FactoryBeanRegistrySupport extends DefaultSingletonBeanRegistry {

    //缓存FactoryBean单例的Map
    private final Map<String, Object> factoryBeanObjectCache = new ConcurrentHashMap<>(16);
}

4.4 AbstractBeanFactory

抽象BeanFactory, 定义了通用的beanFactory的模板方法, 添加了对beanFactory对Scope的支持, scope主要有五种, singleton, prototype, request, session和application,

ConfigurableBeanFactory定义两个SCOPE
- SCOPE_SINGLETON = "singleton"
- SCOPE_PROTOTYPE = "prototype"
WebApplicationContext接口中定义了三个SCOPE
- SCOPE_REQUEST = "request"
- SCOPE_SESSION = "session"
- SCOPE_APPLICATION = "application"

public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {

    //自定义PropertyEditorRegistrar属性编辑器注册器
    //用于编辑Factory下的所有bean
    private final Set<PropertyEditorRegistrar> propertyEditorRegistrars = new LinkedHashSet<>(4);
    
    //自定义PropertyEditor属性编辑器
    private final Map<Class<?>, Class<? extends PropertyEditor>> customEditors = new HashMap<>(4);

    //String值解析器
    private final List<StringValueResolver> embeddedValueResolvers = new CopyOnWriteArrayList<>();

    //Bean创建处理器
    private final List<BeanPostProcessor> beanPostProcessors = new CopyOnWriteArrayList<>();
    
    //Bean Scope范围支持
    //父接口ConfigurableBeanFactory中定义了两个SCOPE
    //SCOPE_SINGLETON = "singleton";
    //SCOPE_PROTOTYPE = "prototype";
    //WebApplicationContext接口中定义了三个SCOPE
    //SCOPE_REQUEST = "request";
    //SCOPE_SESSION = "session";
    //SCOPE_APPLICATION = "application"
    private final Map<String, Scope> scopes = new LinkedHashMap<>(8);

}

4.5 AbstractAutowireCapableBeanFactory

抽象自动配置BeanFactory, 实现了创建Bean, 实例化Bean, 字段配置Bean, 自动装配依赖Bean的方法

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
        implements AutowireCapableBeanFactory {

    //创建Bean策略,默认为cglib
    private InstantiationStrategy instantiationStrategy = new CglibSubclassingInstantiationStrategy();

    public AbstractAutowireCapableBeanFactory() {
        //显示调用父类方法
        super();
        
        //自动装配忽略BeanNameAware接口
        ignoreDependencyInterface(BeanNameAware.class);
        //自动装配忽略BeanFactoryAware接口
        ignoreDependencyInterface(BeanFactoryAware.class);
        //自动装配忽略BeanClassLoaderAware接口
        ignoreDependencyInterface(BeanClassLoaderAware.class);
    }
}

4.6 DefaultListableBeanFactory

BeanFactory默认实现, spring IOC默认容器类

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
        implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
        
    //key为依赖类型, value为自动配置的值
    private final Map<Class<?>, Object> resolvableDependencies = new ConcurrentHashMap<>(16);

    //key为bean名称, value为bean定义
    private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

    //key为依赖的类型, value为所有bean名称列表
    private final Map<Class<?>, String[]> allBeanNamesByType = new ConcurrentHashMap<>(64);

    //key为依赖类型, value为单例bean的名称数组
    private final Map<Class<?>, String[]> singletonBeanNamesByType = new ConcurrentHashMap<>(64);

    //按注册的顺序, 记录的bean名称列表
    private volatile List<String> beanDefinitionNames = new ArrayList<>(256);

    //手动添加的bean名称列表
    private volatile Set<String> manualSingletonNames = new LinkedHashSet<>(16);


    public DefaultListableBeanFactory() {
        //显示调用父类构造函数
        super();
    }
}

5. GenericWebApplicationContext

重写了AbstractApplicationContext的getResourcePatternResolver()方法, 返回一个ServletContextResourcePatternResolver对象, 构造函数中显示调用父类GenericApplicationContext的构造函数

public class GenericWebApplicationContext extends GenericApplicationContext
        implements ConfigurableWebApplicationContext, ThemeSource {
    //显式调用父GenericApplicationContext类构造方法
    //什么都不做
    public GenericWebApplicationContext() {
        super();
    }
    
    //ServletContextResourcePatternResolver
    //重写了父类获取资源的逻辑
    //从ServletContext中获取资源
    @Override
    protected ResourcePatternResolver getResourcePatternResolver() {
        return new ServletContextResourcePatternResolver(this);
    }
}

6. ServletWebServerApplicationContext

隐式调用父类GenericWebApplicationContext构造函数, 什么都没有做

public class ServletWebServerApplicationContext extends GenericWebApplicationContext
        implements ConfigurableWebServerApplicationContext {
    //什么都不做
    //隐式调用父类GenericWebApplicationContext构造方法
    public ServletWebServerApplicationContext() {
    }
}

7.AnnotationConfigServletWebServerApplicationContext

首先, 初始化一个AnnotatedBeanDefinitionReader, 然后再实例化一个ClassPathBeanDefinitionScanner对象

//注解配置ServletWeb服务应用上下文
//当前SpringApplication上下文
public class AnnotationConfigServletWebServerApplicationContext
        extends ServletWebServerApplicationContext implements AnnotationConfigRegistry {

    //注解Bean读取器,用来去取bean
    private final AnnotatedBeanDefinitionReader reader;

    //ClassPath中的Bean扫描器,用来扫描bean
    private final ClassPathBeanDefinitionScanner scanner;

    //被注册到容器中的Class对象列表
    private final Set<Class<?>> annotatedClasses = new LinkedHashSet<>();

    //需要扫描的包
    private String[] basePackages;

    //构造函数
    public AnnotationConfigServletWebServerApplicationContext() {
        //注解Bean读取器 传入this
        this.reader = new AnnotatedBeanDefinitionReader(this);
        //Classpath中的Bean扫描器
        this.scanner = new ClassPathBeanDefinitionScanner(this);
    }
}

7.1 AnnotatedBeanDefinitionReader();

用于读取和解析bean定义

//注解Bean读取器
//用来读取和解析bean
public class AnnotatedBeanDefinitionReader {

    private final BeanDefinitionRegistry registry;

    //bean名称生成器
    private BeanNameGenerator beanNameGenerator = new AnnotationBeanNameGenerator();

    //Scope解析器
    private ScopeMetadataResolver scopeMetadataResolver = new AnnotationScopeMetadataResolver();

    private ConditionEvaluator conditionEvaluator;
    
    //registry传入的AnnotationConfigServletWebServerApplicationContext对象
    public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
        this(registry, getOrCreateEnvironment(registry));
    }

    //构造函数
    //传入的registry就是AnnotationConfigServletWebServerApplicationContext实例
    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) {
            //实现了EnvironmentCapable
            //调用了AbstractApplicationContext中的getEnvironment方法
            //获取到了StandardEnvironment实例
            return ((EnvironmentCapable) registry).getEnvironment();
        }
        return new StandardEnvironment();
    }
}

AnnotationBeanNameGenerator

注解bean名称生成器, 用于生成Bean名称

//bean名称生成器
//主要为Component注解生成名称
//包括Component子注解: Component，Respository，Service，Controller
//还包括java6的ManagedBean
public class AnnotationBeanNameGenerator implements BeanNameGenerator {
    //Spring Component注解
    private static final String COMPONENT_ANNOTATION_CLASSNAME = "org.springframework.stereotype.Component";

    @Override
    public String generateBeanName(BeanDefinition definition, BeanDefinitionRegistry registry) {
        //如果是注解的bean定义
        if (definition instanceof AnnotatedBeanDefinition) {
            //先从注解获取bean名称
            String beanName = determineBeanNameFromAnnotation((AnnotatedBeanDefinition) definition);
            //不为空直接返回
            if (StringUtils.hasText(beanName)) {
                return beanName;
            }
        }
        //注解没有定义bean名称,那么构造一个bean名称
        return buildDefaultBeanName(definition, registry);
    }


    /**
     * 构造bean名称
     */
    protected String buildDefaultBeanName(BeanDefinition definition) {
        String beanClassName = definition.getBeanClassName();
        Assert.state(beanClassName != null, "No bean class name set");
        //获取Class名称
        String shortClassName = ClassUtils.getShortName(beanClassName);
        //将类名作为bean名称
        return Introspector.decapitalize(shortClassName);
    }
}

public class Introspector {
    public static String decapitalize(String name) {
        if (name == null || name.length() == 0) {
            return name;
        }
        if (name.length() > 1 && Character.isUpperCase(name.charAt(1)) &&
                        Character.isUpperCase(name.charAt(0))){
            //如果第一个和第二个字符都是大写,直接返回名称
            return name;
        }
        //将第一个字符转换为小写,返回类名
        char chars[] = name.toCharArray();
        chars[0] = Character.toLowerCase(chars[0]);
        return new String(chars);
    }
}

AnnotationScopeMetadataResolver

Scope注解的解析器, 解析出Scope的模式ScopedProxyMode, 以及Scope的名称

//@Scope注解的解析器
public class AnnotationScopeMetadataResolver implements ScopeMetadataResolver {
    
    //Scope注解
    protected Class<? extends Annotation> scopeAnnotationType = Scope.class;
      
    //代理模式
    private final ScopedProxyMode defaultProxyMode;
    
    //默认不使用代理
    public AnnotationScopeMetadataResolver() {
        this.defaultProxyMode = ScopedProxyMode.NO;
    }
    
    //解析@Scope注解
    public ScopeMetadata resolveScopeMetadata(BeanDefinition definition) {
        ScopeMetadata metadata = new ScopeMetadata();
        if (definition instanceof AnnotatedBeanDefinition) {
            //注解bean
            AnnotatedBeanDefinition annDef = (AnnotatedBeanDefinition)definition;
            
            //获取到metadata放入名为attributes的map中
            AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(annDef.getMetadata(), this.scopeAnnotationType);
            if (attributes != null) {
                //将@Scope注解的value和proxyMode放入到metadata中
                metadata.setScopeName(attributes.getString("value"));
                ScopedProxyMode proxyMode = (ScopedProxyMode)attributes.getEnum("proxyMode");
                if (proxyMode == ScopedProxyMode.DEFAULT) {
                    proxyMode = this.defaultProxyMode;
                }
                metadata.setScopedProxyMode(proxyMode);
            }
        }
        return metadata;
    }
}

//代理模式枚举
public enum ScopedProxyMode {

    //默认代理模式,默认使NO,
    //如果在component-scan中配置了默认值,将会使用这个默认值
    DEFAULT,

    //不使用代理
    NO,

    //接口,使用jdk动态代理
    INTERFACES,

    //类,使用cglib动态代理
    TARGET_CLASS;
}

ConditionEvaluator

@Conditional注解的条件评估器, 评估是否满足条件

//@Conditional注解的解析器
//也可用于@ConditionalOnBean,@ConditionalOnClass,@ConditionalOnExpression,@ConditionalOnMissingBean等子注解
class ConditionEvaluator {

    //内部类
    private final ConditionContextImpl context;
    //构造函数
    public ConditionEvaluator(@Nullable BeanDefinitionRegistry registry,
            @Nullable Environment environment, @Nullable ResourceLoader resourceLoader) {
        this.context = new ConditionContextImpl(registry, environment, resourceLoader);
    }
    
    //判断是否应该跳过
    public boolean shouldSkip(@Nullable AnnotatedTypeMetadata metadata, @Nullable ConfigurationPhase phase) {
        if (metadata == null || !metadata.isAnnotated(Conditional.class.getName())) {
            //metadata为空或者没有使用@Conditional注解,不跳过
            return false;
        }

        if (phase == null) {
            //ConfigurationPhase对象为空,也就是没有设置生效条件
            if (metadata instanceof AnnotationMetadata &&
                    ConfigurationClassUtils.isConfigurationCandidate((AnnotationMetadata) metadata)) {
                //如果是注解的话,使用PARSE_CONFIGURATION配置验证是否跳过
                return shouldSkip(metadata, ConfigurationPhase.PARSE_CONFIGURATION);
            }
            //不是注解的话,使用REGISTER_BEAN配置验证是否跳过
            return shouldSkip(metadata, ConfigurationPhase.REGISTER_BEAN);
        }

        List<Condition> conditions = new ArrayList<>();
        //遍历配置类的条件注解,得到条件数据,放到conditions集合中
        for (String[] conditionClasses : getConditionClasses(metadata)) {
            for (String conditionClass : conditionClasses) {
                Condition condition = getCondition(conditionClass, this.context.getClassLoader());
                conditions.add(condition);
            }
        }

        //按Order注解排序
        AnnotationAwareOrderComparator.sort(conditions);
        //条件排序
        for (Condition condition : conditions) {
            ConfigurationPhase requiredPhase = null;
            if (condition instanceof ConfigurationCondition) {
                requiredPhase = ((ConfigurationCondition) condition).getConfigurationPhase();
            }
            //添加验证满足,那就跳过
            if ((requiredPhase == null || requiredPhase == phase) && !condition.matches(this.context, metadata)) {
                return true;
            }
        }

        return false;
    }
    
    //私有静态内部类
    private static class ConditionContextImpl implements ConditionContext {
    
        public ConditionContextImpl(@Nullable BeanDefinitionRegistry registry,
                @Nullable Environment environment, @Nullable ResourceLoader resourceLoader) {
            //传入的是AnnotationConfigServletWebServerApplicationContext对象
            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);
        }

        //推断获取beanFactory
        @Nullable
        private ConfigurableListableBeanFactory deduceBeanFactory(@Nullable BeanDefinitionRegistry source) {
            if (source instanceof ConfigurableListableBeanFactory) {
                return (ConfigurableListableBeanFactory) source;
            }
            if (source instanceof ConfigurableApplicationContext) {
                //AnnotationConfigServletWebServerApplicationContext实现了ConfigurableApplicationContext
                //调用了GenericApplicationContext中的getBeanFactory方法
                //获取到一个DefaultListableBeanFactory对象
                return (((ConfigurableApplicationContext) source).getBeanFactory());
            }
            return null;
        }

        //获取环境
        private Environment deduceEnvironment(@Nullable BeanDefinitionRegistry source) {
            if (source instanceof EnvironmentCapable) {
                //AnnotationConfigServletWebServerApplicationContex实现了EnvironmentCapable
                //调用了AbstractApplicationContext中的getEnvironment方法
                //获取到了StandardEnvironment实例
                return ((EnvironmentCapable) source).getEnvironment();
            }
            return new StandardEnvironment();
        }

        //获取ResourceLoader
        private ResourceLoader deduceResourceLoader(@Nullable BeanDefinitionRegistry source) {
            if (source instanceof ResourceLoader) {
                //AnnotationConfigServletWebServerApplicationContex实现了ResourceLoader
                //所以直接强转
                return (ResourceLoader) source;
            }
            return new DefaultResourceLoader();
        }

        //获取ClassLoader
        @Nullable
        private ClassLoader deduceClassLoader(@Nullable ResourceLoader resourceLoader,
                @Nullable ConfigurableListableBeanFactory beanFactory) {
            //传入ResourceLoader为null
            if (resourceLoader != null) {
                ClassLoader classLoader = resourceLoader.getClassLoader();
                if (classLoader != null) {
                    return classLoader;
                }
            }
            if (beanFactory != null) {
                //获取到beanFactory不为null
                //使用beanFactory中的classloader
                return beanFactory.getBeanClassLoader();
            }
            return ClassUtils.getDefaultClassLoader();
        }

}

AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry)

注册bean处理器, bean名称需要加上org.springframework.context.annotation前缀:

beanFactory设置AnnotationAwareOrderComparator
- 处理Ordered类、@Order注解和@Priority
- 处理完成之后排序
beanFactory设置ContextAnnotationAutowireCandidateResolver
- 处理@Lazy注解
- 配置延迟加载
注册ConfigurationClassPostProcessor类型的bean
- 处理@Configuration注解
- 非常重要的一个类
- bean名称为internalConfigurationAnnotationProcessor
注册AutowiredAnnotationBeanPostProcessor类型的bean
- 处理@Autowired, @Value注解
- bean名称为internalAutowiredAnnotationProcessor
注册CommonAnnotationBeanPostProcessor类型的bean
- 处理@PostConstruct,@PreDestroy注解
- bean名称为internalCommonAnnotationProcessor
注册EventListenerMethodProcessor类型的bean
- 处理@EventListener注解
- bean名称为internalEventListenerProcessor
注册DefaultEventListenerFactory类型的bean
- 默认的监听器工厂
- 处理@EventListener注解
- bean名称为internalEventListenerFactory

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

    //获取到父类GenericApplicationContext的beanFactory
    DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
    if (beanFactory != null) {
        //添加注解排序器
        if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
            //AnnotationAwareOrderComparator处理Ordered类、@Order注解和@Priority
            beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
        }
        //处理@Lazy注解
        if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
            beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
        }
    }

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

    if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        //注册ConfigurationClassPostProcessor类型的bean 
        //处理@Configuration注解
        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)) {
        //注册类型AutowiredAnnotationBeanPostProcessor的bean
        //处理@Autowired,@Value注解
        RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
    }

    if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        //注册类型CommonAnnotationBeanPostProcessor的bean
        //处理@PostConstruct和@PreDestroy注解
        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)) {
        //注册一个名称为PersistenceAnnotationBeanPostProcessor,类型为PersistenceAnnotationBeanPostProcessor的bean
        //处理@PersistenceUnit,@PersistenceContext注解
        RootBeanDefinition def = new RootBeanDefinition();
        try {
            //我们没有用到PersistenceAnnotationBeanPostProcessor
            //所以不会添加
            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)) {
        //注册类型为EventListenerMethodProcessor的bean
        //处理@EventListener注解
        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)) {
        //注册类型为DefaultEventListenerFactory的bean
        //EventListenerFactory的默认实现,支持EventListener注解
        RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
    }

    return beanDefs;
}

7.2 ClassPathBeanDefinitionScanner

如果basePackages不为空的话, 扫描basePackages中定义的bean, 当前应用中没有配置basePackages, 所以ClassPathBeanDefinitionScanner不会去扫描bean

//ClassPath中Bean扫描器
public class ClassPathBeanDefinitionScanner extends ClassPathScanningCandidateComponentProvider {
    
    private final BeanDefinitionRegistry registry;

    private BeanDefinitionDefaults beanDefinitionDefaults = new BeanDefinitionDefaults();

    @Nullable
    private String[] autowireCandidatePatterns;

    private BeanNameGenerator beanNameGenerator = new AnnotationBeanNameGenerator();

    private ScopeMetadataResolver scopeMetadataResolver = new AnnotationScopeMetadataResolver();

    private boolean includeAnnotationConfig = true;

    // registry是AnnotationConfigServletWebServerApplicationContext的实例
    //useDefaultFilters默认为true
    public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
            Environment environment, @Nullable ResourceLoader resourceLoader) {

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

        if (useDefaultFilters) {
            //添加@Component,@ManagedBean,@Named注解扫描
            registerDefaultFilters();
        }
        
        //getOrCreateEnvironment(registry)
        //得到一个StandardEnvironment
        setEnvironment(environment);
        
        // (registry instanceof ResourceLoader ? (ResourceLoader) registry : null
        //registry实现了ResourceLoader,registry强转为ResourceLoader
        setResourceLoader(resourceLoader);
    }
    
    @SuppressWarnings("unchecked")
    protected void registerDefaultFilters() {
        //添加一个Component注解扫描
        //Compent注解包括子注解:Repository,Service,Controller
        this.includeFilters.add(new AnnotationTypeFilter(Component.class));
        ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();
        try {
            //添加ManagedBean注解
            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) {
        }
        try {
            //添加Named注解
            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) {
        }
    }
    
    //扫描basePackages下使用注解的类
    public int scan(String... basePackages) {
        //DefaultListableBeanFactory#getBeanDefinitionCount()
        //获取beanDefinitionMap元素的数量
        //beanDefinitionMap = new ConcurrentHashMap<>(256);
        int beanCountAtScanStart = this.registry.getBeanDefinitionCount();
    
        //扫描方法
        doScan(basePackages);

        //默认为true
        if (this.includeAnnotationConfig) {
            //该方法实例化reader的时候已经执行过一次了
            AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
        }
        
        //返回实际扫描的数量
        return (this.registry.getBeanDefinitionCount() - beanCountAtScanStart);
    }
    
    //扫描方法
    protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
        Assert.notEmpty(basePackages, "At least one base package must be specified");
        Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
        for (String basePackage : basePackages) {
            //扫描到Compent注解的bean列表
            Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
            for (BeanDefinition candidate : candidates) {
                //获取Scope注解的值
                ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
                candidate.setScope(scopeMetadata.getScopeName());
                //生成bean名称
                String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
                if (candidate instanceof AbstractBeanDefinition) {
                    //bean默认配置
                    postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
                }
                if (candidate instanceof AnnotatedBeanDefinition) {
                    //配置bean
                    AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
                }
                if (checkCandidate(beanName, candidate)) {
                    BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
                    definitionHolder =
                            AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
                    beanDefinitions.add(definitionHolder);
                    //注册bean
                    registerBeanDefinition(definitionHolder, this.registry);
                }
            }
        }
        return beanDefinitions;
    }
}

8. 总结

实例化AnnotationConfigServletWebServerApplicationContext过程中, 会先调用父类GenericApplicationContext构造函数, 实例化了一个DefaultListableBeanFactory, 作为Spring IOC容器, AnnotationConfigServletWebServerApplicationContext的构造函数实例化了AnnotatedBeanDefinitionReader对象, 用于读取Spring的bean定义, 在实例化AnnotatedBeanDefinitionReader的过程中, 注册了几个bean, 用来处理相应的注解

链接：https://www.jianshu.com/p/17c8b15dd595