目录
- 1.基础
- 2.IOC基于xml的配置
- 3.IOC基于注解的配置
- 4.AOP的相关概念
- 6.spring进阶
- 7.消息监听机制
- 8.事物控制与传播行为
- 9.Spring源码
- 10.spring的生命周期
待编辑
ClassPathXmlApplicationContext
//配置容器的核心方法
- refresh
refresh
//准备工作，记录容器的启动时间，设置一启动标志状态，处理配置文件中的占位符
1prepareRefresh()
1.2this.startupDate = System.currentTimeMillis();
1.3this.closed.set(false);
1.4this.active.set(true);
//将配置文件解析成为一个个beanDefinition。将这些信息注册到beanfactory中，bean并没有初始化，只是进行了注册
2.obtainFreshBeanFactory();
//关闭旧的BeanFactory，创建新的BeanFactory,加载beanDefination，注册bean
2.1refreshBeanFactory()
//初始化一个 DefaultListableBeanFactory
2.1.1 createBeanFactory();
// 设置 BeanFactory 的两个配置属性：是否允许 Bean 覆盖、是否允许循环引用
2.1.2customizeBeanFactory(beanFactory);
// 加载 Bean 到 BeanFactory 中
2.1.3 loadBeanDefinitions(beanFactory)
// 给这个 BeanFactory 实例化一个 XmlBeanDefinitionReader
2.1.3.1XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
//加载bean，使用初始化的reader来加载xml配置
2.1.3.2 loadBeanDefinitions(beanDefinitionReader);
// 核心部分，加载bean
2.1.3.2.1return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
//返回当前的beanfactory加载了多少数量的bean
2.1.3.2.1.1registerBeanDefinition
//将xml配置文件转化成为一颗配置树
2.1.3.2.1.1.1Element root = doc.getDocumentElement();
//根据配置树就加载beandefination,完成profile环境的配置
2.1.3.2.1.1.2doRegisterBeanDefinitions(root);
//对标签进行解析，不同的标签，会调用不同的spacehandler来进行处理
2.1.3.2.1.1.2.1 parseBeanDefinitions(root, this.delegate);
//解析的节点是 <import />、<alias />、<bean />、<beans />
2.1.3.2.1.1.2.1.1parseDefaultElement(ele, delegate)
//处理<bean>标签
2.1.3.2.1.1.2.1.1.1processBeanDefinition(ele, delegate);
// 将 <bean /> 节点中的信息提取出来，然后封装到一个 BeanDefinitionHolder 中，将xml中的bean标签转化为beandefinition
2.1.3.2.1.1.2.1.1.1.1BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
//注册Bean，将bean的名字和别名作为key，beandefinition为value，存储在map中
2.1.3.2.1.1.2.1.1.1.1BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry())
//解析 <mvc />、<task />、<context />、<aop />等
2.1.3.2.1.1.2.1.1delegate.parseCustomElement(element)
//准备 Bean 容器,并添加一些beanPostProcessor,并且注册监听器等
3.prepareBeanFactory(factory)
//设置 BeanFactory 的类加载器，即为当前 ApplicationContext 的类加载器
3.1setBeanClassLoader(getClassLoader)
//添加一个 BeanPostProcessor，这个 processor 比较简单
// 实现了 Aware 接口的几个特殊的 beans 在初始化的时候，这个 processor 负责回调
3.2 beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
//自动装配时，对一些实现了特殊接口的bean忽略
3.3 ignoreDependencyInterface
//对一些实现了特殊接口的bean注入相应的值
3.4 registerResolvableDependency
// 这个 BeanPostProcessor 也很简单，在 bean 实例化后，如果是 ApplicationListener 的子类，
// 那么将其添加到 listener 列表中，可以理解成：注册事件监听器
3.5beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
//手动注册几个特殊的bean
// 这里是提供给子类的扩展点，到这里的时候，所有的 Bean 都加载、注册完成了，但是都还没有初始化
// 会执行实现了BeanFactoryPostProcessor 接口类中的方法
4.postProcessBeanFactory(beanFactory);
// 调用 BeanFactoryPostProcessor 各个实现类的 postProcessBeanFactory(factory) 方法
5.invokeBeanFactoryPostProcessors(beanFactory);
// 注册 BeanPostProcessor 的实现类，注意看和 BeanFactoryPostProcessor 的区别
// 此接口两个方法: postProcessBeforeInitialization 和 postProcessAfterInitialization
// 两个方法分别在 Bean 初始化之前和初始化之后得到执行。注意，到这里 Bean 还没初始化
6.registerBeanPostProcessors(beanFactory);
// 初始化当前 ApplicationContext 的 MessageSource，国际化这里就不展开说了，不然没完没了了
7.initMessageSource();
// 初始化当前 ApplicationContext 的事件广播器，这里也不展开了
8.initApplicationEventMulticaster();
// 从方法名就可以知道，典型的模板方法(钩子方法)，
// 具体的子类可以在这里初始化一些特殊的 Bean（在初始化 singleton beans 之前）
9.onRefresh();
// 注册事件监听器，监听器需要实现 ApplicationListener 接口。这也不是我们的重点，过
10.registerListeners();
//初始化所有的sigleton beans，在这个阶段完成所有bean的实例化
11. finishBeanFactoryInitialization
11.1//初始化所有的 conversionService Bean，该类型的bean能够完成类型的转化
//初始化剩余的bean
11.2 beanFactory.preInstantiateSingletons();
//for循环处理所有的singleton Bean
for (String beanName : beanNames) {
//合并其parent的属性，涉及parent属性
11.2.1RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
//对factoryBean进行处理
11.1.2 if (isFactoryBean(beanName)
// 对于普通的 Bean，只要调用 getBean(beanName) 这个方法就可以进行初始化了
11.2.3 getBean(beanName);
11.2.3.1 doGetBean
//处理别名与factoryBean
11.2.3.1.1 transformedBeanName(name);
// 检查下是不是已经创建过了
11.2.3.1.2 Object sharedInstance = getSingleton(beanName);
//如果agrs是空，希望创建bean，否则是为了获取bean
if (sharedInstance != null && args == null) {
}else{
// 检查一下这个 BeanDefinition 在容器中是否存在
11.2.3.1.3BeanFactory parentBeanFactory = getParentBeanFactory();
// 先初始化依赖的所有 Bean，这个很好理解。
// 注意，这里的依赖指的是 depends-on 中定义的依赖
11.2.3.1.4String[] dependsOn = mbd.getDependsOn();
//创建singleton的实例
// 创建 singleton 的实例
11.2.3.1.5
if (mbd.isSingleton()) {
11.2.3.1.5.1 return createBean(beanName, mbd, args);
// 确保 BeanDefinition 中的 Class 被加载
11.2.3.1.5.2 Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
//准备方法覆盖
11.2.3.1.5.3 mbdToUse.prepareMethodOverrides();
//创建BeanPostProcessor bean
11.2.3.1.5.4 Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
//创建bean
11.2.3.1.5.5 Object beanInstance = doCreateBean(beanName, mbdToUse, args);
//实例化 Bean
11.2.3.1.5.5.1 instanceWrapper = createBeanInstance(beanName, mbd, args);
//调用工厂方法实例化bean
return instantiateUsingFactoryMethod(beanName, mbd, args);
// 有参构造函数依赖注入
return autowireConstructor(beanName, mbd, null, null);
// 无参构造函数
return instantiateBean(beanName, mbd);
// 实例化
beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
// 如果不存在方法覆写，那就使用 java 反射进行实例化，否则使用 CGLIB
// 利用构造方法进行实例化
return BeanUtils.instantiateClass(constructorToUse);
//利用 CGLIB 来完成实例化
return instantiateWithMethodInjection(bd, beanName, owner);
//解决循环依赖
11.2.3.1.5.5.2 boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&isSingletonCurrentlyInCreation(beanName)
// 这一步也是非常关键的，这一步负责属性装配，因为前面的实例只是实例化了，并没有设值，这里就是设值
11.2.3.1.5.5.3 populateBean(beanName, mbd, instanceWrapper);
// 通过名字找到所有属性值，如果是 bean 依赖，先初始化依赖的 bean。记录依赖关系
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs);
}
// 通过类型装配。复杂一些
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
autowireByType(beanName, mbd, bw, newPvs);
}
// 设置 bean 实例的属性值
applyPropertyValues(beanName, mbd, bw, pvs);
// 还记得 init-method 吗？还有 InitializingBean 接口？还有 BeanPostProcessor 接口？
// 这里就是处理 bean 初始化完成后的各种回调
11.2.3.1.5.5.4 exposedObject = initializeBean(beanName, exposedObject, mbd);
// 如果 bean 实现了 BeanNameAware、BeanClassLoaderAware 或 BeanFactoryAware 接口，回调
invokeAwareMethods(beanName, bean);
// BeanPostProcessor 的 postProcessBeforeInitialization 回调
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
// 处理 bean 中定义的 init-method，
// 或者如果 bean 实现了 InitializingBean 接口，调用 afterPropertiesSet() 方法
invokeInitMethods(beanName, wrappedBean, mbd);
// BeanPostProcessor 的 postProcessAfterInitialization 回调
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
} // 创建 prototype 的实例
else if (mbd.isPrototype()) {
prototypeInstance = createBean(beanName, mbd, args);
}
}
