1.AnnotationConfigApplicationContext，ClassPathXmlApplicationContext 创建beanFactory的时机不一样。
AnnotationConfigApplicationContext，在容器启动之前就创建beanFactory
public GenericApplicationContext() {
this.beanFactory = new DefaultListableBeanFactory();
}
ClassPathXmlApplicationContext ，调refresh()后，即容器启动过程中创建beanFactory
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); > refreshBeanFactory(); // AbstractApplicationContext#refreshBeanFactory
先创建DefaultListableBeanFactory实例，然后 解析xml配置文件，注册bean到beanFactory，最后再将beanFactory赋值给容器
DefaultListableBeanFactory beanFactory = createBeanFactory();
beanFactory.setSerializationId(getId());
// 定制beanFactory，设置参数
customizeBeanFactory(beanFactory);
// 注册spring的xml配置的bean到beanFactory，此时容器还未指定beanbeanFactory
loadBeanDefinitions(beanFactory);
// 给容器指定beanFactory
synchronized (this.beanFactoryMonitor) {
this.beanFactory = beanFactory;
}
// Tell the subclass to refresh the internal bean factory. // 获得刷新的beanFactory // 对于AnnotationConfigApplicationContext，作用： // 1.调用org.springframework.context.support.GenericApplicationContext.refreshBeanFactory， // 只是指定了SerializationId // 2.直接返回beanFactory(不用创建，容器中已存在) // 对于ClassPathXmlApplicationContext，作用： // 1.调用AbstractRefreshableApplicationContext.refreshBeanFactory // 2.如果存在beanFactory，先销毁单例bean，关闭beanFactory，再创建beanFactory // 3.注册传入的spring的xml配置文件中配置的bean，注册到beanFactory // 4.将beanFactory赋值给容器，返回beanFactory ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Invoke factory processors registered as beans in the context. // 1.通过beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class) // 拿到ConfigurationClassPostProcessor // 2.通过ConfigurationClassPostProcessor.postProcessBeanDefinitionRegistry，注册所有注解配置的bean
（在这个后置处理器中，对beanDefinition进行遍历，就是spring默认的5个+appConfig（配置类），
（1）对appConfig进行full或者lite标记；
（2）
） // 注册的顺序： @ComponentScan>实现ImportSelector>方法bean>@ImportResource("spring.xml") // > 实现 ImportBeanDefinitionRegistrar (相对的顺序，都在同一个配置类上配置) // 3. 调用ConfigurationClassPostProcessor#postProcessBeanFactory // 增强@Configuration修饰的配置类 AppConfig--->AppConfig$$EnhancerBySpringCGLIB // (可以处理内部方法bean之间的调用，防止多例) // 添加了后置处理器 ConfigurationClassPostProcessor.ImportAwareBeanPostProcessor (new) invokeBeanFactoryPostProcessors(beanFactory);
doProcessConfigurationClass方法，解析注解的顺序：
1.@Component
2.@PropertySource
3.@ComponentScan（对注解的参数进行解析，解析后，对相应路径进行扫描，
// 找到@Component修饰的类的beanDefiniton集合
Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
通过该方法把对应路径有@Component注解的类进行扫描，然后对每个类进行遍历注解中的属性（看是否有懒加载之类的属性），对有@Component注解的类，注册到容器中）
4.处理完@ComponentScan后，遍历@Import注解
5.处理@ImportResource
6.处理@Bean
====上面步骤处理完成后，只有@Component注解的类注册到容器中，
其他的扫描到之后都记录起来，在下面的
（// 注册bean
this.registry.registerBeanDefinition(definitionHolder.getBeanName(), definitionHolder.getBeanDefinition());）
进行注册
注册顺序：
1.@Import
2.@Bean
3.@ImportResource("spring.xml")
4.实现 ImportBeanDefinitionRegistrar的 bean 注册到容器
加载完BeanDeifinition之后，进行实例化
// 实例化所有剩余的(非懒加载)单例。 finishBeanFactoryInitialization(beanFactory);
遍历每一个BeanDeifinition，如果不是抽象的，是单例的，不是懒加载的，
就去判断是否为FactoryBean
for (String beanName : beanNames) {
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
//不是抽象的，是单例的，不是懒加载的
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
if (isFactoryBean(beanName)) {
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
if (bean instanceof FactoryBean) {
final FactoryBean<?> factory = (FactoryBean<?>) bean;
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
((SmartFactoryBean<?>) factory)::isEagerInit,
getAccessControlContext());
}
else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
getBean(beanName);
}
}
}
else {
getBean(beanName);
}
}
}
在实例化bean中，调用了很多次BeanPostProcessor bean的后置处理器
第一次调用bean的后置处理器：
// 实例化前的后置处理器调用 InstantiationAwareBeanPostProcessor // 第1次调用后置处理器 Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
// 在目标对象实例化之前调用，可以返回任意类型的值，如果不为空， // 此时可以代替原本应该生成的目标对象实例（一般是代理对象） // InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
去循环所有的bean的后置处理器，如果是实现了InstantiationAwareBeanPostProcessor接口的bean的后置处理器，就去调用它的postProcessBeforeInstantiation的方法：
protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
if (result != null) {
return result;
}
}
}
return null;
}
如果想自定义，那么就实现InstantiationAwareBeanPostProcessor接口，例如：
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor;
import org.springframework.stereotype.Component;
//@Component
public class MyInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
/**
* BeanPostProcessor接口中的方法
* 在Bean的自定义初始化方法之前执行
* Bean对象已经存在了
*/
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
// TODO Auto-generated method stub
System.out.println(">>postProcessBeforeInitialization=="+bean);
return bean;
}
/**
* BeanPostProcessor接口中的方法
* 在Bean的自定义初始化方法执行完成之后执行
* Bean对象已经存在了
*/
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("<<postProcessAfterInitialization=="+bean);
return bean;
}
/**
* InstantiationAwareBeanPostProcessor中自定义的方法
* 在方法实例化之前执行 Bean对象还没有
*/
@Override
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
System.out.println("--->postProcessBeforeInstantiation=="+beanName);
if("user".equals(beanName)){
return new Fox();
}
return null;
}
/**
* InstantiationAwareBeanPostProcessor中自定义的方法
* 在方法实例化之后执行 Bean对象已经创建出来了
*/
@Override
public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
System.out.println("<---postProcessAfterInstantiation=="+beanName);
return true;
}
/**
* InstantiationAwareBeanPostProcessor中自定义的方法
* 可以用来修改Bean中属性的内容
*/
// @Override
// public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean,
// String beanName) throws BeansException {
// System.out.println("<---postProcessPropertyValues--->");
// return pvs;
// }
}
如果有设置object，返回后，直接调用postProcessAfterInitialization：
if (bean != null) {
// 如果bean不为空，调用 postProcessAfterInitialization 方法，否则走正常实例化流程
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
for (BeanPostProcessor processor : getBeanPostProcessors()) {
Object current = processor.postProcessAfterInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}
如果第一次调用后置处理器不做任何处理，就继续往下走，否则直接return。
第2次调用bean的后置处理器：
第二次调用后置处理器，是通过反射去实例化一个对象。其中包含很多内容，例如，选择构造器，选择到构造器之后，就反射创建对象，并将实例放在包装类BeanWrapper中返回。
/** * 第2次调用后置处理器 * 创建bean实例，并将实例放在包装类BeanWrapper中返回 * 1.通过工厂方法创建bean实例 method.invoke(obj,args) @Bean * 2.通过构造方法自动注入创建bean实例 ctor.newInstance(args) * 3.通过无参构造器创建bean实例 ctor.newInstance() */ instanceWrapper = createBeanInstance(beanName, mbd, args);
第3次调用bean后置处理器：处理对象中，熟悉或者方法上是否有@Autowred和@Value 的注解。
//允许后置处理器修改合并的bean定义 // MergedBeanDefinitionPostProcessor#postProcessMergedBeanDefinition // 第3次调用后置处理器 // AutowiredAnnotationBeanPostProcessor 解析@Autowired和@Value，封装到InjectionMetadata applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
第4次调用bean后置处理器，将早期的bean暴露出去
// 添加到singletonFactories SmartInstantiationAwareBeanPostProcessor#getEarlyBeanReference //第4次调用后置处理器 // earlySingletonExposure为true，将早期的bean暴露出去 addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
第5次调用bean后置处理器，在属性设置之前修改bean的状态
// 在属性设置之前修改bean的状态 InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation
// 第5次调用后置处理器
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
//在目标对象实例化之后调用，此时对象被实例化，但是对象的属性还未设置。如果该方法返回
//fasle,则会忽略之后的属性设置。返回true，按正常流程设置属性值
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
continueWithPropertyPopulation = false;
break;
}
}
}
}
第6次调用bean后置处理器，可以在该方法内对属性值进行修改（此时属性值还未设置，但可以修改原本会设置的进去的属性值）
//InstantiationAwareBeanPostProcessor.postProcessProperties
// 第6次调用后置处理器
// 可以在该方法内对属性值进行修改（此时属性值还未设置，但可以修改原本会设置的进去的属性值）。
// 如果postProcessAfterInstantiation方法返回false，该方法不会调用
// 依赖注入逻辑
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
//@Autowired 属性注入逻辑
// AutowiredAnnotationBeanPostProcessor.postProcessProperties
//AutowiredAnnotationBeanPostProcessor.AutowiredMethodElement.inject
//AutowiredAnnotationBeanPostProcessor.AutowiredFieldElement#inject
//DefaultListableBeanFactory#resolveDependency
//DefaultListableBeanFactory#doResolveDependency
//DependencyDescriptor#resolveCandidate
// 此方法直接返回 beanFactory.getBean(beanName);
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
return;
}
}
pvs = pvsToUse;
}
}
第7次调用后置处理器：
//第7次调用后置处理器 // 如果配置了@PostConstruct 会调用 // InitDestroyAnnotationBeanPostProcessor#postProcessBeforeInitialization // Aware方法调用 ApplicationContextAware EnvironmentAware ApplicationEventPublisherAware //ApplicationContextAwareProcessor#postProcessBeforeInitialization wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
第8次调用后置处理器：实现aop
// BeanPostProcessor.postProcessAfterInitialization //第8次调用后置处理器 // aop实现：AbstractAutoProxyCreator#postProcessAfterInitialization wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
第9次调用后置处理器：将bean注册为可以销毁
// 将bean注册为可以销毁 DestructionAwareBeanPostProcessor bean的销毁后置处理器 // 第九次调用后置处理器 registerDisposableBeanIfNecessary(beanName, bean, mbd);
至此，实例化，初始化完毕