Spring boot源码分析-AnnotationConfigApplicationContext非web环境下的启动容器（2）

Spring boot源码分析-AnnotationConfigApplicationContext非web环境下的启动容器（2）

首先我们看容器的类图



1.首先该类间接继承了AbstractApplicationContext（Spring容器最重要的抽象类，就有了容器最终要的一些功能）

2.该类还实现了AnnotationConfigRegistry 注解扫描注册接口 就是基于注解的容器 实现了读取spring注解加载容器的功能

容器启动，构造方法

首先我们看类的构造方法，主要做了以下几个工作

AnnotatedBeanDefinitionReader BeanDefinition解析器用来解析带注解的bean

ClassPathBeanDefinitionScanner bean的扫描器 用来扫描类

注册解析传入的配置类（使用类配置的方式进行解析）

调用容器的refresh方法初始化容器

public class AnnotationConfigApplicationContext extends GenericApplicationContext implements AnnotationConfigRegistry {
private final AnnotatedBeanDefinitionReader reader;
private final ClassPathBeanDefinitionScanner scanner;

public AnnotationConfigApplicationContext() {
//关键代码  里面有注解的BeanDefinitionreader
this.reader = new AnnotatedBeanDefinitionReader(this);
//bean扫描器
this.scanner = new ClassPathBeanDefinitionScanner(this);
logger.info(this.getBeanFactory());
}

public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
this();
//关键代码   注册配置的类对象   （当配置类上有@Conditional注解且为matches方法返回false的时候  好像
4000
这个类就不注册了）
register(annotatedClasses);
refresh();
}
}

在看他的父类的构造器 创建了DefaultListableBeanFactory bean工厂

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

我们现在对于容器的类型和大致的执行过程有了一个了解 知道容器启动的时候做了哪几个大的工作

AnnotatedBeanDefinitionReader Bean解析器的分析

先看构造的源码

this.reader = new AnnotatedBeanDefinitionReader(this);

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;
//Conditional注解评估器
this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
//这个时关键   注册AnnotationConfigProcessor
AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}

注解的条件判断器ConditionEvaluator 该方法在初始化的时调用，当配置的类上有@Conditional注解并且返回false的时候 容器就不处理该类

AnnotationConfigApplicationContext

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

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

AnnotatedBeanDefinitionReader

public void register(Class<?>... annotatedClasses) {
for (Class<?> annotatedClass : annotatedClasses) {
registerBean(annotatedClass);
}
}

public void registerBean(Class<?> annotatedClass, String name, Class<? extends Annotation>... qualifiers) {
AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
//解析beanClass的@Conditional注解，如果有注解返回false 容器就停止处理
if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
return;
}
······
}

再看代码 这是整个容器的关键，调用了registerAnnotationConfigProcessors方法 该方法的作用

注册和解析spring注解相关的post processors

该方法被调用有两个地方

1.在spring使用AnnotationConfigBeanDefinitionParser解析xml文件的时候 也就是配置annotation-config的时候

2.启动在AnnotationConfigApplicationContext容器的时候

AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);

AnnotationConfigUtils

public static final String AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME =
"org.springframework.context.annotation.internalAutowiredAnnotationProcessor";

public static void registerAnnotationConfigProcessors(BeanDefinitionRegistry registry) {
registerAnnotationConfigProcessors(registry, null);
}

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

······
//注册ConfigurationClassPostProcessor
if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
//1.在spring使用AnnotationConfigBeanDefinitionParser解析xml文件的时候  也就是配置annotation-config的时候
//2.启动在AnnotationConfigApplicationContext容器的时候
RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
}

//自动注入 注册AutowiredAnnotationBeanPostProcessor
if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
def.setSource(source);
//org.springframework.context.annotation.internalAutowiredAnnotationProcessor
beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
}
······

return beanDefs;
}

我们再看beanfactory注册了ConfigurationClassPostProcessor类，我们看看这个类的类图以及作用

我们可以看到ConfigurationClassPostProcessor实现了BeanDefinitionRegistryPostProcessor接口,该接口在

AbstractApplicationContext的refresh()方法中会被nvokeBeanFactoryPostProcessors(beanFactory)方法调用,就是在容器激活的时候被调用



在看看ConfigurationClassPostProcessor的postProcessBeanDefinitionRegistry方法,由代码可以知道 这个类解析了spring使用@Configuration配置方式的bean

@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
RootBeanDefinition iabpp = new RootBeanDefinition(ImportAwareBeanPostProcessor.class);
iabpp.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
registry.registerBeanDefinition(IMPORT_AWARE_PROCESSOR_BEAN_NAME, iabpp);
//注册了ConfigurationBeanPostProcessor
RootBeanDefinition ecbpp = new RootBeanDefinition(EnhancedConfigurationBeanPostProcessor.class);
ecbpp.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
registry.registerBeanDefinition(ENHANCED_CONFIGURATION_PROCESSOR_BEAN_NAME, ecbpp);

int registryId = System.identityHashCode(registry);
if (this.registriesPostProcessed.contains(registryId)) {
throw new IllegalStateException(
"postProcessBeanDefinitionRegistry already called on this post-processor against " + registry);
}
if (this.factoriesPostProcessed.contains(registryId)) {
throw new IllegalStateException(
"postProcessBeanFactory already called on this post-processor against " + registry);
}
this.registriesPostProcessed.add(registryId);
//处理@Configuration的bean
processConfigBeanDefinitions(registry);
}

在看看@SpringBootApplication的组合注解 就知道bean是怎么被加载的了

ClassPathBeanDefinitionScanner Bean解析器的分析

ClassPathBeanDefinitionScanner提供了包扫描路径的方式启动容器，中间的解析方式和使用类文件的配置是一样的

ApplicationContext context=new AnnotationConfigApplicationContext("com.mitix.spring.context.expb");

protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
Assert.notEmpty(basePackages, "At least one base package must be specified");
Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<BeanDefinitionHolder>();
for (String basePackage : basePackages) {
//寻找候选的BeanDefinition
//注：注解在匹配的时候会递归的   会找这个注解的父注解
Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
for (BeanDefinition candidate : candidates) {
//scope注解设置beandefinition的scope属性
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
candidate.setScope(scopeMetadata.getScopeName());
String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
//如果满足AbstractBeanDefinition类型，就设置名字，就是上面获取到的那个
if (candidate instanceof AbstractBeanDefinition) {
/*
* 1.设置了beandefinition的默认需要的那些属性
*
*/
postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
}
//如果是实现注解的beandefinition,然后把一堆注解解析成属性放进去，什么依赖啊什么的
if (candidate instanceof AnnotatedBeanDefinition) {
AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
}
//检查注册的候选bean
if (checkCandidate(beanName, candidate)) {
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
//这里可能创建起来的是一个代理
definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
beanDefinitions.add(definitionHolder);
//把代理注册到registory上，就是注册到工厂里
registerBeanDefinition(definitionHolder, this.registry);
}
}
}
return beanDefinitions;
}

总结

AnnotationConfigApplicationContext类提供了另外一种启动spring容器的方式，而不是使用传统的xml文件进行配置

具体详细的启动过程，可以查看spring的源码相关的问题