spring4.3.6源代码 - context - Processor

 

 

org.springframework.context.annotation.ConfigurationClassPostProcessor
{
	1、public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry)
	{
		1、获取所有 <已经注册的bean列表>
		2、获取配置候选人
			for(迭代所有 <已经注册的bean列表>)
			{
				if 如bean类有声明@Configuration注解，那么BeanDefinition
				{
					beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_FULL); // full
				}
				else 类有声明 @Component、@ComponentScan、@Import、@ImportResource注解、或者 <类中有方法声明@Bean注解>
				{
					beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_LITE); // lite
				}

				if 类有声明@Order注解
				{
					beanDef.setAttribute(ORDER_ATTRIBUTE, orderAttributes.get(AnnotationUtils.VALUE));
				}

				return true;
			}
		3、do { // 会一直循环，指定没有bean需要解析
			parser.parse(configCandidates)
			{
				processConfigurationClass(ConfigurationClass configClass)
				{
					SourceClass sourceClass = doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
					{
						1、处理内部类，内部类上有声明 @Configuration 或者 【 @Component、@ComponentScan、@Import、@ImportResource注解、或者 <类中有方法声明@Bean注解> 】
							递归执行

						2、类上有@PropertySource注解
							解析并添加到 environment 对象

						3、类上有@ComponentScan注解
							根据 @ComponentScan配置的属性，扫描 @Component，功能同 <context:component-scan ... />

						4、类上有@Import注解
							// 根据@Import配置的属性，处理导入，功能同 <import>
							if 导入的类继承 ImportSelector
							{
								this.deferredImportSelectors.add(new DeferredImportSelectorHolder(configClass, (DeferredImportSelector) selector));
							}
							else if 导入的类继承 ImportBeanDefinitionRegistrar
							{
								configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
							}

						5、类上有@ImportResource注解
							configClass.addImportedResource(resolvedResource, readerClass);

						6、带有@Bean注解的方法列表
							configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));

						7、读取父类的带有@Bean注解的方法列表
							configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
					}

					this.configurationClasses.put(configClass, configClass); //!!! 存储配置类
				}
			}

			parser.validate();

			this.reader.loadBeanDefinitions(configClasses); // 注册BeanDefinition
			{
				for (迭代 ConfigurationClass 列表) {
					if (configClass.isImported()) { // 是被导入的（即：本configClass是在内部类声明的注解，解析出来的；即本注解声明在内部类上）
						registerBeanDefinitionForImportedConfigurationClass(configClass); // 注册BeanDefinition，要进入第二解析
						{
							1、用AnnotatedGenericBeanDefinition包装注解
							2、解析通用注解  @Lazy、@Primary、@DependsOn、@Role、@Description
							3、注册AnnotatedGenericBeanDefinition到registry
						}
					}

					for (BeanMethod beanMethod : configClass.getBeanMethods()) {
						loadBeanDefinitionsForBeanMethod(beanMethod); // 注册BeanDefinition，用工厂模式包装
						{
							1、获取声明@bean的所在的ConfigClass对象
							2、用ConfigurationClassBeanDefinition对象包装bean对象
							3、读取@Bean的属性，设置到ConfigurationClassBeanDefinition（@Bean(autowire="",initMethod="",destroyMethod="")）
							4、读取@Scope的属性，设置到ConfigurationClassBeanDefinition
							5、注ConfigurationClassBeanDefinition到registry
						}
					}

					loadBeanDefinitionsFromImportedResources(configClass.getImportedResources()); // 注册BeanDefinition
					{
						1、创建资源读取器（支持的类型有 .groovy 和 .xml 后缀的文件）
						2、执行解析 reader.loadBeanDefinitions(resource);
					}

					loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars())
					{
						for (Map.Entry<ImportBeanDefinitionRegistrar, AnnotationMetadata> entry : registrars.entrySet()) {
							// entry.getKey() == ImportBeanDefinitionRegistrar对象
							// entry.getValue() == 声明Import注解类的元信息对象
							entry.getKey().registerBeanDefinitions(entry.getValue(),this.registry);
						}
					}
				}
			}
		}
	}

	2、public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
	{
		// !!!  使用了@Configuration注解的类，生成子类，
		// 子类实现 org.springframework.context.annotation.ConfigurationClassEnhancer.EnhancedConfiguration 接口，
		// EnhancedConfiguration实现了BeanFactoryAware接口，所以“使用了@Configuration注解的类”能感知BeanFactory
		enhanceConfigurationClasses(beanFactory); //

		// 添加BeanPostProcessor
		beanFactory.addBeanPostProcessor(new ImportAwareBeanPostProcessor(beanFactory)); // 添加BeanPostProcessor
	}
}

org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor
{

	// 检查候选构造函数
	1、determineCandidateConstructors(Class<?> beanClass, final String beanName)
	{
		1、检查方法上包含注解@Lookup方法，配置addOverride，用途同：<lookup-method>
		2、获取所有构造函数
		3、过滤出候选的构造函数
			for（迭代所有构造函数）{
				1、如果有@Autowired注解 、 @Value注解、@Inject注解，获取注解的属性
					if 注解属性为null
					{
						1、检查是否是cglib类包装过，如果是，那么获取父类（即实际类）
						2、获取实际的类的构造函数
					}
					else
					{
						1、检查是否有标记required
						2、如果required，则判断构造函数有且只能有一个标记为required，否则抛错误
					}
			}
	}

	// 合并BeanDefinition（创建bean实例后调用）
	2、postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName)
	{
		if (beanType != null) {
			1、如果字段上有@Autowired注解 、 @Value注解、@Inject注解，获取注解的属性
			2、如果方法上有@Autowired注解 、 @Value注解、@Inject注解，获取注解的属性
		}
	}

	// 在《居于 autowireByName 或者 autowireByType 方式装配》后执行
	3、postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName)
	{
		1、根据字段上有@Autowired注解 、 @Value注解、@Inject注解，注入相应的依赖
		2、根据方法上有@Autowired注解 、 @Value注解、@Inject注解，注入相应的依赖
	}
}


org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor
{
	1、postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName)
	{
		for（迭代类里的所有方法）
		{
			“有@Required注解,但是没有配置值”，那么抛出异常
		}
	}
}

org.springframework.beans.factory.annotation.CommonAnnotationBeanPostProcessor
{
	1、postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName)
	{
		识别方法上的 @PostConstruct，用途相当于 init-method=""
		识别方法上的 @PreDestroy注解，用途相当于 destroy-method=""
		处理字段上的@WebServiceRef、@EJB、@Resource 注解
		处理方法上的@WebServiceRef、@EJB、@Resource 注解
	}

	2、postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName)
	{
		处理字段上的@WebServiceRef、@EJB、@Resource 注解，注入相应的依赖
		处理方法上的@WebServiceRef、@EJB、@Resource 注解，注入相应的依赖
	}

	3、postProcessBeforeInitialization(Object bean, String beanName)
	{
		根据方法上的 @PostConstruct，调用 init 方法，用途相当于 init-method=""
	}

	4、postProcessBeforeDestruction(Object bean, String beanName)
	{
		根据方法上的 @PreDestroy注解，调用 destroy 方法，用途相当于 destroy-method=""
	}
}

org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor
{
	postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName)
	{
		处理字段上的@PersistenceContext、@PersistenceUnit 注解
		处理方法上的@PersistenceContext、@PersistenceUnit 注解
	}

	postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName)
	{
		处理字段上的@PersistenceContext、@PersistenceUnit 注解，注入相应的依赖
		处理方法上的@PersistenceContext、@PersistenceUnit 注解，注入相应的依赖
	}

	postProcessBeforeDestruction(Object bean, String beanName)
	{
		销毁 EntityManager
	}
}

org.springframework.context.event.EventListenerMethodProcessor
{
	// 上下文refresh最后，预先实例化单例对象后，调用本方法
	afterSingletonsInstantiated()
	{
		1、扫描单例对象上包含@EventListener注解的方法
		2、用 ApplicationListenerMethodAdapter 适配目标方法，并注册到 context。
	}
}