AnnotationConfigApplicationConte
测试代码：
//spring 配置类
@ComponentScan(value = {"com.y.user","com.y.product"})
public class SpringConfig {
}
package com.y.user;
public interface UserService {
String getUser();
}
@Service
public class UserServiceImpl implements UserService {
@Override
public String getUser() {
return "YOUNG";
}
}
package com.y.product;
public interface ProductService {
boolean order();
}
@Service
public class ProductServiceImpl implements ProductService {
@Autowired
private UserService userService;
@Override
public boolean order() {
String user = userService.getUser();
System.out.println(user + " complete order...");
return true;
}
}
@Test
public void testAnno() {
AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext();
annotationConfigApplicationContext.register(SpringConfig.class);
annotationConfigApplicationContext.refresh();
UserService userService = (UserService) annotationConfigApplicationContext.getBean("userServiceImpl");
System.out.println(userService.getUser());
}
容器初始化
AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext();
AnnotationConfigApplicationContext继承GenericApplicationContext，在初始化时候会先调用GenericApplicationContext的无参构造函数，实例化出一个DefaultListableBeanFactory，为后续的BeanDefinition注册做准备。
public GenericApplicationContext() {
this.beanFactory = new DefaultListableBeanFactory();
}
AnnotationConfigApplicationContext 的构造函数会初始化reader和scanner
public AnnotationConfigApplicationContext() {
this.reader = new AnnotatedBeanDefinitionReader(this);
this.scanner = new ClassPathBeanDefinitionScanner(this);
}
reader的初始化
reader的初始化过程中通过AnnotationConfigUtils注册几个注解处理器的Bean定义：
ConfigurationClassPostProcessor 是一个BeanFactoryPostProcessor处理器，容器启动时候对@Configuration注解的处理
AutowiredAnnotationBeanPostProcessor 是一个BeanPostProcessor处理器，对@Autowired注解处理
CommonAnnotationBeanPostProcessor 是一个BeanPostProcessor处理器，对@PostConstruct （初始化）和 @PreDestroy（移除）处理
DefaultEventListenerFactory 对@EventListener 处理
详细源码见：AnnotationConfigUtils#registerAnnotationConfigProcessors(this.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);
}
scanner的初始化
scanner初始化过程
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);
}
//过滤注解集合中增加 @Component注解，Component，Repository，Controller，Service都会被扫描到
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.
}
}
注册SpringConfig过程：annotationConfigApplicationContext.register(SpringConfig.class);
通过AnnotatedBeanDefinitionReader注册到DefaultListableBeanFactory的beanDefinitionMap中
@Override
public void register(Class<?>... componentClasses) {
Assert.notEmpty(componentClasses, "At least one component class must be specified");
this.reader.register(componentClasses);
}
<T> void doRegisterBean(Class<T> beanClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,
@Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {
AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);
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);
}
刷新容器annotationConfigApplicationContext.refresh()
调用refresh刷新容器，开始bean的实例化和依赖注入，会调用父类AbstractApplicationContext的refresh方法，
org.springframework.context.support.AbstractApplicationContext#refresh
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.
/**
* 获得BeanFactory(首先得有这个才能创建Bean)，默认DefaultListableBeanFactory
* 同时先加载xml配置文件，加载BeanDefinition，并注册到BeanDefinitionRegistry（将id作为key，BeanDefinition作为value放入的map中）
*/
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
/**
* BeanFactory的预备工作，BeanFactory进行一些设置，比如context类加载器等。
*/
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory in context subclasses.
/**
* 获取BeanFactoryPostProcessor
*/
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.
/**
* 调用BeanFactoryPostProcessor#postProcessBeanFactory
*/
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
/**
* 准备BeanPostProcessor，但是此时Bean还没有被创建，无法使用，后续使用
*/
registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
/**
* 国际化
*/
initMessageSource();
// Initialize event multicaster for this context.
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
/**
* 子类重新这个方法，比如容器刷新的时候可以自定义逻辑：如创建Tomcat，jetty等web服务器
*/
onRefresh();
// Check for listener beans and register them.
/**
* 注册监听器
*/
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
/**
* 初始化所有剩下的非懒加载的单例Bean
* 初始化创建非懒加载方式的单例Bean实例（未设置属性）
* 填充属性
* 初始化方法调用（比如调用afterPropertiesSet方法，init-method方法）
* 调用beanPostProcessor后置处理器对实例bean进行后置处理
*/
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
/**
* 完成context的属性，主要调用了LiftCycleProcessor的onRefresh（）方法，并且发布事件
*/
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();
}
}
}
invokeBeanFactoryPostProcessors(beanFactory); 调用会触发org.springframework.context.annotation.ConfigurationClassPostProcessor#postProcessBeanDefinitionRegistry的调用，最终会通过ComponentScanAnnotationParser对@ComponentScan注解处理
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
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);
processConfigBeanDefinitions(registry);
}
最终通过org.springframework.context.annotation.ComponentScanAnnotationParser#parse对@ComponentScan中定义的包进行扫描，加入到BeanDefinition定义中去。
经过上述处理后，DefaultListableBeanFactory的beanDefinitionMap中存在的定义有：
springConfig
org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.event.internalEventListenerFactory
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
userServiceImpl
productServiceImpl
Bean的创建过程
refresh方法中的finishBeanFactoryInitialization()调用，触发bean的创建，通过DefaultListableBeanFactory的beanFactory.preInstantiateSingletons()方法创建Bean。
创建调用流程：
SequenceDiagram1.png
productServiceImpl中的Autowired注解在bean创建过程中的populateBean时被AutowiredAnnotationBeanPostProcessor这个后置处理器拦截处理，
org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor#postProcessProperties
org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.AutowiredFieldElement#inject
最终通过反射设置属性值
autowired.PNG
那么populateBean调用的时候，ProductServiceImpl中依赖的userService在哪里解析出来的呢？
doCreateBean的过程中有一个调用applyMergedBeanDefinitionPostProcessors，AutowiredAnnotationBeanPostProcessor会进行属性解析
protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof MergedBeanDefinitionPostProcessor) {
MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
}
}
}
使用AutowiredAnnotationBeanPostProcessor#postProcessMergedBeanDefinition 找出需要注入的属性
@Override
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
InjectionMetadata metadata = findAutowiringMetadata(beanName, beanType, null);
metadata.checkConfigMembers(beanDefinition);
}
调用栈以及解析到的field属性
autowired.PNG
