SpringBoot源码-@Configuration注解的解析
1. 简介
本篇文章是对上一篇文章Spring刷新应用上下文的补充说明，详细讲述了上一篇文章中的第五步（实例化并调用所有注册的beanFactory后置处理器）中Spring解析@Configuration注解的过程。
在Spring3.0之前的Spring核心框架中，我们启动一个Spring容器必须使用一个XML文件。而到了3.0之后的版本Spring为创建容器新增了一个入口类——AnnotationConfigApplicationContext。AnnotationConfigApplicationContext和过去的ClassPathXmlApplicationContext、FileSystemXmlApplicationContext等方法不同的是他不用再指定任何XML配置文件，而是可以通过指定类向容器添加Bean。
因此，从Spring3.0后，只要在配置类上加@Configuration注解就可以替换之前的xml配置文件，被注解的类内部包含有一个或多个被@Bean注解的方法，这些方法将会被AnnotationConfigApplicationContext或AnnotationConfigWebApplicationContext类进行扫描，并用于构建bean定义，初始化Spring容器。从使用的角度来说可以把他理解为XML配置中的<beans>标签，但是二者又有些细节的差异。在<beans>标签中除了使用<bean>声名Bean以外，还有各种<context>标签来扩展功能，比如<context:component-scan/>、<context:annotation-config />以及<import>等，这些扩展的功能并不是@Configuration注解的参数，而是通过其它注解来实现的如：@ComponentScan、@Import。
1.1 前提
使用@Configuration注解需满足以下要求
- @Configuration不可以是final类型；
- @Configuration不可以是匿名类；
- 嵌套的configuration必须是静态类。
1.2 声明
Spring对@Configuration注解类的解析最终是在ConfigurationClassPostProcessor类调用的processConfigBeanDefinitions方法中使用Spring的工具类ConfigurationClassParser来进行的。ConfigurationClassPostProcessor类是BeanFactoryPostProcessor的实现（看下图），BeanFactoryPostProcessor用于spring应用启动过程中@Configuration类的处理（发现和处理所有的配置类，注册其中的bean定义）。
1.3 @Configuration源码
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Configuration {
@AliasFor(annotation = Component.class)
String value() default ""; //可以自定义Bean的名称
}
2 @Configuration类的解析
介绍
ConfigurationClassPostProcessor 位于 org.springframework.context.annotation 包中，这是一个 BeanDefinitionRegistryPostProcessor，隐含地也实现了接口BeanFactoryPostProcessor,用于spring 应用启动过程中 @Configuration 类的处理（发现和处理所有的配置类，注册其中的bean定义）。
引入时机
- 非Springboot的Sping应用，当在配置文件中使用<context:annotation-config/>或者 <context:component-scan/>时，该BeanFactoryPostProcessor会被注册。
- Springboot 应用中在ApplicationContext对象创建时，会在应用上下文类(参考AnnotationConfigServletWebServerApplicationContext/AnnotationConfigReactiveWebServerApplicationContext)的构造函数中创建AnnotatedBeanDefinitionReader对象时调用 AnnotationConfigUtils.registerAnnotationConfigProcessors() 注册这个BeanFactoryPostProcessor到容器。
调用时机
ConfigurationClassPostProcessor既实现了BeanDefinitionRegistryPostProcessor定义的方法postProcessBeanDefinitionRegistry,也实现了接口BeanFactoryPostProcessor定义的方法postProcessBeanFactory。
AbstractApplicationContext.refresh()方法执行时，在BeanFactory，也就是Spring容器被准备(prepare)和postProcess之后，AbstractApplicationContext的invokeBeanFactoryPostProcessors()方法被调用，这个方法用来执行所有容器中被作为bean注册的BeanFactoryPostProcessor,其中就包括对ConfigurationClassPostProcessor方法postProcessBeanDefinitionRegistry()以及postProcessBeanFactory()方法的调用。
调用过程
解析过程是在容器刷新方法中--refreshContext(context) --> refresh(context) --> ApplicationContext.refresh()
--> invokeBeanFactoryPostProcessor(beanFactory)（该方法在容器刷新专栏有详细讲解，就是调用了PostProcessorRegistrationDelegate类的invokeBeanFactoryPostProcessors方法）这个方法调用所有的BeanFactoryPostProcessor，同时也就启动了Configuration类的解析。此时的BeanFactory中已经加载了main class，以及内部定义的class。内部定义的class都是带internal的，这些并不是Configuration Class，解析程序会忽略这些类，最后只有SpringBoot的启动类（如：DemoApplication）会进行Configuration的解析处理。
这里之所有这样做的原因是上述方法执行时有可能注册新的BeanDefinitionRegistryPostProcessor/BeanFactoryPostProcessor到容器，而这些新注册的BeanDefinitionRegistryPostProcessor/BeanFactoryPostProcessor也需要在这个阶段执行。
注意事项
- BeanDefinitionRegistryPostProcessor可能会注册另外一个BeanDefinitionRegistryPostProcessor。
- 一个非BeanDefinitionRegistryPostProcessor BeanFactoryPostProcessor可能会注册另外一个BeanFactoryPostProcessor。
- 一个非BeanDefinitionRegistryPostProcessor BeanFactoryPostProcessor不会注册另外一个BeanDefinitionRegistryPostProcessor(注册了但是不会被执行)。
因为配置类中定义的每个bean定义方法都必须要赶在其它BeanFactoryPostProcessor应用前,所以完成bean定义注册任务的ConfigurationClassPostProcessor 被设计为拥有最高执行优先级Ordered.HIGHEST_PRECEDENCE。
2.1 开始看代码
重提上一篇文章 Spring 刷新应用上下文 中的invokeBeanFactoryPostProcessors方法，用以引出下文。
//实例化并调用所有注册的beanFactory后置处理器
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
Set<String> processedBeans = new HashSet<>();
if (beanFactory instanceof BeanDefinitionRegistry) {
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<>();
List<BeanDefinitionRegistryPostProcessor> registryProcessors = new LinkedList<>();
//遍历所有的beanFactoryPostProcessors,
//将BeanDefinitionRegistryPostProcessor和普通BeanFactoryPostProcessor区分开
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
BeanDefinitionRegistryPostProcessor registryProcessor =
(BeanDefinitionRegistryPostProcessor) postProcessor;
//主要看这里！！！
registryProcessor.postProcessBeanDefinitionRegistry(registry);
registryProcessors.add(registryProcessor);
}
else {
regularPostProcessors.add(postProcessor);
}
}
....省略此处代码在之前的文章已经介绍过了
该方法主要做了以下事情：
- 执行了BeanDefinitionRegistryPostProcessor（此处只有ConfigurationClassPostProcessor）
- 执行了BeanFactoryPostProcessor
- 完成了@Configuration配置文件的解析，并且把扫描到的、配置的Bean定义信息都加载进容器里
- Full模式下，完成了对@Configuration配置文件的加强，使得管理Bean依赖关系更加的方便了
registryProcessor.postProcessBeanDefinitionRegistry(registry)这一步（调用了ConfigurationClassPostProcessor类的postProcessBeanDefinitionRegistry方法）使用工具ConfigurationClassParser尝试发现所有的配置(@Configuration)类，使用工具ConfigurationClassBeanDefinitionReader注册所发现的配置类中所有的bean定义。结束执行的条件是所有配置类都被发现和处理,相应的bean定义注册到容器。
public class ConfigurationClassPostProcessor implements BeanDefinitionRegistryPostProcessor,
PriorityOrdered, ResourceLoaderAware, BeanClassLoaderAware, EnvironmentAware {
2.2 主要看这里
下面看ConfigurationClassPostProcessor类中postProcessBeanDefinitionRegistry()的处理逻辑，该方法使用工具ConfigurationClassParser尝试发现所有的配置(@Configuration)类，使用工具ConfigurationClassBeanDefinitionReader注册所发现的配置类中所有的bean定义。结束执行的条件是所有配置类都被发现和处理，相应的bean定义注册到容器。
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
//根据BeanDefinitionRegistry,生成registryId 是全局唯一的。
int registryId = System.identityHashCode(registry);
// 判断，如果这个registryId 已经被执行过了，就不能够再执行了，否则抛出异常
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);
}
// 已经执行过的registry防止重复执行
this.registriesPostProcessed.add(registryId);
// 调用processConfigBeanDefinitions 进行Bean定义的加载
processConfigBeanDefinitions(registry);
}
2.2.1 处理配置类并注册BeanDefinition
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
// 记录候选配置类
List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
// 获取已经注册的bean名称（将容器中已经登记的Bean定义作为候选配置类名称）
String[] candidateNames = registry.getBeanDefinitionNames();
// 程序此时处于容器启动的早期，通常此时 candidateNames 中实际上只会有一个配置类（即...Application启动类）
for (String beanName : candidateNames) {
BeanDefinition beanDef = registry.getBeanDefinition(beanName);
//如果beanDef现在就已经确定了是full或者lite，说明已经被解析过了，所以再来就直接输出debug
if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) ||
ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) {
if (logger.isDebugEnabled()) {
logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
}
}
// 检查是否是@Configuration的Class,如果是就标记下属性：full 或者lite。
else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
//如果当前的bean是Javabean配置类（含有@Configuration注解的类），则加入到集合configCandidates中
configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
}
}
// 如果一个配置文件类都没找到，直接返回
if (configCandidates.isEmpty()) {
return;
}
// 把这些配置按照@Order注解进行排序（@Configuration注解的配置文件是支持order排序的。但是普通bean不行）
configCandidates.sort((bd1, bd2) -> {
int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
return Integer.compare(i1, i2);
});
// 尝试检测自定义的 BeanNameGenerator
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;
}
}
}
// web环境这里都设置了StandardServletEnvironment
//正常情况下env环境不可能为null（此处做容错处理）
if (this.environment == null) {
this.environment = new StandardEnvironment();
}
// ConfigurationClassParser是真正解析@Configuration注解的类
ConfigurationClassParser parser = new ConfigurationClassParser(
this.metadataReaderFactory, this.problemReporter, this.environment,
this.resourceLoader, this.componentScanBeanNameGenerator, registry);
// 表示将要被处理的候选配置类
// 因为不清楚候选是否确实是配置类，所以使用BeanDefinitionHolder类型记录
// 这里初始化为方法开始时容器中注解了@Configuration的Bean定义的集合
Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
// 装载已经处理过的配置类，最大长度为：configCandidates.size()
// 表示已经处理的配置类，已经被处理的配置类已经明确了其类型，所以用 ConfigurationClass 类型记录，
Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
do {
// 解析目标配置类【第一个解析的是应用程序主类】
parser.parse(candidates);
// 主要校验配置类不能使用final修饰符（CGLIB代理是生成一个子类，因此原先的类不能使用final修饰）
parser.validate();
// 从分析器parser中获取分析得到的配置类configurationClasses
Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
configClasses.removeAll(alreadyParsed);
// 如果Reader为null，那就实例化ConfigurationClassBeanDefinitionReader来加载Bean，
// 并加入到alreadyParsed中,用于去重（避免@ComponentScan直接互扫）
if (this.reader == null) {
this.reader = new ConfigurationClassBeanDefinitionReader(
registry, this.sourceExtractor, this.resourceLoader, this.environment,
this.importBeanNameGenerator, parser.getImportRegistry());
}
// 此处调用ConfigurationClassBeanDefinitionReader的loadBeanDefinitionsd方法
// 加载配置文件里面的@Bean/@Import，此方法决定了向容器注册Bean定义信息的顺序
this.reader.loadBeanDefinitions(configClasses);
// 刚刚处理完的配置类记录到已处理配置类alreadyParsed集合中
alreadyParsed.addAll(configClasses);
// 清空候选配置类集合，为下一轮do循环做初始化准备
candidates.clear();
// 如果registry中注册的bean的数量 大于 之前获得的数量
if (registry.getBeanDefinitionCount() > candidateNames.length) {
// 则意味着在解析过程中发现并注册了更多的Bean定义到容器中去，这些新注册的Bean定义
// 也有可能是候选配置类，它们也要被处理用来发现和注册Bean定义
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) {
// 如果老的oldCandidateNames不包含就说明是新进来的候选的Bean定义(即当前 BeanDefinition 是新解析的)
if (!oldCandidateNames.contains(candidateName)) {
BeanDefinition bd = registry.getBeanDefinition(candidateName);
if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
!alreadyParsedClasses.contains(bd.getBeanClassName())) {
// 基于 BeanDefinition 创建 BeanDefinitionHolder 并将其写入 candidates
candidates.add(new BeanDefinitionHolder(bd, candidateName));
}
}
}
candidateNames = newCandidateNames;
}
}
while (!candidates.isEmpty());// 直到所有的配置类都解析完毕
// 注册 ImportRegistry bean 到 SingletonBeanRegistry 中
if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
}
//清除缓存（元数据缓存）
if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {
((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();
}
}
下面文章主要围绕processConfigBeanDefinitions方法做的扩展延伸。
3 解析processConfigBeanDefinitions方法
3.1 概要分析
处理配置类并注册BeanDefinition的方法比较复杂，下面针对方法中一些重要的功能点进行解析：
3.2. 介绍ConfigurationClassUtils工具类
3.3. 解析Java配置类ConfigurationClassParser#parse(Set<BeanDefinitionHolder> configCandidates)
3.3.1 processConfigurationClass解析单个配置类
3.3.1.1 doProcessConfigurationClass
3.3.1.1.1 processMemberClasses
3.3.1.1.2 处理给定的@PropertySource 注解元数据
3.3.1.1.3 @ComponentScan注解解析过程
3.3.1.1.3 processImports
3.3.1.1.5 processInterfaces
3.3.1.2 ConditionEvaluator条件评估
3.3.1.3 ConfigurationClass配置类
3.3.1.4 ConditionalOnProperty
3.4. loadBeanDefinitions加载bean定义信息
3.2 ConfigurationClassUtils工具类
ConfigurationClassUtils工具类用于检查是否是含有@Configuration注解的类，需要注意下面两个核心方法，是如何判断某个类是否为配置类的（判断是full模式，还是lite模式的配置文件）：
- 如果类上有@Configuration注解说明是一个完全（Full）的配置类
- 如果如果类上面有@Component，@ComponentScan，@Import，@ImportResource这些注解，那么就是一个简化配置类。如果不是上面两种情况，那么有@Bean注解修饰的方法也是简化配置类
abstract class ConfigurationClassUtils {
private static final String CONFIGURATION_CLASS_FULL = "full";
private static final String CONFIGURATION_CLASS_LITE = "lite";
private static final String CONFIGURATION_CLASS_ATTRIBUTE =
Conventions.getQualifiedAttributeName(ConfigurationClassPostProcessor.class, "configurationClass");
private static final String ORDER_ATTRIBUTE =
Conventions.getQualifiedAttributeName(ConfigurationClassPostProcessor.class, "order");
private static final Log logger = LogFactory.getLog(ConfigurationClassUtils.class);
private static final Set<String> candidateIndicators = new HashSet<>(4);
static {
candidateIndicators.add(Component.class.getName());
candidateIndicators.add(ComponentScan.class.getName());
candidateIndicators.add(Import.class.getName());
candidateIndicators.add(ImportResource.class.getName());
}
// 只要这个类标注了：@Configuration注解就行(接口、抽象类都没问题）
public static boolean isFullConfigurationCandidate(AnnotationMetadata metadata) {
return metadata.isAnnotated(Configuration.class.getName());
}
// 判断是Lite模式的条件：（首先肯定没有@Configuration注解）
// 1、不能是接口
// 2、但凡只要标注了一个下面注解，都算lite模式：@Component @ComponentScan @Import @ImportResource
// 3、只要存在有一个方法标注了@Bean注解，那就是lite模式
public static boolean isLiteConfigurationCandidate(AnnotationMetadata metadata) {
// 不能是接口
if (metadata.isInterface()) {
return false;
}
// 但凡只有标注了一个下面注解，都算lite模式：@Component @ComponentScan @Import @ImportResource
for (String indicator : candidateIndicators) {
if (metadata.isAnnotated(indicator)) {
return true;
}
}
// 只有存在有一个方法标注了@Bean注解，那就是lite模式
try {
return metadata.hasAnnotatedMethods(Bean.class.getName());
}
catch (Throwable ex) {
if (logger.isDebugEnabled()) {
logger.debug("Failed to introspect @Bean methods on class [" + metadata.getClassName() + "]: " + ex);
}
return false;
}
}
// 不管是Full模式还是Lite模式，都被认为是候选的配置类，是上面两个方法的结合
public static boolean isConfigurationCandidate(AnnotationMetadata metadata) {
return (isFullConfigurationCandidate(metadata) || isLiteConfigurationCandidate(metadata));
}
// 下面两个方法是直接判断Bean定义信息，是否是配置类，至于Bean定义里这个属性什么时候放进去的，请参考
//ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)方法，
//它会对每个Bean定义信息进行检测（毕竟刚开始Bean定义信息是非常少的，所以速度也很快）
public static boolean isFullConfigurationClass(BeanDefinition beanDef) {
return CONFIGURATION_CLASS_FULL.equals(beanDef.getAttribute(CONFIGURATION_CLASS_ATTRIBUTE));
}
public static boolean isLiteConfigurationClass(BeanDefinition beanDef) {
return CONFIGURATION_CLASS_LITE.equals(beanDef.getAttribute(CONFIGURATION_CLASS_ATTRIBUTE));
}
Full模式和Lite模式的区别：
- 当@Bean方法声明在没有被@Conguration注解的类里，这就是所谓的以’精简’模式（Lite）处理。例如，在一个@Component中，甚至在一个普通的类中声明的bean方法都会以’精简’处理。
- 跟完整@Configuration不同的是，精简@Bean方法难以声明bean之间的依赖。通常，在精简模式中操作时，不应该在一个@Bean方法中调用另一个@Bean方法。一种推荐的方式是只在@Configuration类中使用@Bean方法，这样可以确保总是使用’完整’模式，避免@Bean方法意外地被调用多次，减少那些在精简模式下产生的很难跟踪的微妙bugs。
例如：
@Configuration
public class AppConfig {
@Bean
public Foo foo() {
return new Foo(bar()); // 这里调用的bar()方法
}
@Bean
public Bar bar() {
return new Bar();
}
}
Foo 接受一个bar的引用来进行构造器注入：这种方法声明的bean的依赖关系只有在@Configuration类的@Bean方法中有效。如果换成@Component（Lite模式），则foo()方法中new Foo（bar()）传入的bar()方法会每次产生一个新的Bar对象
结论：
在@Component或其他组建中使用@Bean好处是不会启动CGLIB这种重量级工具（不过在Spring中即使这里不使用，其他很多地方也在使用）。并且@Component及其相关的Stereotype组件自身就有摸框级别的功能，在这里使用@Bean注解能很好的表明一个Bean的从属和结构关系，但是需要注意直接调用方法的“副作用”。
个人建议如果没什么特别的要求就使用@Configuration，引入CGLIB并不会影响多少性能，然而坑会少很多。在spring官网将用@Configuration创建的@Bean称呼为"Full"模式、将@Component创建的@Bean称呼为"'lite"模式，从字面上也能略知他们的差异。
只有类上标注@Configuration才是full模式。标注有@Component、@ComponentScan、@Import、@ImportResource或者啥注解都没标注但是有被标注了@Bean的方法这种也是lite模式
3.3 解析Java配置类
解过程中
- 如果遇到注解了@Component类，直接作为Bean定义注册到容器
- 如果注解或者注解的注解中有@Import, 处理所有这些@import，识别配置类,添加到分析器的属性configurationClasses中去
ConfigurationClassParser#parse
public void parse(Set<BeanDefinitionHolder> configCandidates) {
this.deferredImportSelectors = new LinkedList<>();
for (BeanDefinitionHolder holder : configCandidates) {
BeanDefinition bd = holder.getBeanDefinition();
// 下面三种方式解析Bean
try {
// 我们使用的注解驱动，所以会到这个parse进来处理。
if (bd instanceof AnnotatedBeanDefinition) {
// 其实内部调用都是processConfigurationClass进行解析的
parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
}
//只要有注解标注的，都会走这里来解析
else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
}
else {
parse(bd.getBeanClassName(), holder.getBeanName());
}
}
catch (BeanDefinitionStoreException ex) {
throw ex;
}
catch (Throwable ex) {
throw new BeanDefinitionStoreException(
"Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);
}
}
//处理ImportSelect，执行找到的 DeferredImportSelector
//DeferredImportSelector 是 ImportSelector 的一个变种。
// ImportSelector 被设计成其实和@Import注解的类同样的导入效果，但是实现 ImportSelector
// 的类可以条件性地决定导入哪些配置。
// DeferredImportSelector 的设计目的是在所有其他的配置类被处理后才处理。这也正是
// 该语句被放到本函数最后一行的原因。
processDeferredImportSelectors();
}
该方法做了三件事如下：
- 实例化deferredImportSelectors
- 遍历configCandidates ,进行处理.根据BeanDefinition 的类型 做不同的处理,一般都会调用ConfigurationClassParser#parse 进行解析
- 处理ImportSelect
3.3.1 处理@Configuration配置类
解析@Configuration配置文件，然后加载进Bean的定义信息。可以看到它加载Bean定义信息的一个顺序
protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
//ConfigurationCondition继承自Condition接口
// ConfigurationPhase枚举类型的作用：根据条件来判断是否加载这个配置类
// 两个值：PARSE_CONFIGURATION 若条件不匹配就不加载此@Configuration
// REGISTER_BEAN：无论如何，所有@Configurations都将被解析。
if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
return;
}
//判断同一个配置类是否重复加载过，如果重复加载过
ConfigurationClass existingClass = this.configurationClasses.get(configClass);
if (existingClass != null) {
if (configClass.isImported()) {
//如果这个配置类已经存在了,后面又被@Import进来了就会走这里，然后做属性合并
if (existingClass.isImported()) {
existingClass.mergeImportedBy(configClass);
}
return;
}
else {
//从集合中移除旧的配置类，后续逻辑将处理新的配置
this.configurationClasses.remove(configClass);
this.knownSuperclasses.values().removeIf(configClass::equals);
}
}
SourceClass sourceClass = asSourceClass(configClass);
do {
//【doProcessConfigurationClass】这个方法是解析配置文件的核心方法
sourceClass = doProcessConfigurationClass(configClass, sourceClass);
}
while (sourceClass != null);
//保存我们所有的配置类（注意：它是一个LinkedHashMap，所以是有序的和bean定义信息息息相关）
this.configurationClasses.put(configClass, configClass);
}
3.3.1.1 doProcessConfigurationClass
doProcessConfigurationClass方法主要实现从配置类中解析所有bean，包括处理内部类，父类以及各种注解
@Nullable
protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
throws IOException {
//配置类上存在 Component注解，则尝试递归处理其内部成员类
if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
processMemberClasses(configClass, sourceClass);
}
//处理所有 @PropertySource 注解：将目标资源导入到 environment.propertySources 中
//将所有的 @PropertySource 注解合并到 @PropertySources 注解中，并逐个进行处理
for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
sourceClass.getMetadata(), PropertySources.class,
org.springframework.context.annotation.PropertySource.class)) {
if (this.environment instanceof ConfigurableEnvironment) {
processPropertySource(propertySource);
}
else {
logger.warn("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
"]. Reason: Environment must implement ConfigurableEnvironment");
}
}
//处理所有的 ComponentScan 注解
//以深度优先的方式递归处理所有扫描到的配置类
Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
if (!componentScans.isEmpty() &&
!this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
//循环处理每个 ComponentScan 注解
for (AnnotationAttributes componentScan : componentScans) {
//如果此配置类存在ComponentScan注解，则通过 ComponentScanAnnotationParser立即处理它
Set<BeanDefinitionHolder> scannedBeanDefinitions =
this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
// 遍历扫描到的所有组件
for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
//若果扫描出的bean定义是配置类（含有@COnfiguration）
if (ConfigurationClassUtils.checkConfigurationClassCandidate(
holder.getBeanDefinition(), this.metadataReaderFactory)) {
//继续调用parse，内部再次调用doProcessConfigurationClas()递归解析
parse(holder.getBeanDefinition().getBeanClassName(), holder.getBeanName());
}
}
}
}
//处理所有的 @Import 注解
//1.优先处理所有注解上的 @Import 注解导入的配置类
//2.后处理此类上通过@Import 注解直接导入的配置类
processImports(configClass, sourceClass, getImports(sourceClass), true);
//处理@ImportResource注解
AnnotationAttributes importResource =
AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
if (importResource != null) {
// 读取资源位置
String[] resources = importResource.getStringArray("locations");
// 读取 BeanDefinitionReader
Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
for (String resource : resources) {
// 解析占位符
String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
// 写入缓存
configClass.addImportedResource(resolvedResource, readerClass);
}
}
//处理所有的 @Bean 方法，将它们解析为 BeanMethod 并写入配置类中
Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
for (MethodMetadata methodMetadata : beanMethods) {
//将解析出的所有@Bean注解方法添加到configClass配置类信息中
configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
}
//处理所有接口上非 Abstract 的 @Bean 方法，并添加到configClass配置类信息中
processInterfaces(configClass, sourceClass);
// 如果有父类，则返回父类，递归执行doProcessConfigurationClass()解析父类
if (sourceClass.getMetadata().hasSuperClass()) {
String superclass = sourceClass.getMetadata().getSuperClassName();
if (superclass != null && !superclass.startsWith("java") &&
!this.knownSuperclasses.containsKey(superclass)) {
// 已处理的父类缓存
this.knownSuperclasses.put(superclass, configClass);
return sourceClass.getSuperClass();
}
}
// 此配置类处理完成
return null;
}
3.3.1.1.1 processMemberClasses
private void processMemberClasses(ConfigurationClass configClass, SourceClass sourceClass) throws IOException {
// 读取所有的成员类
Collection<SourceClass> memberClasses = sourceClass.getMemberClasses();
// 存在成员类
if (!memberClasses.isEmpty()) {
List<SourceClass> candidates = new ArrayList<>(memberClasses.size());
for (SourceClass memberClass : memberClasses) {
// 过滤出所有的配置类
if (ConfigurationClassUtils.isConfigurationCandidate(memberClass.getMetadata()) &&
!memberClass.getMetadata().getClassName().equals(configClass.getMetadata().getClassName())) {
candidates.add(memberClass);
}
}
// 根据 Order 进行排序
OrderComparator.sort(candidates);
for (SourceClass candidate : candidates) {
// 出现配置类循环导入
if (this.importStack.contains(configClass)) {
this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
}
else {
//将此配置类入栈
this.importStack.push(configClass);
try {
// 处理此配置类
processConfigurationClass(candidate.asConfigClass(configClass));
}
finally {
//解析完成后将其出栈
this.importStack.pop();
}
}
}
}
}
3.3.1.1.2 处理给定的@PropertySource 注解元数据
private void processPropertySource(AnnotationAttributes propertySource) throws IOException {
// 读取名称
String name = propertySource.getString("name");
if (!StringUtils.hasLength(name)) {
name = null;
}
// 读取编码
String encoding = propertySource.getString("encoding");
if (!StringUtils.hasLength(encoding)) {
encoding = null;
}
// 读取资源位置
String[] locations = propertySource.getStringArray("value");
Assert.isTrue(locations.length > 0, "At least one @PropertySource(value) location is required");
// 读取资源未找到则忽略标识
boolean ignoreResourceNotFound = propertySource.getBoolean("ignoreResourceNotFound");
// 读取 PropertySourceFactory
Class<? extends PropertySourceFactory> factoryClass = propertySource.getClass("factory");
PropertySourceFactory factory = (factoryClass == PropertySourceFactory.class ?
DEFAULT_PROPERTY_SOURCE_FACTORY : BeanUtils.instantiateClass(factoryClass));
// 循环处理每个资源
for (String location : locations) {
try {
// 解析占位符
String resolvedLocation = this.environment.resolveRequiredPlaceholders(location);
// 读取资源
Resource resource = this.resourceLoader.getResource(resolvedLocation);
// 创建 ResourcePropertySource 并加入到 environment 中
addPropertySource(factory.createPropertySource(name, new EncodedResource(resource, encoding)));
}
catch (IllegalArgumentException | FileNotFoundException | UnknownHostException ex) {
// 占位符解析失败或资源未找到
if (ignoreResourceNotFound) {
if (logger.isInfoEnabled()) {
logger.info("Properties location [" + location + "] not resolvable: " + ex.getMessage());
}
}
else {
throw ex;
}
}
}
}
3.3.1.1.3 @ComponentScan注解解析过程
@ComponentScan注解解析通过调用ComponentScanAnnotationParser的parse方法完成，而parse()方法内部处理了一些scanner属性(过滤器设置)和basePackages包名处理，最终通过调用ClassPathBeanDefinitionScanner.doScan方法实现扫面工作。
3.3.1.1.3.1 ComponentScan 注解
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Repeatable(ComponentScans.class)
public @interface ComponentScan {
/**
* 基础包名称
*/
@AliasFor("basePackages")
String[] value() default {};
/**
* 基础包名称
*/
@AliasFor("value")
String[] basePackages() default {};
/**
* 基础包类【读取指定类所在的包路径】
*/
Class<?>[] basePackageClasses() default {};
/**
* 用于生成 bean 名称的 BeanNameGenerator
*/
Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;
/**
* 范围解析器
*/
Class<? extends ScopeMetadataResolver> scopeResolver() default AnnotationScopeMetadataResolver.class;
/**
* 是否需要为目标组件生成代理，默认不生成
*/
ScopedProxyMode scopedProxy() default ScopedProxyMode.DEFAULT;
/**
* 资源模式
*/
String resourcePattern() default ClassPathScanningCandidateComponentProvider.DEFAULT_RESOURCE_PATTERN;
/**
* 是否使用默认的过滤器
* 自动检测 @Component、@Repository、@Service、@Controller 注解标注的类
*/
boolean useDefaultFilters() default true;
/**
* 指定扫描哪些类型
*/
Filter[] includeFilters() default {};
/**
* 指定排除哪些类型
*/
Filter[] excludeFilters() default {};
/**
* 扫描到的单例 bean 是否需要延迟初始化
*/
boolean lazyInit() default false;
@Retention(RetentionPolicy.RUNTIME)
@Target({})
@interface Filter {
/**
* 过滤类型，默认是基于注解
*/
FilterType type() default FilterType.ANNOTATION;
/**
* 用作筛选器的类，多个类之间是逻辑或的关系
*/
@AliasFor("classes")
Class<?>[] value() default {};
/**
* 用作筛选器的类，多个类之间是逻辑或的关系
*/
@AliasFor("value")
Class<?>[] classes() default {};
/**
* 匹配模式，根据 FilterType 分流
*/
String[] pattern() default {};
}
}
3.3.1.1.3.2 ComponentScan 注解解析器
/**
* @ComponentScan 注解解析器
*/
class ComponentScanAnnotationParser {
private final Environment environment;
private final ResourceLoader resourceLoader;
private final BeanNameGenerator beanNameGenerator;
private final BeanDefinitionRegistry registry;
public ComponentScanAnnotationParser(Environment environment, ResourceLoader resourceLoader,
BeanNameGenerator beanNameGenerator, BeanDefinitionRegistry registry) {
this.environment = environment;
this.resourceLoader = resourceLoader;
this.beanNameGenerator = beanNameGenerator;
this.registry = registry;
}
/**
* 解析指定的 @ComponentScan 注解
*/
public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, final String declaringClass) {
// 类路径 BeanDefinition 扫描器
final ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(registry,
componentScan.getBoolean("useDefaultFilters"), environment, resourceLoader);
// 设置扫描器的 BeanNameGenerator
final Class<? extends BeanNameGenerator> generatorClass = componentScan.getClass("nameGenerator");
final boolean useInheritedGenerator = BeanNameGenerator.class == generatorClass;
scanner.setBeanNameGenerator(useInheritedGenerator ? beanNameGenerator :
BeanUtils.instantiateClass(generatorClass));
// 尝试设置扫描器的 ScopedProxyMode
final ScopedProxyMode scopedProxyMode = componentScan.getEnum("scopedProxy");
if (scopedProxyMode != ScopedProxyMode.DEFAULT) {
scanner.setScopedProxyMode(scopedProxyMode);
}
else {
final Class<? extends ScopeMetadataResolver> resolverClass = componentScan.getClass("scopeResolver");
scanner.setScopeMetadataResolver(BeanUtils.instantiateClass(resolverClass));
}
// 设置扫描器的资源模式
scanner.setResourcePattern(componentScan.getString("resourcePattern"));
// 添加包含过滤器，默认无
for (final AnnotationAttributes filter : componentScan.getAnnotationArray("includeFilters")) {
for (final TypeFilter typeFilter : typeFiltersFor(filter)) {
scanner.addIncludeFilter(typeFilter);
}
}
// 添加排序过滤器
for (final AnnotationAttributes filter : componentScan.getAnnotationArray("excludeFilters")) {
for (final TypeFilter typeFilter : typeFiltersFor(filter)) {
scanner.addExcludeFilter(typeFilter);
}
}
// 设置延迟初始化属性
final boolean lazyInit = componentScan.getBoolean("lazyInit");
if (lazyInit) {
scanner.getBeanDefinitionDefaults().setLazyInit(true);
}
final Set<String> basePackages = new LinkedHashSet<>();
// 尝试读取 basePackages 属性
final String[] basePackagesArray = componentScan.getStringArray("basePackages");
for (final String pkg : basePackagesArray) {
// 解析占位符，并按照 ,;/t/n 切割包路径
final String[] tokenized = StringUtils.tokenizeToStringArray(environment.resolvePlaceholders(pkg),
ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
Collections.addAll(basePackages, tokenized);
}
// 读取 basePackageClasses，并提取出包路径
for (final Class<?> clazz : componentScan.getClassArray("basePackageClasses")) {
basePackages.add(ClassUtils.getPackageName(clazz));
}
/**
* 如果 basePackages 和 basePackageClasses 都未配置，
* 则以 @ComponentScan 注解所在配置类的包路径作为基础包
*/
if (basePackages.isEmpty()) {
basePackages.add(ClassUtils.getPackageName(declaringClass));
}
// 忽略此配置类
scanner.addExcludeFilter(new AbstractTypeHierarchyTraversingFilter(false, false) {
@Override
protected boolean matchClassName(String className) {
return declaringClass.equals(className);
}
});
// 执行包扫描
return scanner.doScan(StringUtils.toStringArray(basePackages));
}
private List<TypeFilter> typeFiltersFor(AnnotationAttributes filterAttributes) {
final List<TypeFilter> typeFilters = new ArrayList<>();
// 读取过滤类型
final FilterType filterType = filterAttributes.getEnum("type");
// 读取所有的 classes
for (final Class<?> filterClass : filterAttributes.getClassArray("classes")) {
switch (filterType) {
// 1）过滤类型为基于注解
case ANNOTATION:
// 目标 class 是否是注解
Assert.isAssignable(Annotation.class, filterClass,
"@ComponentScan ANNOTATION type filter requires an annotation type");
@SuppressWarnings("unchecked") final
Class<Annotation> annotationType = (Class<Annotation>) filterClass;
// 添加注解类型过滤器
typeFilters.add(new AnnotationTypeFilter(annotationType));
break;
// 2）过滤类型为基于目标类型及其子类
case ASSIGNABLE_TYPE:
// 添加类型过滤器
typeFilters.add(new AssignableTypeFilter(filterClass));
break;
// 3）过滤类型为基于自定义过滤器
case CUSTOM:
// 添加自定义 TypeFilter
Assert.isAssignable(TypeFilter.class, filterClass,
"@ComponentScan CUSTOM type filter requires a TypeFilter implementation");
final TypeFilter filter = BeanUtils.instantiateClass(filterClass, TypeFilter.class);
ParserStrategyUtils.invokeAwareMethods(
filter, environment, resourceLoader, registry);
typeFilters.add(filter);
break;
default:
throw new IllegalArgumentException("Filter type not supported with Class value: " + filterType);
}
}
// 如果指定了匹配模式
for (final String expression : filterAttributes.getStringArray("pattern")) {
switch (filterType) {
// 过滤类型为 ASPECTJ
case ASPECTJ:
typeFilters.add(new AspectJTypeFilter(expression, resourceLoader.getClassLoader()));
break;
// 过滤类型为 REGEX
case REGEX:
typeFilters.add(new RegexPatternTypeFilter(Pattern.compile(expression)));
break;
default:
throw new IllegalArgumentException("Filter type not supported with String pattern: " + filterType);
}
}
return typeFilters;
}
}
3.3.1.1.3.3 doScan
//ClassPathBeanDefinitionScanner#执行包扫描
protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
Assert.notEmpty(basePackages, "At least one base package must be specified");
final Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
for (final String basePackage : basePackages) {
//根据basePackage加载包下所有java文件，并扫描出所有bean组件,
//findCandidateComponents方法内部调用
//ClassPathScanningCandidateComponentProvider.scanCandidateComponents(backPackages)
final Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
//遍历beandefition
for (final BeanDefinition candidate : candidates) {
//解析作用域Scope
final ScopeMetadata scopeMetadata = scopeMetadataResolver.resolveScopeMetadata(candidate);
candidate.setScope(scopeMetadata.getScopeName());
final String beanName = beanNameGenerator.generateBeanName(candidate, registry);
if (candidate instanceof AbstractBeanDefinition) {
// 应用默认配置
postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
}
//通用注解解析到candidate结构中，主要是处理Lazy, primary DependsOn, Role ,Description这五个注解
if (candidate instanceof AnnotatedBeanDefinition) {
// 处理 BeanDefinition 相关注解
AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
}
//检查当前bean是否已经注册，不存在则注册
if (checkCandidate(beanName, candidate)) {
// 创建 BeanDefinitionHolder
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
// 尝试应用代理模式
definitionHolder =
AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, registry);
// 添加到 beanDefinitions 进行循环处理
beanDefinitions.add(definitionHolder);
// 注册到ioc容器中，主要是一些@Component组件，@Bean注解方法并没有在此处注册，
// definitionHolder: beanname和beandefinition 键值对
registerBeanDefinition(definitionHolder, registry);
}
}
}
return beanDefinitions;
}
3.3.1.1.3.4 AnnotationConfigUtils
public static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd) {
processCommonDefinitionAnnotations(abd, abd.getMetadata());
}
static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd, AnnotatedTypeMetadata metadata) {
// 1）目标元素存在 @Lazy 注解
AnnotationAttributes lazy = attributesFor(metadata, Lazy.class);
if (lazy != null) {
abd.setLazyInit(lazy.getBoolean("value"));
}
else if (abd.getMetadata() != metadata) {
lazy = attributesFor(abd.getMetadata(), Lazy.class);
if (lazy != null) {
abd.setLazyInit(lazy.getBoolean("value"));
}
}
// 2）目标元素存在 @Primary 注解
if (metadata.isAnnotated(Primary.class.getName())) {
abd.setPrimary(true);
}
// 3）目标元素存在 @DependsOn 注解
final AnnotationAttributes dependsOn = attributesFor(metadata, DependsOn.class);
if (dependsOn != null) {
abd.setDependsOn(dependsOn.getStringArray("value"));
}
// 4）目标元素存在 @Role 注解
final AnnotationAttributes role = attributesFor(metadata, Role.class);
if (role != null) {
abd.setRole(role.getNumber("value").intValue());
}
// 5）目标元素存在 @Description 注解
final AnnotationAttributes description = attributesFor(metadata, Description.class);
if (description != null) {
abd.setDescription(description.getString("value"));
}
}
static BeanDefinitionHolder applyScopedProxyMode(
ScopeMetadata metadata, BeanDefinitionHolder definition, BeanDefinitionRegistry registry) {
// 读取代理模式
final ScopedProxyMode scopedProxyMode = metadata.getScopedProxyMode();
if (scopedProxyMode.equals(ScopedProxyMode.NO)) {
return definition;
}
// 如果是基于 CGLIB 的类代理
final boolean proxyTargetClass = scopedProxyMode.equals(ScopedProxyMode.TARGET_CLASS);
return ScopedProxyCreator.createScopedProxy(definition, registry, proxyTargetClass);
}
3.3.1.1.3.5 ClassPathScanningCandidateComponentProvider
//扫描指定的类路径
public Set<BeanDefinition> findCandidateComponents(String basePackage) {
if (componentsIndex != null && indexSupportsIncludeFilters()) {
return addCandidateComponentsFromIndex(componentsIndex, basePackage);
}
else {
// 扫描组件
return scanCandidateComponents(basePackage);
}
}
//实现bean定义信息扫描
private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
final Set<BeanDefinition> candidates = new LinkedHashSet<>();
try {
// @ComponentScan("com.sl.springlearning.extension")包路径处理：
// packageSearchPath = classpath*:com/sl/springlearning/extension/**/*.class
final String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
resolveBasePackage(basePackage) + '/' + resourcePattern;
// 通过 ServletContextResourcePatternResolver 读取所有资源(当前包下所有的class文件)
final Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
final boolean traceEnabled = logger.isTraceEnabled();
final boolean debugEnabled = logger.isDebugEnabled();
// 循环处理所有资源
for (final Resource resource : resources) {
if (traceEnabled) {
logger.trace("Scanning " + resource);
}
// 资源是可读取的
if (resource.isReadable()) {
try {
// 读取 MetadataReader
final MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
//按照scanner过滤器过滤，比如配置类本身将被过滤掉，没有@Component等组件注解的类将过滤掉
if (isCandidateComponent(metadataReader)) {
// 基于 MetadataReader 创建 ScannedGenericBeanDefinition
final ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
sbd.setResource(resource);
sbd.setSource(resource);
// 是否是候选组件
if (isCandidateComponent(sbd)) {
if (debugEnabled) {
logger.debug("Identified candidate component class: " + resource);
}
candidates.add(sbd);
}
else {
if (debugEnabled) {
logger.debug("Ignored because not a concrete top-level class: " + resource);
}
}
}
else {
if (traceEnabled) {
logger.trace("Ignored because not matching any filter: " + resource);
}
}
}
catch (final Throwable ex) {
throw new BeanDefinitionStoreException(
"Failed to read candidate component class: " + resource, ex);
}
}
else {
if (traceEnabled) {
logger.trace("Ignored because not readable: " + resource);
}
}
}
}
catch (final IOException ex) {
throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
}
return candidates;
}
/**
* 将类名解析为资源路径
* 为了避免多余的替换操作，可以直接使用 / 作为包分隔符
*/
protected String resolveBasePackage(String basePackage) {
return ClassUtils.convertClassNameToResourcePath(getEnvironment().resolveRequiredPlaceholders(basePackage));
}
/**
* 目标类不匹配任何排除过滤器，并且至少匹配一个包含过滤器
*/
protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {
for (final TypeFilter tf : excludeFilters) {
// 匹配当期排除过滤器
if (tf.match(metadataReader, getMetadataReaderFactory())) {
return false;
}
}
for (final TypeFilter tf : includeFilters) {
// 匹配当前包含过滤器
if (tf.match(metadataReader, getMetadataReaderFactory())) {
return isConditionMatch(metadataReader);
}
}
return false;
}
/**
* 目标 BeanDefinition 是否是一个候选组件
*/
protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
final AnnotationMetadata metadata = beanDefinition.getMetadata();
/**
* 目标类型不是接口，并且不依赖于封闭类【不是内部类】
*/
return metadata.isIndependent() && (metadata.isConcrete() ||
metadata.isAbstract() && metadata.hasAnnotatedMethods(Lookup.class.getName()));
}
3.3.1.1.3.6 ServletContextResourcePatternResolver
/**
* 可配置 ServletContext 的 PathMatchingResourcePatternResolver
*/
public class ServletContextResourcePatternResolver extends PathMatchingResourcePatternResolver {
private static final Log logger = LogFactory.getLog(ServletContextResourcePatternResolver.class);
public ServletContextResourcePatternResolver(ServletContext servletContext) {
super(new ServletContextResourceLoader(servletContext));
}
public ServletContextResourcePatternResolver(ResourceLoader resourceLoader) {
super(resourceLoader);
}
@Override
protected Set<Resource> doFindPathMatchingFileResources(Resource rootDirResource, String subPattern)
throws IOException {
// 如果跟路径资源是 ServletContextResource
if (rootDirResource instanceof ServletContextResource) {
final ServletContextResource scResource = (ServletContextResource) rootDirResource;
final ServletContext sc = scResource.getServletContext();
final String fullPattern = scResource.getPath() + subPattern;
final Set<Resource> result = new LinkedHashSet<>(8);
doRetrieveMatchingServletContextResources(sc, fullPattern, scResource.getPath(), result);
return result;
}
else {
// 默认是 UrlResource
return super.doFindPathMatchingFileResources(rootDirResource, subPattern);
}
}
}
3.3.1.1.3.7 PathMatchingResourcePatternResolver
@Override
public Resource[] getResources(String locationPattern) throws IOException {
Assert.notNull(locationPattern, "Location pattern must not be null");
// 资源路径以 classpath*: 开头
if (locationPattern.startsWith(CLASSPATH_ALL_URL_PREFIX)) {
/**
* 支持多个同名文件
* a class path resource (multiple resources for same name possible)
* 资源路径是 Ant 风格的通配符
*/
if (getPathMatcher().isPattern(locationPattern.substring(CLASSPATH_ALL_URL_PREFIX.length()))) {
// a class path resource pattern
return findPathMatchingResources(locationPattern);
}
else {
// 读取 classpath 特定根路径下的所有资源
return findAllClassPathResources(locationPattern.substring(CLASSPATH_ALL_URL_PREFIX.length()));
}
}
else {
// Generally only look for a pattern after a prefix here, and on Tomcat only after the "*/" separator for its "war:" protocol.
final int prefixEnd = locationPattern.startsWith("war:") ? locationPattern.indexOf("*/") + 1 :
locationPattern.indexOf(':') + 1;
if (getPathMatcher().isPattern(locationPattern.substring(prefixEnd))) {
// a file pattern
return findPathMatchingResources(locationPattern);
}
else {
// a single resource with the given name
return new Resource[] {getResourceLoader().getResource(locationPattern)};
}
}
}
/**
* 通过 Ant 风格的路径匹配器查找所有匹配资源
*/
protected Resource[] findPathMatchingResources(String locationPattern) throws IOException {
// 确定给定位置的根目录：classpath*:org/zxd/spring5/
final String rootDirPath = determineRootDir(locationPattern);
// 截取模糊匹配路径：**/*.class
final String subPattern = locationPattern.substring(rootDirPath.length());
// 读取根路径 Resource
final Resource[] rootDirResources = getResources(rootDirPath);
final Set<Resource> result = new LinkedHashSet<>(16);
// 遍历所有根路径
for (Resource rootDirResource : rootDirResources) {
rootDirResource = resolveRootDirResource(rootDirResource);
// 获取根路径 URL
URL rootDirUrl = rootDirResource.getURL();
// 1）URL 协议以 bundle 开头
if (equinoxResolveMethod != null && rootDirUrl.getProtocol().startsWith("bundle")) {
final URL resolvedUrl = (URL) ReflectionUtils.invokeMethod(equinoxResolveMethod, null, rootDirUrl);
if (resolvedUrl != null) {
rootDirUrl = resolvedUrl;
}
rootDirResource = new UrlResource(rootDirUrl);
}
// 2）URL 协议以 vfs 开头
if (rootDirUrl.getProtocol().startsWith(ResourceUtils.URL_PROTOCOL_VFS)) {
result.addAll(VfsResourceMatchingDelegate.findMatchingResources(rootDirUrl, subPattern, getPathMatcher()));
}
// 3）URL 是一个 jar：jar、war、zip、vfszip、wsjar
else if (ResourceUtils.isJarURL(rootDirUrl) || isJarResource(rootDirResource)) {
result.addAll(doFindPathMatchingJarResources(rootDirResource, rootDirUrl, subPattern));
}
else {
// 4）URL 协议以 file 开头
result.addAll(doFindPathMatchingFileResources(rootDirResource, subPattern));
}
}
if (logger.isTraceEnabled()) {
logger.trace("Resolved location pattern [" + locationPattern + "] to resources " + result);
}
return result.toArray(new Resource[0]);
}
protected Resource[] findAllClassPathResources(String location) throws IOException {
String path = location;
if (path.startsWith("/")) {
path = path.substring(1);
}
// 读取所有的 ClassPathResource
final Set<Resource> result = doFindAllClassPathResources(path);
if (logger.isTraceEnabled()) {
logger.trace("Resolved classpath location [" + location + "] to resources " + result);
}
return result.toArray(new Resource[0]);
}
protected Set<Resource> doFindAllClassPathResources(String path) throws IOException {
final Set<Resource> result = new LinkedHashSet<>(16);
// 读取类加载器
final ClassLoader cl = getClassLoader();
// 读取指定包路径【org/zxd/spring5/】下所有资源的 URL
final Enumeration<URL> resourceUrls = cl != null ? cl.getResources(path) : ClassLoader.getSystemResources(path);
while (resourceUrls.hasMoreElements()) {
final URL url = resourceUrls.nextElement();
result.add(convertClassLoaderURL(url));
}
if ("".equals(path)) {
// The above result is likely to be incomplete, i.e. only containing file system references.
// We need to have pointers to each of the jar files on the classpath as well...
addAllClassLoaderJarRoots(cl, result);
}
return result;
}
/**
* 将 URL 转换为 UrlResource
*/
protected Resource convertClassLoaderURL(URL url) {
return new UrlResource(url);
}
3.3.1.1.3.8 ConfigurationClassBeanDefinitionReader
配置类 BeanDefinition 读取器
/**
* 从一组完整的 ConfigurationClass 类中解析 BeanDefinition
* 并将其注册到 BeanDefinitionRegistry 中。
*/
class ConfigurationClassBeanDefinitionReader {
private static final Log logger = LogFactory.getLog(ConfigurationClassBeanDefinitionReader.class);
private static final ScopeMetadataResolver scopeMetadataResolver = new AnnotationScopeMetadataResolver();
private final BeanDefinitionRegistry registry;
private final SourceExtractor sourceExtractor;
private final ResourceLoader resourceLoader;
private final Environment environment;
private final BeanNameGenerator importBeanNameGenerator;
private final ImportRegistry importRegistry;
private final ConditionEvaluator conditionEvaluator;
/**
* Create a new {@link ConfigurationClassBeanDefinitionReader} instance
* that will be used to populate the given {@link BeanDefinitionRegistry}.
*/
ConfigurationClassBeanDefinitionReader(BeanDefinitionRegistry registry, SourceExtractor sourceExtractor,
ResourceLoader resourceLoader, Environment environment, BeanNameGenerator importBeanNameGenerator,
ImportRegistry importRegistry) {
registry = registry;
sourceExtractor = sourceExtractor;
resourceLoader = resourceLoader;
environment = environment;
importBeanNameGenerator = importBeanNameGenerator;
importRegistry = importRegistry;
conditionEvaluator = new ConditionEvaluator(registry, environment, resourceLoader);
}
/**
* 从已解析的 ConfigurationClass 中读取 BeanDefinition
*/
public void loadBeanDefinitions(Set<ConfigurationClass> configurationModel) {
TrackedConditionEvaluator trackedConditionEvaluator = new TrackedConditionEvaluator();
for (ConfigurationClass configClass : configurationModel) {
loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);
}
}
/**
* 读取一个特定的 ConfigurationClass 并注册 BeanDefinition
*/
private void loadBeanDefinitionsForConfigurationClass(
ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {
// 是否需要忽略此配置类
if (trackedConditionEvaluator.shouldSkip(configClass)) {
String beanName = configClass.getBeanName();
// 将其从 BeanDefinitionRegistry 中移除
if (StringUtils.hasLength(beanName) && registry.containsBeanDefinition(beanName)) {
registry.removeBeanDefinition(beanName);
}
// 将此类从 importRegistry 中移除
importRegistry.removeImportingClass(configClass.getMetadata().getClassName());
return;
}
// 1）此配置类是通过 @Import 导入的
if (configClass.isImported()) {
registerBeanDefinitionForImportedConfigurationClass(configClass);
}
// 2）处理所有通过 @Bean 注解的方法
for (BeanMethod beanMethod : configClass.getBeanMethods()) {
loadBeanDefinitionsForBeanMethod(beanMethod);
}
// 解析通过 @ImportResource 导入的配置文件
loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
// 解析通过 @Import 导入的 ImportBeanDefinitionRegistrar
loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
}
/**
* 将配置类本身注册到 BeanDefinitionRegistry 中
*/
private void registerBeanDefinitionForImportedConfigurationClass(ConfigurationClass configClass) {
AnnotationMetadata metadata = configClass.getMetadata();
AnnotatedGenericBeanDefinition configBeanDef = new AnnotatedGenericBeanDefinition(metadata);
ScopeMetadata scopeMetadata = scopeMetadataResolver.resolveScopeMetadata(configBeanDef);
configBeanDef.setScope(scopeMetadata.getScopeName());
String configBeanName = importBeanNameGenerator.generateBeanName(configBeanDef, registry);
AnnotationConfigUtils.processCommonDefinitionAnnotations(configBeanDef, metadata);
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(configBeanDef, configBeanName);
definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, registry);
registry.registerBeanDefinition(definitionHolder.getBeanName(), definitionHolder.getBeanDefinition());
configClass.setBeanName(configBeanName);
if (logger.isTraceEnabled()) {
logger.trace("Registered bean definition for imported class '" + configBeanName + "'");
}
}
@SuppressWarnings("deprecation") // for RequiredAnnotationBeanPostProcessor.SKIP_REQUIRED_CHECK_ATTRIBUTE
private void loadBeanDefinitionsForBeanMethod(BeanMethod beanMethod) {
ConfigurationClass configClass = beanMethod.getConfigurationClass();
MethodMetadata metadata = beanMethod.getMetadata();
// 读取方法名称
String methodName = metadata.getMethodName();
// 此 Bean 是否已经被忽略
if (configClass.skippedBeanMethods.contains(methodName)) {
return;
}
// 此 Bean 是否需要忽略
if (conditionEvaluator.shouldSkip(metadata, ConfigurationPhase.REGISTER_BEAN)) {
configClass.skippedBeanMethods.add(methodName);
return;
}
// 读取 @Bean 注解的属性
AnnotationAttributes bean = AnnotationConfigUtils.attributesFor(metadata, Bean.class);
Assert.state(bean != null, "No @Bean annotation attributes");
// 读取 bean 名称
List<String> names = new ArrayList<>(Arrays.asList(bean.getStringArray("name")));
// 如果配置了 bean 名称，则获取第一个；否则以方法名称作为 bean 的名称
String beanName = !names.isEmpty() ? names.remove(0) : methodName;
// 尝试注册别名
for (String alias : names) {
registry.registerAlias(beanName, alias);
}
// Has this effectively been overridden before (e.g. via XML)?
if (isOverriddenByExistingDefinition(beanMethod, beanName)) {
if (beanName.equals(beanMethod.getConfigurationClass().getBeanName())) {
throw new BeanDefinitionStoreException(beanMethod.getConfigurationClass().getResource().getDescription(),
beanName, "Bean name derived from @Bean method '" + beanMethod.getMetadata().getMethodName() +
"' clashes with bean name for containing configuration class; please make those names unique!");
}
return;
}
// 创建 ConfigurationClassBeanDefinition
ConfigurationClassBeanDefinition beanDef = new ConfigurationClassBeanDefinition(configClass, metadata);
beanDef.setResource(configClass.getResource());
beanDef.setSource(sourceExtractor.extractSource(metadata, configClass.getResource()));
// @Bean 标注的方法是静态方法
if (metadata.isStatic()) {
// static @Bean method
beanDef.setBeanClassName(configClass.getMetadata().getClassName());
beanDef.setFactoryMethodName(methodName);
}
// @Bean 标注的方法是实例方法
else {
// instance @Bean method
beanDef.setFactoryBeanName(configClass.getBeanName());
beanDef.setUniqueFactoryMethodName(methodName);
}
// 配置属性
beanDef.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_CONSTRUCTOR);
beanDef.setAttribute(org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor.
SKIP_REQUIRED_CHECK_ATTRIBUTE, Boolean.TRUE);
// 处理通用 BeanDefinition 注解
AnnotationConfigUtils.processCommonDefinitionAnnotations(beanDef, metadata);
// 写入 Autowire
Autowire autowire = bean.getEnum("autowire");
if (autowire.isAutowire()) {
beanDef.setAutowireMode(autowire.value());
}
// 写入 AutowireCandidate
boolean autowireCandidate = bean.getBoolean("autowireCandidate");
if (!autowireCandidate) {
beanDef.setAutowireCandidate(false);
}
// 写入初始化方法
String initMethodName = bean.getString("initMethod");
if (StringUtils.hasText(initMethodName)) {
beanDef.setInitMethodName(initMethodName);
}
// 写入销毁方法
String destroyMethodName = bean.getString("destroyMethod");
beanDef.setDestroyMethodName(destroyMethodName);
// Consider scoping
ScopedProxyMode proxyMode = ScopedProxyMode.NO;
AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(metadata, Scope.class);
if (attributes != null) {
beanDef.setScope(attributes.getString("value"));
proxyMode = attributes.getEnum("proxyMode");
if (proxyMode == ScopedProxyMode.DEFAULT) {
proxyMode = ScopedProxyMode.NO;
}
}
// Replace the original bean definition with the target one, if necessary
BeanDefinition beanDefToRegister = beanDef;
if (proxyMode != ScopedProxyMode.NO) {
BeanDefinitionHolder proxyDef = ScopedProxyCreator.createScopedProxy(
new BeanDefinitionHolder(beanDef, beanName), registry,
proxyMode == ScopedProxyMode.TARGET_CLASS);
beanDefToRegister = new ConfigurationClassBeanDefinition(
(RootBeanDefinition) proxyDef.getBeanDefinition(), configClass, metadata);
}
if (logger.isTraceEnabled()) {
logger.trace(String.format("Registering bean definition for @Bean method %s.%s()",
configClass.getMetadata().getClassName(), beanName));
}
// 注册此 BeanDefinition
registry.registerBeanDefinition(beanName, beanDefToRegister);
}
protected boolean isOverriddenByExistingDefinition(BeanMethod beanMethod, String beanName) {
if (!registry.containsBeanDefinition(beanName)) {
return false;
}
BeanDefinition existingBeanDef = registry.getBeanDefinition(beanName);
// Is the existing bean definition one that was created from a configuration class?
// -> allow the current bean method to override, since both are at second-pass level.
// However, if the bean method is an overloaded case on the same configuration class,
// preserve the existing bean definition.
if (existingBeanDef instanceof ConfigurationClassBeanDefinition) {
ConfigurationClassBeanDefinition ccbd = (ConfigurationClassBeanDefinition) existingBeanDef;
return ccbd.getMetadata().getClassName().equals(
beanMethod.getConfigurationClass().getMetadata().getClassName());
}
// A bean definition resulting from a component scan can be silently overridden
// by an @Bean method, as of 4.2...
if (existingBeanDef instanceof ScannedGenericBeanDefinition) {
return false;
}
// Has the existing bean definition bean marked as a framework-generated bean?
// -> allow the current bean method to override it, since it is application-level
if (existingBeanDef.getRole() > BeanDefinition.ROLE_APPLICATION) {
return false;
}
// At this point, it's a top-level override (probably XML), just having been parsed
// before configuration class processing kicks in...
if (registry instanceof DefaultListableBeanFactory &&
!((DefaultListableBeanFactory) registry).isAllowBeanDefinitionOverriding()) {
throw new BeanDefinitionStoreException(beanMethod.getConfigurationClass().getResource().getDescription(),
beanName, "@Bean definition illegally overridden by existing bean definition: " + existingBeanDef);
}
if (logger.isDebugEnabled()) {
logger.debug(String.format("Skipping bean definition for %s: a definition for bean '%s' " +
"already exists. This top-level bean definition is considered as an override.",
beanMethod, beanName));
}
return true;
}
private void loadBeanDefinitionsFromImportedResources(
Map<String, Class<? extends BeanDefinitionReader>> importedResources) {
Map<Class<?>, BeanDefinitionReader> readerInstanceCache = new HashMap<>();
importedResources.forEach((resource, readerClass) -> {
// 使用默认的 BeanDefinitionReader
if (BeanDefinitionReader.class == readerClass) {
// 目标资源以 .groovy 结尾，则使用 GroovyBeanDefinitionReader 进行读取
if (StringUtils.endsWithIgnoreCase(resource, ".groovy")) {
// When clearly asking for Groovy, that's what they'll get...
readerClass = GroovyBeanDefinitionReader.class;
}
else {
// 否则使用 XmlBeanDefinitionReader 进行读取
readerClass = XmlBeanDefinitionReader.class;
}
}
// 读取缓存的 BeanDefinitionReader
BeanDefinitionReader reader = readerInstanceCache.get(readerClass);
if (reader == null) {
try {
// 实例化特定的 BeanDefinitionReader
reader = readerClass.getConstructor(BeanDefinitionRegistry.class).newInstance(registry);
// Delegate the current ResourceLoader to it if possible
if (reader instanceof AbstractBeanDefinitionReader) {
AbstractBeanDefinitionReader abdr = (AbstractBeanDefinitionReader) reader;
abdr.setResourceLoader(resourceLoader);
abdr.setEnvironment(environment);
}
readerInstanceCache.put(readerClass, reader);
}
catch (Throwable ex) {
throw new IllegalStateException(
"Could not instantiate BeanDefinitionReader class [" + readerClass.getName() + "]");
}
}
// 使用 BeanDefinitionReader 读取 BeanDefinition
// TODO SPR-6310: qualify relative path locations as done in AbstractContextLoader.modifyLocations
reader.loadBeanDefinitions(resource);
});
}
/**
* 通过 ImportBeanDefinitionRegistrar 注册 BeanDefinition
*/
private void loadBeanDefinitionsFromRegistrars(Map<ImportBeanDefinitionRegistrar, AnnotationMetadata> registrars) {
registrars.forEach((registrar, metadata) ->
registrar.registerBeanDefinitions(metadata, registry));
}
@SuppressWarnings("serial")
private static class ConfigurationClassBeanDefinition extends RootBeanDefinition implements AnnotatedBeanDefinition {
/**
* 注解元数据
*/
private final AnnotationMetadata annotationMetadata;
/**
* 方法元数据
*/
private final MethodMetadata factoryMethodMetadata;
public ConfigurationClassBeanDefinition(ConfigurationClass configClass, MethodMetadata beanMethodMetadata) {
annotationMetadata = configClass.getMetadata();
factoryMethodMetadata = beanMethodMetadata;
setLenientConstructorResolution(false);
}
public ConfigurationClassBeanDefinition(
RootBeanDefinition original, ConfigurationClass configClass, MethodMetadata beanMethodMetadata) {
super(original);
annotationMetadata = configClass.getMetadata();
factoryMethodMetadata = beanMethodMetadata;
}
private ConfigurationClassBeanDefinition(ConfigurationClassBeanDefinition original) {
super(original);
annotationMetadata = original.annotationMetadata;
factoryMethodMetadata = original.factoryMethodMetadata;
}
@Override
public AnnotationMetadata getMetadata() {
return annotationMetadata;
}
@Override
public MethodMetadata getFactoryMethodMetadata() {
return factoryMethodMetadata;
}
@Override
public boolean isFactoryMethod(Method candidate) {
return super.isFactoryMethod(candidate) && BeanAnnotationHelper.isBeanAnnotated(candidate);
}
@Override
public ConfigurationClassBeanDefinition cloneBeanDefinition() {
return new ConfigurationClassBeanDefinition(this);
}
}
private class TrackedConditionEvaluator {
private final Map<ConfigurationClass, Boolean> skipped = new HashMap<>();
public boolean shouldSkip(ConfigurationClass configClass) {
Boolean skip = skipped.get(configClass);
if (skip == null) {
if (configClass.isImported()) {
boolean allSkipped = true;
for (ConfigurationClass importedBy : configClass.getImportedBy()) {
if (!shouldSkip(importedBy)) {
allSkipped = false;
break;
}
}
if (allSkipped) {
// The config classes that imported this one were all skipped, therefore we are skipped...
skip = true;
}
}
if (skip == null) {
skip = conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN);
}
skipped.put(configClass, skip);
}
return skip;
}
}
}
3.3.1.1.4 处理所有的 @Import 注解
private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
Collection<SourceClass> importCandidates, boolean checkForCircularImports) {
// 如果配置类上没有任何候选@Import（importCandidates），
//说明没有需要处理的导入，则什么都不用做，直接返回
if (importCandidates.isEmpty()) {
return;
}
// 进行循环依赖的检查
if (checkForCircularImports && isChainedImportOnStack(configClass)) {
// 如果要求做循环导入检查，并且检查到了循环依赖，报告这个问题
this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
}
else {
// 开始处理配置类configClass上所有的@Import importCandidates
this.importStack.push(configClass);
try {
// 循环处理每一个@Import,每个@Import可能导入三种类型的类 :
// 1. ImportSelector
// 2. ImportBeanDefinitionRegistrar
// 3. 其他类型，都当作配置类处理，也就是相当于使用了注解@Configuration的配置类
// 下面的for循环中对这三种情况执行了不同的处理逻辑
for (SourceClass candidate : importCandidates) {
// 目标类是 ImportSelector 实例
if (candidate.isAssignable(ImportSelector.class)) {
Class<?> candidateClass = candidate.loadClass();
// 创建目标实例
ImportSelector selector = BeanUtils.instantiateClass(candidateClass, ImportSelector.class);
// 执行 BeanClassLoaderAware、BeanFactoryAware、EnvironmentAware、ResourceLoaderAware 注入
ParserStrategyUtils.invokeAwareMethods(
selector, this.environment, this.resourceLoader, this.registry);
// 如果这个类也是DeferredImportSelector接口的实现类，
// 那么加入ConfigurationClassParser的deferredImportSelectors
if (this.deferredImportSelectors != null && selector instanceof DeferredImportSelector) {
this.deferredImportSelectors.add(
new DeferredImportSelectorHolder(configClass, (DeferredImportSelector) selector));
}
else {//如果不是,则调用processImports 进行处理.
// 获取所有配置类名称
String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
// 获取所有配置类名称
Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames);
// 递归处理所有导入的配置类
processImports(configClass, currentSourceClass, importSourceClasses, false);
}
}
// 如果这个类是ImportBeanDefinitionRegistrar接口的实现类
// 设置到配置类的importBeanDefinitionRegistrars属性中
else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
Class<?> candidateClass = candidate.loadClass();
// 实例化 ImportBeanDefinitionRegistrar
ImportBeanDefinitionRegistrar registrar =
BeanUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class);
// 执行 Aware 注入
ParserStrategyUtils.invokeAwareMethods(
registrar, this.environment, this.resourceLoader, this.registry);
// 写入 importBeanDefinitionRegistrars 缓存
configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
}
else {
//配置类不是 ImportSelector or ImportBeanDefinitionRegistrar，
//则加入到importStack后调用processConfigurationClass 进行处理.
// 其它情况下把这个类入队到ConfigurationClassParser的importStack(队列)属性中
// 然后把这个类当成是@Configuration注解修饰的类递归重头开始解析这个类
this.importStack.registerImport(
currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
processConfigurationClass(candidate.asConfigClass(configClass));
}
}
}
catch (BeanDefinitionStoreException ex) {
throw ex;
}
catch (Throwable ex) {
throw new BeanDefinitionStoreException(
"Failed to process import candidates for configuration class [" +
configClass.getMetadata().getClassName() + "]", ex);
}
finally {
this.importStack.pop();
}
}
}
3.3.1.1.5 processInterfaces
/**
* 解析接口上的方法，如果此方法存在 @Bean 注解
*/
private void processInterfaces(ConfigurationClass configClass, SourceClass sourceClass) throws IOException {
for (final SourceClass ifc : sourceClass.getInterfaces()) {
final Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(ifc);
for (final MethodMetadata methodMetadata : beanMethods) {
if (!methodMetadata.isAbstract()) {
// A default method or other concrete method on a Java 8+ interface...
configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
}
}
processInterfaces(configClass, ifc);
}
}
3.3.1.2 ConditionEvaluator条件评估
用于计算 @Conditional 注解的内部类
class ConditionEvaluator {
private final ConditionContextImpl context;
public ConditionEvaluator(@Nullable BeanDefinitionRegistry registry,
@Nullable Environment environment, @Nullable ResourceLoader resourceLoader) {
context = new ConditionContextImpl(registry, environment, resourceLoader);
}
/**
* 指定类或方法上是否存在 @Conditional 注解，并需要跳过处理流程
*/
public boolean shouldSkip(AnnotatedTypeMetadata metadata) {
return shouldSkip(metadata, null);
}
public boolean shouldSkip(@Nullable AnnotatedTypeMetadata metadata, @Nullable ConfigurationPhase phase) {
// 注解元数据为空 || 目标元素不存在 @Conditional 注解，不跳过
if (metadata == null || !metadata.isAnnotated(Conditional.class.getName())) {
return false;
}
if (phase == null) {
if (metadata instanceof AnnotationMetadata &&
ConfigurationClassUtils.isConfigurationCandidate((AnnotationMetadata) metadata)) {
return shouldSkip(metadata, ConfigurationPhase.PARSE_CONFIGURATION);
}
return shouldSkip(metadata, ConfigurationPhase.REGISTER_BEAN);
}
final List<Condition> conditions = new ArrayList<>();
// 读取所有的条件类
for (final String[] conditionClasses : getConditionClasses(metadata)) {
for (final String conditionClass : conditionClasses) {
final Condition condition = getCondition(conditionClass, context.getClassLoader());
conditions.add(condition);
}
}
// 根据 Order 进行排序
AnnotationAwareOrderComparator.sort(conditions);
for (final Condition condition : conditions) {
ConfigurationPhase requiredPhase = null;
if (condition instanceof ConfigurationCondition) {
requiredPhase = ((ConfigurationCondition) condition).getConfigurationPhase();
}
// 请求阶段为空或请求阶段==此阶段 && 此条件不匹配
if ((requiredPhase == null || requiredPhase == phase) && !condition.matches(context, metadata)) {
return true;
}
}
// 所有的条件都匹配
return false;
}
@SuppressWarnings("unchecked")
private List<String[]> getConditionClasses(AnnotatedTypeMetadata metadata) {
// 读取所有 @Conditional 注解的属性配置
final MultiValueMap<String, Object> attributes = metadata.getAllAnnotationAttributes(Conditional.class.getName(), true);
// 读取评估条件
final Object values = attributes != null ? attributes.get("value") : null;
return (List<String[]>) (values != null ? values : Collections.emptyList());
}
/**
* 实例化目标条件
*/
private Condition getCondition(String conditionClassName, @Nullable ClassLoader classloader) {
final Class<?> conditionClass = ClassUtils.resolveClassName(conditionClassName, classloader);
return (Condition) BeanUtils.instantiateClass(conditionClass);
}
private static class ConditionContextImpl implements ConditionContext {
@Nullable
private final BeanDefinitionRegistry registry;
@Nullable
private final ConfigurableListableBeanFactory beanFactory;
private final Environment environment;
private final ResourceLoader resourceLoader;
@Nullable
private final ClassLoader classLoader;
public ConditionContextImpl(@Nullable BeanDefinitionRegistry registry,
@Nullable Environment environment, @Nullable ResourceLoader resourceLoader) {
this.registry = registry;
beanFactory = deduceBeanFactory(registry);
this.environment = environment != null ? environment : deduceEnvironment(registry);
this.resourceLoader = resourceLoader != null ? resourceLoader : deduceResourceLoader(registry);
classLoader = deduceClassLoader(resourceLoader, beanFactory);
}
@Nullable
private ConfigurableListableBeanFactory deduceBeanFactory(@Nullable BeanDefinitionRegistry source) {
if (source instanceof ConfigurableListableBeanFactory) {
return (ConfigurableListableBeanFactory) source;
}
if (source instanceof ConfigurableApplicationContext) {
return ((ConfigurableApplicationContext) source).getBeanFactory();
}
return null;
}
/**
* 推断 Environment
*/
private Environment deduceEnvironment(@Nullable BeanDefinitionRegistry source) {
if (source instanceof EnvironmentCapable) {
return ((EnvironmentCapable) source).getEnvironment();
}
return new StandardEnvironment();
}
/**
* 推断 ResourceLoader
*/
private ResourceLoader deduceResourceLoader(@Nullable BeanDefinitionRegistry source) {
if (source instanceof ResourceLoader) {
return (ResourceLoader) source;
}
return new DefaultResourceLoader();
}
/**
* 推断 ClassLoader
*/
@Nullable
private ClassLoader deduceClassLoader(@Nullable ResourceLoader resourceLoader,
@Nullable ConfigurableListableBeanFactory beanFactory) {
if (resourceLoader != null) {
final ClassLoader classLoader = resourceLoader.getClassLoader();
if (classLoader != null) {
return classLoader;
}
}
if (beanFactory != null) {
return beanFactory.getBeanClassLoader();
}
return ClassUtils.getDefaultClassLoader();
}
@Override
public BeanDefinitionRegistry getRegistry() {
Assert.state(registry != null, "No BeanDefinitionRegistry available");
return registry;
}
@Override
@Nullable
public ConfigurableListableBeanFactory getBeanFactory() {
return beanFactory;
}
@Override
public Environment getEnvironment() {
return environment;
}
@Override
public ResourceLoader getResourceLoader() {
return resourceLoader;
}
@Override
@Nullable
public ClassLoader getClassLoader() {
return classLoader;
}
}
}
3.3.1.3 ConfigurationClass配置类
ConfigurationClass代表一个配置类，它内部维护了一些已经解析好的但是还没有被加入进Bean定义信息的原始信息，有必要做如下解释：
//它是普通的类，基本只有get set方法
final class ConfigurationClass {
private final AnnotationMetadata metadata;
private final Resource resource;
@Nullable
private String beanName;
private final Set<ConfigurationClass> importedBy = new LinkedHashSet<>(1);
// 存储该配置类里所有标注@Bean注解的方法~~~~
private final Set<BeanMethod> beanMethods = new LinkedHashSet<>();
// 用Map保存着@ImportResource 导入进来的资源们~
private final Map<String, Class<? extends BeanDefinitionReader>> importedResources =
new LinkedHashMap<>();
// 用Map保存着@Import中实现了`ImportBeanDefinitionRegistrar`接口的内容~
private final Map<ImportBeanDefinitionRegistrar, AnnotationMetadata> importBeanDefinitionRegistrars =
new LinkedHashMap<>();
final Set<String> skippedBeanMethods = new HashSet<>();
}
3.3.1.4 ConditionalOnProperty
/**
* 此 Environment 中是否存在指定的属性 && 属性具有存在特定值【如果指定】。
*/
@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.TYPE, ElementType.METHOD })
@Documented
@Conditional(OnPropertyCondition.class) // 通过 @Conditional 注解关联条件类
public @interface ConditionalOnProperty {
/**
* 属性的名称
*/
String[] value() default {};
/**
* 每个属性的前缀
*/
String prefix() default "";
/**
* 属性的名称
*/
String[] name() default {};
/**
* 属性值
*/
String havingValue() default "";
/**
* 如果 Environment 中不存在此属性，是否匹配【默认不匹配】
*/
boolean matchIfMissing() default false;
}
/**
* 组件被注册到 BeanDefinitionRegistry 时必须满足的条件
*/
@FunctionalInterface
public interface Condition {
/**
* 判断此条件是否满足
*/
boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata);
}
public abstract class SpringBootCondition implements Condition {
private final Log logger = LogFactory.getLog(getClass());
@Override
public final boolean matches(ConditionContext context,
AnnotatedTypeMetadata metadata) {
// 读取类名或方法名称
String classOrMethodName = getClassOrMethodName(metadata);
try {
// 读取条件的输出结果
ConditionOutcome outcome = getMatchOutcome(context, metadata);
// 记录日志
logOutcome(classOrMethodName, outcome);
// 记录评估结果
recordEvaluation(context, classOrMethodName, outcome);
// 此条件是否满足
return outcome.isMatch();
}
catch (NoClassDefFoundError ex) {
throw new IllegalStateException(
"Could not evaluate condition on " + classOrMethodName + " due to "
+ ex.getMessage() + " not "
+ "found. Make sure your own configuration does not rely on "
+ "that class. This can also happen if you are "
+ "@ComponentScanning a springframework package (e.g. if you "
+ "put a @ComponentScan in the default package by mistake)",
ex);
}
catch (RuntimeException ex) {
throw new IllegalStateException(
"Error processing condition on " + getName(metadata), ex);
}
}
private String getName(AnnotatedTypeMetadata metadata) {
if (metadata instanceof AnnotationMetadata) {
return ((AnnotationMetadata) metadata).getClassName();
}
if (metadata instanceof MethodMetadata) {
MethodMetadata methodMetadata = (MethodMetadata) metadata;
return methodMetadata.getDeclaringClassName() + "."
+ methodMetadata.getMethodName();
}
return metadata.toString();
}
private static String getClassOrMethodName(AnnotatedTypeMetadata metadata) {
if (metadata instanceof ClassMetadata) {
ClassMetadata classMetadata = (ClassMetadata) metadata;
return classMetadata.getClassName();
}
MethodMetadata methodMetadata = (MethodMetadata) metadata;
return methodMetadata.getDeclaringClassName() + "#"
+ methodMetadata.getMethodName();
}
protected final void logOutcome(String classOrMethodName, ConditionOutcome outcome) {
if (this.logger.isTraceEnabled()) {
this.logger.trace(getLogMessage(classOrMethodName, outcome));
}
}
private StringBuilder getLogMessage(String classOrMethodName,
ConditionOutcome outcome) {
StringBuilder message = new StringBuilder();
message.append("Condition ");
message.append(ClassUtils.getShortName(getClass()));
message.append(" on ");
message.append(classOrMethodName);
message.append(outcome.isMatch() ? " matched" : " did not match");
if (StringUtils.hasLength(outcome.getMessage())) {
message.append(" due to ");
message.append(outcome.getMessage());
}
return message;
}
private void recordEvaluation(ConditionContext context, String classOrMethodName,
ConditionOutcome outcome) {
if (context.getBeanFactory() != null) {
ConditionEvaluationReport.get(context.getBeanFactory())
.recordConditionEvaluation(classOrMethodName, this, outcome);
}
}
/**
* 确定匹配结果
*/
public abstract ConditionOutcome getMatchOutcome(ConditionContext context,
AnnotatedTypeMetadata metadata);
/**
* 只要有一个条件满足
*/
protected final boolean anyMatches(ConditionContext context,
AnnotatedTypeMetadata metadata, Condition... conditions) {
for (Condition condition : conditions) {
if (matches(context, metadata, condition)) {
return true;
}
}
return false;
}
/**
* 指定的条件是否满足
*/
protected final boolean matches(ConditionContext context,
AnnotatedTypeMetadata metadata, Condition condition) {
if (condition instanceof SpringBootCondition) {
return ((SpringBootCondition) condition).getMatchOutcome(context, metadata)
.isMatch();
}
return condition.matches(context, metadata);
}
}
/**
* 指定的属性是否定义在此 Environment 中
*/
@Order(Ordered.HIGHEST_PRECEDENCE + 40)
class OnPropertyCondition extends SpringBootCondition {
@Override
public ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata metadata) {
// 读取目标元素上所有的 @ConditionalOnProperty 注解的属性信息
final List<AnnotationAttributes> allAnnotationAttributes = annotationAttributesFromMultiValueMap(
metadata.getAllAnnotationAttributes(ConditionalOnProperty.class.getName()));
final List<ConditionMessage> noMatch = new ArrayList<>();
final List<ConditionMessage> match = new ArrayList<>();
for (final AnnotationAttributes annotationAttributes : allAnnotationAttributes) {
// 确定当前 ConditionalOnProperty 条件的输出结果
final ConditionOutcome outcome = determineOutcome(annotationAttributes, context.getEnvironment());
// 记录 ConditionMessage
(outcome.isMatch() ? match : noMatch).add(outcome.getConditionMessage());
}
// 存在一个不匹配条件
if (!noMatch.isEmpty()) {
return ConditionOutcome.noMatch(ConditionMessage.of(noMatch));
}
// 所有的条件都匹配
return ConditionOutcome.match(ConditionMessage.of(match));
}
private List<AnnotationAttributes> annotationAttributesFromMultiValueMap(
MultiValueMap<String, Object> multiValueMap) {
final List<Map<String, Object>> maps = new ArrayList<>();
multiValueMap.forEach((key, value) -> {
for (int i = 0; i < value.size(); i++) {
Map<String, Object> map;
if (i < maps.size()) {
map = maps.get(i);
} else {
map = new HashMap<>();
maps.add(map);
}
map.put(key, value.get(i));
}
});
final List<AnnotationAttributes> annotationAttributes = new ArrayList<>(maps.size());
for (final Map<String, Object> map : maps) {
annotationAttributes.add(AnnotationAttributes.fromMap(map));
}
return annotationAttributes;
}
private ConditionOutcome determineOutcome(AnnotationAttributes annotationAttributes, PropertyResolver resolver) {
final Spec spec = new Spec(annotationAttributes);
final List<String> missingProperties = new ArrayList<>();
final List<String> nonMatchingProperties = new ArrayList<>();
spec.collectProperties(resolver, missingProperties, nonMatchingProperties);
// 1）属性值不存在
if (!missingProperties.isEmpty()) {
return ConditionOutcome.noMatch(ConditionMessage.forCondition(ConditionalOnProperty.class, spec)
.didNotFind("property", "properties").items(Style.QUOTE, missingProperties));
}
// 2）属性值存在，但是不匹配
if (!nonMatchingProperties.isEmpty()) {
return ConditionOutcome.noMatch(ConditionMessage.forCondition(ConditionalOnProperty.class, spec)
.found("different value in property", "different value in properties")
.items(Style.QUOTE, nonMatchingProperties));
}
// 此 ConditionalOnProperty 条件匹配
return ConditionOutcome
.match(ConditionMessage.forCondition(ConditionalOnProperty.class, spec).because("matched"));
}
private static class Spec {
private final String prefix;
private final String havingValue;
private final String[] names;
private final boolean matchIfMissing;
Spec(AnnotationAttributes annotationAttributes) {
// 读取 ConditionalOnProperty 注解的 prefix 属性
String prefix = annotationAttributes.getString("prefix").trim();
// prefix 不为空，则尝试添加 . 后缀
if (StringUtils.hasText(prefix) && !prefix.endsWith(".")) {
prefix = prefix + ".";
}
this.prefix = prefix;
// 读取 ConditionalOnProperty 注解的 havingValue 属性
havingValue = annotationAttributes.getString("havingValue");
// 读取 ConditionalOnProperty 注解的关联属性名称
names = getNames(annotationAttributes);
// 读取 ConditionalOnProperty 注解的 matchIfMissing 属性
matchIfMissing = annotationAttributes.getBoolean("matchIfMissing");
}
private String[] getNames(Map<String, Object> annotationAttributes) {
final String[] value = (String[]) annotationAttributes.get("value");
final String[] name = (String[]) annotationAttributes.get("name");
Assert.state(value.length > 0 || name.length > 0,
"The name or value attribute of @ConditionalOnProperty must be specified");
Assert.state(value.length == 0 || name.length == 0,
"The name and value attributes of @ConditionalOnProperty are exclusive");
// value 属性的优先级高于 name
return value.length > 0 ? value : name;
}
private void collectProperties(PropertyResolver resolver, List<String> missing, List<String> nonMatching) {
// 遍历所有的属性名称
for (final String name : names) {
// 添加前缀
final String key = prefix + name;
// 1）如果 Environment 中存在此属性
if (resolver.containsProperty(key)) {
// 指定的值不匹配，则写入 nonMatching 中
if (!isMatch(resolver.getProperty(key), havingValue)) {
nonMatching.add(name);
}
// 2）Environment 中不存在此属性
} else {
// 如果不能忽略此属性，则写入 missing 中
if (!matchIfMissing) {
missing.add(name);
}
}
}
}
private boolean isMatch(String value, String requiredValue) {
// 1）指定了必须的值，则使用 equals 进行比较
if (StringUtils.hasLength(requiredValue)) {
return requiredValue.equalsIgnoreCase(value);
}
// 只要属性值不是忽略大小写的 false，就匹配
return !"false".equalsIgnoreCase(value);
}
@Override
public String toString() {
final StringBuilder result = new StringBuilder();
result.append("(");
result.append(prefix);
if (names.length == 1) {
result.append(names[0]);
} else {
result.append("[");
result.append(StringUtils.arrayToCommaDelimitedString(names));
result.append("]");
}
if (StringUtils.hasLength(havingValue)) {
result.append("=").append(havingValue);
}
result.append(")");
return result.toString();
}
}
}
3.4 loadBeanDefinitions加载bean定义信息
ConfigurationClassBeanDefinitionReader.loadBeanDefinitions()方法的功能就是将之前解析出的configClasses配置类信息中所有配置相关的信息添加到spring的bean定义，主要是配置类中的@Bean注解方法，配置类@ImportResource和@Import(实现ImportBeanDefinitionRegistrar接口方式)的bean注册
ConfigurationClassBeanDefinitionReader.loadBeanDefinitions()方法 实现逻辑如下：
public void loadBeanDefinitions(Set<ConfigurationClass> configurationModel) {
TrackedConditionEvaluator trackedConditionEvaluator = new TrackedConditionEvaluator();
for (ConfigurationClass configClass : configurationModel) {
loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);
}
}
private void loadBeanDefinitionsForConfigurationClass(
ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {
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;
}
if (configClass.isImported()) {
registerBeanDefinitionForImportedConfigurationClass(configClass);
}
//将@Bean方法注册为bean
for (BeanMethod beanMethod : configClass.getBeanMethods()) {
loadBeanDefinitionsForBeanMethod(beanMethod);
}
//将configClass中中ImportResource指定的资源注册为bean
loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
//将configClass中ImportedRegistrar注册为bean
loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
}
处理逻辑理了一遍后，看一下ConfigurationClassPostProcessor处理器解析@configuration配置类主要过程：
1. Spring容器初始化时注册默认后置处理器ConfigurationClassPostProcessor
2. Spring容器初始化执行refresh()方法中调用ConfigurationClassPostProcessor
3. ConfigurationClassPostProcessor处理器借助ConfigurationClassParser完成配置类解析
4. ConfigurationClassParser配置内解析过程中完成嵌套的MemberClass、@PropertySource注解、@ComponentScan注解（扫描package下的所有Class并进行迭代解析，主要是@Component组件解析及注册）、@ImportResource、@Bean等处理
5. 完成@Bean注册， @ImportResource指定bean的注册以及@Import(实现ImportBeanDefinitionRegistrar接口方式)的bean注册
4 总结
扫描Bean的顺序（并不是Bean定义真正注册的顺序）：
- 内部配置类：–> 它里面还可以有普通配置类一模一样的功能，但优先级最高，最终会放在configurationClasses这个Map的第一位
- @PropertySource：这个和Bean定义没啥关系，属于Spring配置PropertySource的范畴。这个属性优先级相对较低
- @ComponentScan：这里扫描到的Bean定义， 就直接register注册了 。所以它的时机是非常早的。（另外：如果注册进去的Bean定义信息还是配置类，这里会继续parse()，所以最终能被扫描到的组件，最终都会当作一个配置类来处理，所以最终都会放进configurationClasses这个Map里面去）
-
@Import：相对复杂点，如下：
- 若是一个普通类（标注@Configuration与否都无所谓反正会当作一个配置类来处理，也会放进configurationClasses缓存进去）
- 实现了ImportSelector：递归最后都成为第一步的类。若实现的是DeferredImportSelector接口，它会放在deferredImportSelectors属性里先保存着，等着外部所有的configCandidates配置类全部解析完成后，统一processDeferredImportSelectors()，最终也是转为第一步的类。
- 实现了ImportBeanDefinitionRegistrar：放在ConfigurationClass.importBeanDefinitionRegistrars属性里保存着
- @ImportResource：一般用来导入xml文件。它是先放在ConfigurationClass.importedResources属性里放着
- @Bean：找到所有@Bean的方法，然后保存到ConfigurationClass.beanMethods属性里
- processInterfaces：处理该类实现的接口们的default方法（标注@Bean的有效）
- 处理父类：拿到父类，每个父类都是当作一个配置文件来处理。备注：!superclass.startsWith("java")全类名不以java打头，且没有被处理过(因为一个父类可以有N个子类，但只能被处理一次)
- return null：若全部处理完成后就返回null，停止递归。
由上可见，这九步中，唯独只有@ComponentScan扫描到的Bean这个时候的Bean定义信息是已经注册上去了的，其余的都还没有真正注册到注册中心。
注意：bean注册的先后顺序，将直接影响到Bean的覆盖（默认Map，后注册的覆盖先注册的，当然还和scope有关）
正文到此结束
- 本文标签： id ArrayList UTC XEN 源码 UI App Collections 总结 strace bean mmap LinkedList HashSet java classpath https 配置 CTO 实例 final http Service HashMap 缓存 spring 启动过程 struct map CEO URLs 参数 ask Property Collection 注册中心 cglib rmi 协议 ip expat 代码 Select BeanUtils entity BeanDefinition IO token Proxy 目录 ssl tomcat cat FIT Document list src 处理器 数据缓存 Lua 类加载器 logo root servlet description 管理 parse value lib message cache bug 静态方法 web db find IDE 遍历 key build 文章 ORM springboot equals 递归 zip tab tar 数据 解析 XML provider ACE ioc
- 版权声明： 本文为互联网转载文章，出处已在文章中说明(部分除外)。如果侵权，请联系本站长删除，谢谢。
- 本文海报： 生成海报一 生成海报二
热门推荐
相关文章
近期评论
-
666
-
文章和留言都翻到11页了 没有OOM
-
-
朋友，翻页到11页，及以后，会出现OOM，无法访问
-
-
-
-
版本号是多少，你可以下载哪个代码仓库，jdk选1.8 直接跑就行
-
-
Loading...
![[HBLOG]公众号](https://www.liuhaihua.cn/img/qrcode_gzh.jpg)
