Spring Annotation IOC
2021-01-28 本文已影响0人
涣涣虚心0215
前面我们系统看过IOC，AOP和Transaction的实现，但是都是基于XML的，那么基于Annotation和XML有什么区别呢？其实换汤不换药。就IOC来说，基于XML就是通过XmlBeanDefinitionReader读取ClassPathResource的配置，然后通过registerBeanDefinition到DefaultListableBeanFactory。
而基于annotation，同样也是需要将有注解的类组装成BeanDefinition添加到BeanFactory中。
至于后续调用getBean()获取bean实例的过程二者都是一模一样的。
基于Annotation示例
Annotation需要使用AnnotationConfigApplicationContext来进行操作，ApplicationContext是BeanFactory的子类，可以通过scan或者register来告诉context需要加载哪些BeanDefinition。
另外跟XML类似，它也需要提供BeanDefinitionReader（AnnotatedBeanDefinitionReader），除此之外，AnnotationConfigApplicationContext还提供scan操作（ClassPathBeanDefinitionScanner），扫描所提供路径下所有的Bean。
@Configuration
public class Config {
@Bean("student")
public Student getStudent(){
return new Student();
}
@Bean("teacher")
public Teacher getTeacher(){
return new Teacher();
}
}
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
//context.register(Config.class);
context.scan("com.gary.annotation");
context.refresh();
Teacher teacher = (Teacher) context.getBean("teacher");
teacher.sayName();
teacher.getStudent().sayName();
AnnotatedBeanDefinitionReader
在使用AnnotationConfigApplicationContext.register(Configuration.class)的时候，内部通过AnnotatedBeanDefinitionReader来读取有@Configuration的配置类信息，并注册到BeanFactory。
AnnotatedBeanDefinitionReader与XMLBeanDefinitionReader一样，也是需要传入BeanDefinitionRegistry，在这里传入的是AnnotationConfigApplicationContext实例，AnnotationConfigApplicationContext内部包含BeanFactory（即DefaultListableBeanFactory）
//传入BeanDefinitionRegistry，这里是AnnotationConfigApplicationContext
public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
//getOrCreateEnvironment获取Environment，能获取环境变量相关
this(registry, getOrCreateEnvironment(registry));
}
//实际逻辑，获取conditionEvaluator，以及注册一些annotation post processors
public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
this.registry = registry;
this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}
AnnotatedBeanDefinitionReader.registerAnnotationConfigProcessors()
AnnotatedBeanDefinitionReader工作的前提条件就是需要注册与Annotation解析有关的BeanPostProcessor的BeanDefinition。
- ConfigurationClassPostProcessor，是一个BeanDefinitionRegistryPostProcessor(BeanFactoryPostProcessor)，处理@Configuration注解的类
- AutowiredAnnotationBeanPostProcessor，处理@Autowired和@Value以及@Inject注解
- CommonAnnotationBeanPostProcessor，针对于JSR250，处理@PostConstruct和@PreDestroy这两种与Bean生命周期相关的注解
- PersistenceAnnotationBeanPostProcessor，针对于JPA
- EventListenerMethodProcessor，跟事件监听@EventListener相关的注解
public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
BeanDefinitionRegistry registry, @Nullable Object source) {
。。。省略代码
Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
//注册ConfigurationClassPostProcessor，处理@Configuration注解的类
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));
}
//注册AutowiredAnnotationBeanPostProcessor，处理@Autowired和@Value以及@Inject注解
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));
}
//针对于JSR250，CommonAnnotationBeanPostProcessor，处理@PostConstruct和@PreDestroy这两种与Bean生命周期相关的注解
// Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
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，PersistenceAnnotationBeanPostProcessor
// Check for JPA support, and if present add the 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，跟事件监听@EventListener相关的注解
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));
}
//注册DefaultEventListenerFactory，负责创建createApplicationListener
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;
}
AnnotatedBeanDefinitionReader.register()
那么register的方法就很简单了，主要就是针对提供的有@Configuration的配置类，创建并注册与之对应的BeanDefinition。
里面还是涉及到@ Conditional，@Scope，@Lazy，@Primary，@DependsOn，@Role，@Description等注解的处理。
<T> void doRegisterBean(Class<T> annotatedClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,
@Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {
//创建BeanDefinition，里面封装了StandardAnnotationMetadata，通过该metadata，就能获得annotatedClass注解相关的方法
AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
//通过conditionEvaluator判断是否需要skip，主要看是不是配置了@Conditional注解
if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
return;
}
//设置InstanceSupplier
abd.setInstanceSupplier(instanceSupplier);
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
//根据scopeMetadata获取scope，根据@Scope注解
abd.setScope(scopeMetadata.getScopeName());
String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
//处理common的注解，@Lazy，@Primary，@DependsOn，@Role，@Description，并设值到BeanDefinition相关属性中
AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
//如果传进来的qualifiers不为空，则重新设置Primary或者Lazy以及Qualifier
if (qualifiers != null) {
for (Class<? extends Annotation> qualifier : qualifiers) {
if (Primary.class == qualifier) {
abd.setPrimary(true);
}
else if (Lazy.class == qualifier) {
abd.setLazyInit(true);
}
else {
abd.addQualifier(new AutowireCandidateQualifier(qualifier));
}
}
}
//customize定制化BeanDefinition
for (BeanDefinitionCustomizer customizer : definitionCustomizers) {
customizer.customize(abd);
}
//封装BeanDefinitionHolder
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
//根据ScopedProxyMode决定是否要创建proxy
definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
//将BeanDefinition注册到registry中
BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}
ConfigurationClassPostProcessor
@Configuration标识这个类就是配置类，可替换xml配置文件，被注解的类内部包含有一个或多个被@Bean注解的方法。
那么上面提到ConfigurationClassPostProcessor是用来处理配置类的，那么在解析了配置类之后，肯定有步骤将里面的@Bean解析注册到BeanFactory。
因为实现了BeanDefinitionRegistryPostProcessor，所以它需要提供postProcessBeanDefinitionRegistry()和postProcessBeanFactory()方法，而这两个方法在ApplicationContext.refresh() --> invokeBeanFactoryPostProcessors()就会调用了。
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
//通过hashcode避免重复加载
int registryId = System.identityHashCode(registry);
if (this.registriesPostProcessed.contains(registryId)) {
throw new IllegalStateException(
"postProcessBeanDefinitionRegistry already called on this post-processor against " + registry);
}
if (this.factoriesPostProcessed.contains(registryId)) {
throw new IllegalStateException(
"postProcessBeanFactory already called on this post-processor against " + registry);
}
this.registriesPostProcessed.add(registryId);
//重点方法
processConfigBeanDefinitions(registry);
}
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
int factoryId = System.identityHashCode(beanFactory);
if (this.factoriesPostProcessed.contains(factoryId)) {
throw new IllegalStateException(
"postProcessBeanFactory already called on this post-processor against " + beanFactory);
}
this.factoriesPostProcessed.add(factoryId);
if (!this.registriesPostProcessed.contains(factoryId)) {
// BeanDefinitionRegistryPostProcessor hook apparently not supported...
// Simply call processConfigurationClasses lazily at this point then.
processConfigBeanDefinitions((BeanDefinitionRegistry) beanFactory);
}
//通过enhancer创建CGLIB的代理子类，作为配置类的beanClass
enhanceConfigurationClasses(beanFactory);
beanFactory.addBeanPostProcessor(new ImportAwareBeanPostProcessor(beanFactory));
}
//处理Config 配置bean的内容
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
String[] candidateNames = registry.getBeanDefinitionNames();
//根据BeanFactory里面的BeanDefinition，查找出配置类
for (String beanName : candidateNames) {
BeanDefinition beanDef = registry.getBeanDefinition(beanName);
if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) ||
ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) {
if (logger.isDebugEnabled()) {
logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
}
}
else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
}
}
// Return immediately if no @Configuration classes were found
//没有找到配置类@Configuration
if (configCandidates.isEmpty()) {
return;
}
// Sort by previously determined @Order value, if applicable
//根据@Order进行排序
configCandidates.sort((bd1, bd2) -> {
int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
return Integer.compare(i1, i2);
});
// Detect any custom bean name generation strategy supplied through the enclosing application context
//获取bean name generator
SingletonBeanRegistry sbr = null;
if (registry instanceof SingletonBeanRegistry) {
sbr = (SingletonBeanRegistry) registry;
if (!this.localBeanNameGeneratorSet) {
BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(CONFIGURATION_BEAN_NAME_GENERATOR);
if (generator != null) {
this.componentScanBeanNameGenerator = generator;
this.importBeanNameGenerator = generator;
}
}
}
if (this.environment == null) {
this.environment = new StandardEnvironment();
}
// Parse each @Configuration class 重点
//对配置类进行解析，处理@PropertySources，@ComponentScans，@Import等注解
ConfigurationClassParser parser = new ConfigurationClassParser(
this.metadataReaderFactory, this.problemReporter, this.environment,
this.resourceLoader, this.componentScanBeanNameGenerator, registry);
Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
do {
//解析并验证配置类
parser.parse(candidates);
parser.validate();
Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
configClasses.removeAll(alreadyParsed);
// Read the model and create bean definitions based on its content
//这里是核心，通过ConfigurationClassBeanDefinitionReader来解析配置类里面的bean
if (this.reader == null) {
this.reader = new ConfigurationClassBeanDefinitionReader(
registry, this.sourceExtractor, this.resourceLoader, this.environment,
this.importBeanNameGenerator, parser.getImportRegistry());
}
this.reader.loadBeanDefinitions(configClasses);
alreadyParsed.addAll(configClasses);
candidates.clear();
if (registry.getBeanDefinitionCount() > candidateNames.length) {
String[] newCandidateNames = registry.getBeanDefinitionNames();
Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
Set<String> alreadyParsedClasses = new HashSet<>();
for (ConfigurationClass configurationClass : alreadyParsed) {
alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
}
for (String candidateName : newCandidateNames) {
if (!oldCandidateNames.contains(candidateName)) {
BeanDefinition bd = registry.getBeanDefinition(candidateName);
if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
!alreadyParsedClasses.contains(bd.getBeanClassName())) {
candidates.add(new BeanDefinitionHolder(bd, candidateName));
}
}
}
candidateNames = newCandidateNames;
}
}
while (!candidates.isEmpty());
// Register the ImportRegistry as a bean in order to support ImportAware @Configuration classes
if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
}
if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {
// Clear cache in externally provided MetadataReaderFactory; this is a no-op
// for a shared cache since it'll be cleared by the ApplicationContext.
((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();
}
}
从上述代码中可以看出，需要通过ConfigurationClassBeanDefinitionReader来处理配置类中的@Bean或者@Import的bean。
private void loadBeanDefinitionsForConfigurationClass(
ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {
//进行Condition的检查
if (trackedConditionEvaluator.shouldSkip(configClass)) {
String beanName = configClass.getBeanName();
if (StringUtils.hasLength(beanName) && this.registry.containsBeanDefinition(beanName)) {
this.registry.removeBeanDefinition(beanName);
}
this.importRegistry.removeImportingClass(configClass.getMetadata().getClassName());
return;
}
//比如Config类import了另一个Con类，那么Con类就从这处理
//如果配置类是被Import的，通过registerBeanDefinitionForImportedConfigurationClass进行处理
if (configClass.isImported()) {
registerBeanDefinitionForImportedConfigurationClass(configClass);
}
//处理@Bean的，注册成ConfigurationClassBeanDefinition
for (BeanMethod beanMethod : configClass.getBeanMethods()) {
loadBeanDefinitionsForBeanMethod(beanMethod);
}
//处理配置类里面@Import的内容
loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
//处理实现了ImportBeanDefinitionRegistrar的类
loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
}
这里的BeanDefinition是ConfigurationClassBeanDefinition类型的，它会将配置类作为FactoryBeanName，以及@Bean的方法作为factoryMethodName，这样在createBeanInstance()的时候会通过instantiateUsingFactoryMethod()来创建beanInstance。
ConfigurationClassBeanDefinition
ClassPathBeanDefinitionScanner
scan和Register的唯一区别就是register明确知道传入的是哪个配置类，而scan，则是扫描所有的带有@Configuration的配置类，创建并注册BeanDefinition到BeanFactory。
然后后面处理都一样就是通过ConfigurationClassPostProcessor处理器来处理配置类中的@Bean。
总结
从上述代码中，可以看出，不管register还是scan，第一步都是找出@Configuration配置类，然后在refresh()过程中，通过invokeBeanFactoryPostProcessors()来调用ConfigurationClassPostProcessor。
ConfigurationClassPostProcessor内部会通过ConfigurationClassParser来继续处理@Configuration配置类，比如处理@PropertySources，@ComponentScans，@Import等注解。
另外通过ConfigurationClassBeanDefinitionReader来解析@Bean的类。
除此之外，像@PostConstruct，@PreDestroy等注解，在initializeBean() --> applyBeanPostProcessorsBeforeInitialization()里去调用CommonAnnotationBeanPostProcessor。
而@Autowired和@Value以及@Inject等注解在doCreateBean() --> applyMergedBeanDefinitionPostProcessors() --> AutowiredAnnotationBeanPostProcessor.postProcessMergedBeanDefinition()进行预先findAutowiringMetadata()处理得到InjectionMetadata，然后在populateBean()方法里调用AutowiredAnnotationBeanPostProcessor.postProcessProperties()进行反射设置依赖的值。
