上篇文章是从宏观的角度分析spring IOC的加载过程，通过上篇文章，我们对spring IOC的加载过程有了个整体的认识。本节主要从源码的层面去分析我们的springIOC加载过程。
springIOC加载过程
1.实例化容器AnnotationConfigApplicationContext：
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainTest.class);
AnnotationConfigApplicationContext的结构关系图：
public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
//调用构造函数
this();
//注册我们的配置类
register(annotatedClasses);
//IOC容器刷新接口
refresh();
}
说明：
①从AnnotationConfigApplicationContext(Class<?>… annotatedClasses)可以看出，这个有参构造方法是可以传入多个配置类的。
②配置类分两种：
一种是Full配置类，即带有@configuration；
另一种是Lite配置类，即不带@configuration，但是带有@Component，@Import，@ImportResouce，@Service。
通过this调用无参构造函数AnnotationConfigApplicationContext()：
public AnnotationConfigApplicationContext() {
/**
* 初始化注解模式下的bean定义读取器
* 调用AnnotatedBeanDefinitionReader构造方法，传入的是this(AnnotationConfigApplicationContext)对象
*/
this.reader = new AnnotatedBeanDefinitionReader(this);
/**
* 初始化我们的classPath类型的bean定义扫描器
*/
this.scanner = new ClassPathBeanDefinitionScanner(this);
}
说明：
①实例化读取器reader，这是一个标记了注解的bean定义读取器。
②扫描器scanner，它仅仅是在外面手动调用.scan方法，或者调用参数为String的构造方法，传入需要扫描的包名才会用到，我们这里传入的配置类并不是由它进行扫描的，用法如下：
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
context.scan("com.cshg");
调用无参构造函数AnnotationConfigApplicationContext()之前会调用它的父类的无参构造函数GenericApplicationContext() ，在这个函数中实例化工厂：DefaultListableBeanFactory。
2.实例化工厂：DefaultListableBeanFactory
public GenericApplicationContext() {
this.beanFactory = new DefaultListableBeanFactory();
}
说明：因为GenericApplicationContext是AnnotationConfigApplicationContext的父类，故在调用子类的无参构造函数时，会先调用父类的无参构造函数。
下面是DefaultListableBeanFactory的关系图
public AnnotationConfigApplicationContext() {
/**
* 初始化注解模式下的bean定义读取器
* 调用AnnotatedBeanDefinitionReader构造方法，传入的是this(AnnotationConfigApplicationContext)对象
*/
this.reader = new AnnotatedBeanDefinitionReader(this);
/**
* 初始化我们的classPath类型的bean定义扫描器
*/
this.scanner = new ClassPathBeanDefinitionScanner(this);
}
进入AnnotatedBeanDefinitionReader的构造方法：
public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
this(registry, getOrCreateEnvironment(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");
//把ApplicationContext对象赋值给AnnotatedBeanDefinitionReader
this.registry = registry;
//用户处理条件表达式计算 @Conditionl主机呃呃
this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
//注册一些配置的后置处理器
AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}
进入registerAnnotationConfigProcessors(this.registry)方法：
public static void registerAnnotationConfigProcessors(BeanDefinitionRegistry registry) {
registerAnnotationConfigProcessors(registry, null);
}
这又是一个门面方法，进入registerAnnotationConfigProcessors(registry, null)方法：
public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
BeanDefinitionRegistry registry, @Nullable Object source) {
DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
......
Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
/**
* 为我们容器中注册了解析我们配置类的后置处理器ConfigurationClassPostProcessor
* 名字叫:org.springframework.context.annotation.internalConfigurationAnnotationProcessor
*/
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));
}
/**
* 为我们容器中注册了处理@Autowired 注解的处理器AutowiredAnnotationBeanPostProcessor
* 名字叫:org.springframework.context.annotation.internalAutowiredAnnotationProcessor
*/
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));
}
/**
* 为我们容器中注册处理@Required属性的注解处理器RequiredAnnotationBeanPostProcessor
* 名字叫:org.springframework.context.annotation.internalRequiredAnnotationProcessor
*/
if (!registry.containsBeanDefinition(REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(RequiredAnnotationBeanPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
}
/**
* 为我们容器注册处理JSR规范的注解处理器CommonAnnotationBeanPostProcessor
* org.springframework.context.annotation.internalCommonAnnotationProcessor
*/
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));
}
/**
* 处理jpa注解的处理器org.springframework.orm.jpa.support.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));
}
/**
* 处理监听方法的注解解析器EventListenerMethodProcessor
*/
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;
}
说明：
这个方法主要注册了很多后置处理器beanPostProcessor，因此部分代码我用…省略了。
下面说明下这些后置处理器：
①ConfigurationClassPostProcessor：解析我们配置类的后置处理器；
②AutowiredAnnotationBeanPostProcessor：处理@Autowired注解的后置处理器；
③RequiredAnnotationBeanPostProcessor：处理@Required注解的后置处理器；
④CommonAnnotationBeanPostProcessor：处理JSR规范的注解处理器；
⑤PersistenceAnnotationBeanPostProcessor：处理jpa注解的处理器；
⑥EventListenerMethodProcessor：处理监听方法的注解解析器；
进入new RootBeanDefinition(ConfigurationClassPostProcessor.class)里面看看：
/**
* 用于保存bean组件的class对象
*/
@Nullable
private volatile Object beanClass;
public RootBeanDefinition(@Nullable Class<?> beanClass) {
super();
setBeanClass(beanClass);
}
public void setBeanClass(@Nullable Class<?> beanClass) {
this.beanClass = beanClass;
}
出来，进入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);
}
这个方法注册了beanDefinition。
说到这我得提一下BeanDefinition,即bean定义，先看它的子类RootBeanDefinition关系图
@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 BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
"Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
"': There is already [" + existingDefinition + "] bound.");
}else if (existingDefinition.getRole() < beanDefinition.getRole()) {
// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
if (logger.isWarnEnabled()) {
logger.warn("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.isInfoEnabled()) {
logger.info("Overriding bean definition for bean '" + beanName +
"' with a different definition: replacing [" + existingDefinition +
"] with [" + beanDefinition + "]");
}
}else {
if (logger.isDebugEnabled()) {
logger.debug("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);
}
}
这个方法很长，我先把注意力放到这两行代码：
this.beanDefinitionMap.put(beanName, beanDefinition);
this.beanDefinitionNames.add(beanName);
说明：
beanDefinitionMap是一个hashMap，beanName作为Key,beanDefinition作为Value。
beanDefinitionNames是一个集合，里面存放了beanName。
此处注册了许多bean，其中有一个很重要的bean就是ConfigurationClassPostProcessor，这个bean的继承关系如下：
因篇幅问题不能全部显示，请点此查看更多更全内容