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()进行反射设置依赖的值。

最后编辑于：2021.02.20 16:26:55

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 216,402评论 6赞 499
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 92,377评论 3赞 392
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 162,483评论 0赞 353
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 58,165评论 1赞 292
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 67,176评论 6赞 388
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 51,146评论 1赞 297
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 40,032评论 3赞 417
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 38,896评论 0赞 274
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 45,311评论 1赞 310
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 37,536评论 2赞 332
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 39,696评论 1赞 348
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 35,413评论 5赞 343
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 41,008评论 3赞 325
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 31,659评论 0赞 22
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 32,815评论 1赞 269
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 47,698评论 2赞 368
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 44,592评论 2赞 353