spring源码解析（3）

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);

　　至此，实例化，初始化完毕