Spring Annotation IOC

前面我们系统看过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()进行反射设置依赖的值。