SpringBoot 源码解析——AnnotatedBeanDefinitionReader 源码分析

点击上方 "Java指南者"关注, 星标或置顶一起成长

免费送 1024GB 精品学习资源 

在 BeanDefinitionLoader 源码分析 中讲 BeanDefinitionLoader 的时候，可以看到其中有一个属性是 AnnotatedBeanDefinitionReader，在该类构造方法中会根本传入的 BeanDefinitionRegistry 创建 AnnotatedBeanDefinitionReader 实例。下面一起来看下 AnnotatedBeanDefinitionReader 的源码。

先来看看该类的构造方法：

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
    this(registry, getOrCreateEnvironment(registry));
}

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
    this.beanNameGenerator = AnnotationBeanNameGenerator.INSTANCE;
    this.scopeMetadataResolver = new AnnotationScopeMetadataResolver();
    Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
    Assert.notNull(environment, "Environment must not be null");
    this.registry = registry;
    //条件评估器
    this.conditionEvaluator = new ConditionEvaluator(registry, environment, (ResourceLoader)null);
    //使用注解配置时需要注入的一些后置处理器
    AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}

我们来看下下面方法中向 Spring 容器注入注解配置时需要使用的后置处理器：

AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);

public static void registerAnnotationConfigProcessors(BeanDefinitionRegistry registry) {
    registerAnnotationConfigProcessors(registry, (Object)null);
}

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(BeanDefinitionRegistry registry, @Nullable Object source) {
    // 将工厂使用的比较器和解析器设置成注解形式的实例
    DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
    if (beanFactory != null) {
        if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
            beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
        }

        if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
            beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
        }
    }

    Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet(8);
    RootBeanDefinition def;
    // 判断注册器中是否存在Spring内置的ConfigurationClassPostProcessor类型的Bean
 // 如果没有则添加到注册器中
    if (!registry.containsBeanDefinition("org.springframework.context.annotation.internalConfigurationAnnotationProcessor")) {
        def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.annotation.internalConfigurationAnnotationProcessor"));
    }
    // 判断注册器中是否存在Spring内置的AutowiredAnnotationBeanPostProcessor类型的Bean
 // 如果没有则添加到注册器中
    if (!registry.containsBeanDefinition("org.springframework.context.annotation.internalAutowiredAnnotationProcessor")) {
        def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.annotation.internalAutowiredAnnotationProcessor"));
    }

    if (jsr250Present && !registry.containsBeanDefinition("org.springframework.context.annotation.internalCommonAnnotationProcessor")) {
        def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.annotation.internalCommonAnnotationProcessor"));
    }

    if (jpaPresent && !registry.containsBeanDefinition("org.springframework.context.annotation.internalPersistenceAnnotationProcessor")) {
        def = new RootBeanDefinition();

        try {
            def.setBeanClass(ClassUtils.forName("org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor", AnnotationConfigUtils.class.getClassLoader()));
        } catch (ClassNotFoundException var6) {
            throw new IllegalStateException("Cannot load optional framework class: org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor", var6);
        }

        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.annotation.internalPersistenceAnnotationProcessor"));
    }

    if (!registry.containsBeanDefinition("org.springframework.context.event.internalEventListenerProcessor")) {
        def = new RootBeanDefinition(EventListenerMethodProcessor.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.event.internalEventListenerProcessor"));
    }

    if (!registry.containsBeanDefinition("org.springframework.context.event.internalEventListenerFactory")) {
        def = new RootBeanDefinition(DefaultEventListenerFactory.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.event.internalEventListenerFactory"));
    }

    return beanDefs;
}

在能够使用 AnnotatedBeanDefinitionReader 开始对注解注册 Bean 之前，Spring 加入了一系列的 BeanPostProcessor 处理器。

还记得在 BeanDefinitionLoader 类中的 load 方法吗，代码如下：

private int load(Class<?> source) {
    if (isGroovyPresent() && GroovyBeanDefinitionSource.class.isAssignableFrom(source)) {
        // Any GroovyLoaders added in beans{} DSL can contribute beans here
        GroovyBeanDefinitionSource loader = BeanUtils.instantiateClass(source, GroovyBeanDefinitionSource.class);
        load(loader);
    }
    if (isComponent(source)) {
        this.annotatedReader.register(source);
        return 1;
    }
    return 0;
}

在该方法中会调用 AnnotatedBeanDefinitionReader 中的  register 方法，代码如下：

public void register(Class... componentClasses) {
    Class[] var2 = componentClasses;
    int var3 = componentClasses.length;

    for(int var4 = 0; var4 < var3; ++var4) {
        Class<?> componentClass = var2[var4];
        this.registerBean(componentClass);
    }
}

在该方法中会将所有扫描到含 component 注解的类进行注册成 Bean。接下来看下 registerBean 方法的代码：

public void registerBean(Class<?> beanClass) {
    this.doRegisterBean(beanClass, (String)null, (Class[])null, (Supplier)null, (BeanDefinitionCustomizer[])null);
}

private <T> void doRegisterBean(Class<T> beanClass, @Nullable String name, @Nullable Class<? extends Annotation>[] qualifiers, @Nullable Supplier<T> supplier, @Nullable BeanDefinitionCustomizer[] customizers) {
    // 包装注解类
    AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);
    // 判断是否应该跳过注册Bean
    if (!this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
        abd.setInstanceSupplier(supplier);
        // 获取Scope元数据信息
        ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
        abd.setScope(scopeMetadata.getScopeName());
        // 生成Bean名称
        String beanName = name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry);
        // 处理一些公共的注解
        AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
        int var10;
        int var11;
        if (qualifiers != null) {
            Class[] var9 = qualifiers;
            var10 = qualifiers.length;

            for(var11 = 0; var11 < var10; ++var11) {
                Class<? extends Annotation> qualifier = var9[var11];
                if (Primary.class == qualifier) {
                    abd.setPrimary(true);
                } else if (Lazy.class == qualifier) {
                    abd.setLazyInit(true);
                } else {
                    abd.addQualifier(new AutowireCandidateQualifier(qualifier));
                }
            }
        }

        if (customizers != null) {
            BeanDefinitionCustomizer[] var13 = customizers;
            var10 = customizers.length;

            for(var11 = 0; var11 < var10; ++var11) {
                BeanDefinitionCustomizer customizer = var13[var11];
                customizer.customize(abd);
            }
        }
  // 创建Bean定义对象
        BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
        // 代理类
        definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
        // 注册到Spring中
        BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
    }
}

上面说了 conditionEvaluator.shouldSkip(abd.getMetadata()) 会判断是否应该跳过注册 Bean，我们来看下代码：

public boolean shouldSkip(AnnotatedTypeMetadata metadata) {
    return this.shouldSkip(metadata, (ConfigurationPhase)null);
}

public boolean shouldSkip(@Nullable AnnotatedTypeMetadata metadata, @Nullable ConfigurationPhase phase) {
    //是否属于 Conditional 类型注解
    if (metadata != null && metadata.isAnnotated(Conditional.class.getName())) {
        if (phase == null) {
            return metadata instanceof AnnotationMetadata && ConfigurationClassUtils.isConfigurationCandidate((AnnotationMetadata)metadata) ? this.shouldSkip(metadata, ConfigurationPhase.PARSE_CONFIGURATION) : this.shouldSkip(metadata, ConfigurationPhase.REGISTER_BEAN);
        } else {
            // 从@conditional中获取Condition集合
            List<Condition> conditions = new ArrayList();
            Iterator var4 = this.getConditionClasses(metadata).iterator();

            while(var4.hasNext()) {
                String[] conditionClasses = (String[])var4.next();
                String[] var6 = conditionClasses;
                int var7 = conditionClasses.length;

                for(int var8 = 0; var8 < var7; ++var8) {
                    String conditionClass = var6[var8];
                    Condition condition = this.getCondition(conditionClass, this.context.getClassLoader());
                    conditions.add(condition);
                }
            }
   // 进行排序
            AnnotationAwareOrderComparator.sort(conditions);
            var4 = conditions.iterator();
   // 一旦发现有不匹配的Condition就表示需要跳过注册
            Condition condition;
            ConfigurationPhase requiredPhase;
            do {
                do {
                    if (!var4.hasNext()) {
                        return false;
                    }

                    condition = (Condition)var4.next();
                    requiredPhase = null;
                    if (condition instanceof ConfigurationCondition) {
                        requiredPhase = ((ConfigurationCondition)condition).getConfigurationPhase();
                    }
                } while(requiredPhase != null && requiredPhase != phase);
            } while(condition.matches(this.context, metadata));

            return true;
        }
    } else {
        return false;
    }
}

注册 Bean：

public static void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) throws BeanDefinitionStoreException {
    String beanName = definitionHolder.getBeanName();
    registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
    String[] aliases = definitionHolder.getAliases();
    if (aliases != null) {
        String[] var4 = aliases;
        int var5 = aliases.length;

        for(int var6 = 0; var6 < var5; ++var6) {
            String alias = var4[var6];
            registry.registerAlias(beanName, alias);
        }
    }

}

关注我

关注我，Java 学习不迷路！