由于本人水平有限，本文内容较为简单，仅供个人学习笔记，或者大家参考，如果能够帮助大家，荣幸之至！本文主要分析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当中的其他后置处理器，会在后续文章中更新！
