@Conditional条件注解源码分析

已于 2023-09-04 21:27:29 修改
阅读量98 收藏 2
点赞数
文章标签： spring boot java spring 后端
于 2023-09-03 19:10:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38345773/article/details/132653973
版权

概念和使用规则

过滤-配置类生效的方式

@ConditionalOnClass ： 某个class位于类路径上，才会实例化这个Bean。
@ConditionalOnMissingClass ： classpath中不存在该类时起效
@ConditionalOnBean ： DI容器中存在该类型Bean时起效
@ConditionalOnMissingBean ： DI容器中不存在该类型Bean时起效
@ConditionalOnSingleCandidate ： DI容器中该类型Bean只有一个或@Primary的只有一个时起效
@ConditionalOnExpression ： SpEL表达式结果为true时
@ConditionalOnProperty ： 参数设置或者值一致时起效
@ConditionalOnResource ： 指定的文件存在时起效
@ConditionalOnJndi ： 指定的JNDI存在时起效
@ConditionalOnJava ： 指定的Java版本存在时起效
@ConditionalOnWebApplication ： Web应用环境下起效
@ConditionalOnNotWebApplication ： 非Web应用环境下起效
=======
@Conditional ：自定义实现条件注入

uml类图

在这里插入图片描述

时序图说明

此图说明了 @ConditionalOnClass、@ConditionalOnBean等待在整个spring容器中校验的时机

在这里插入图片描述

如何自定义注入

如何基于@Conditional实现自定义注入呢

@Component
public class ConditionalTest {

    @Component
    @ConditionalOnClass(DataSource.class)
    @Conditional(ConfigurationTest.EmbeddedDatabaseCondition.class)
    protected static class EmbeddedDatabaseConfiguration {
    }
    static class EmbeddedDatabaseCondition extends SpringBootCondition {
        @Override
        public ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata metadata) {
           return new ConditionOutcome(true, (String) null);
        }
    }
}

源码分析

如上面自定义注入案例，在11行断点
…
堆栈直接定位到这里

shouldSkip

org.springframework.context.annotation.ConditionEvaluator#shouldSkip(org.springframework.core.type.AnnotatedTypeMetadata)

public boolean shouldSkip(AnnotatedTypeMetadata metadata) {
		return shouldSkip(metadata, null);
	}
public boolean shouldSkip(@Nullable AnnotatedTypeMetadata metadata, @Nullable ConfigurationPhase phase) {
    	// 判断是否包含@Conditional注解，像spring自带的注解@ConditionalOnClass等，都是@Conditional注解
		if (metadata == null || !metadata.isAnnotated(Conditional.class.getName())) {
			return false;
		}

        // 阶段给个默认值
		if (phase == null) {
            // 判断当前元数据是否包含 @Bean\@Compnent\@ComponentScan\@Import\@ImportResource  注解
			if (metadata instanceof AnnotationMetadata &&
					ConfigurationClassUtils.isConfigurationCandidate((AnnotationMetadata) metadata)) {
                // 给phase一个默认值PARSE_CONFIGURATION，再递归一下
				return shouldSkip(metadata, ConfigurationPhase.PARSE_CONFIGURATION);
			}
			return shouldSkip(metadata, ConfigurationPhase.REGISTER_BEAN);
		}

		List<Condition> conditions = new ArrayList<>();
   		// 解析当前bean上 所有的@Conditional注解的class（包含： @ConditionalOnClass、@ConditionalOnBean）
		for (String[] conditionClasses : getConditionClasses(metadata)) {
			for (String conditionClass : conditionClasses) {
                // 根据class实例化
				Condition condition = getCondition(conditionClass, this.context.getClassLoader());
				conditions.add(condition);
			}
		}

     	// 排序
		AnnotationAwareOrderComparator.sort(conditions);

		for (Condition condition : conditions) {
			ConfigurationPhase requiredPhase = null;
            // 根据上面类图可得只有 @OnBeanCondition 实现了 ConfigurationCondition
			if (condition instanceof ConfigurationCondition) {
				requiredPhase = ((ConfigurationCondition) condition).getConfigurationPhase();
			}
            /**
            条件1、
            	这里经过反复debug发现当前bean的元数据包含@ComponentScan注解时，
                phase才会=REGISTER_BEAN，
                其他情况时 phase都是null，然后在上面11行代码里面初始化 PARSE_CONFIGURATION 执行
                所以这里的 requiredPhase ，差不多都是PARSE_CONFIGURATION
                
                当然也有 REGISTER_BEAN 的情况，具体堆栈：ConfigurationClassParser#doProcessConfigurationClass:286行
            条件2、
                condition.matches 会默认走到 SpringBootCondition.matches 仅有SpringBootCondition实现此方法
            */
			if ((requiredPhase == null || requiredPhase == phase) && !condition.matches(this.context, metadata)) {
				return true;
			}
		}

		return false;
	}

shouldSkip时机（思考）

可能不会有人思考这俩枚举值有啥不一样的作用?

  • ConfigurationPhase.PARSE_CONFIGURATION
  • ConfigurationPhase.REGISTER_BEAN

spring 虽然搞了很多条件注解，但是总的分为俩类

  • 基于Bean（spring容器的bean）的条件：@ConditionalOnBean
  • 基于其他的匹配：@ConditionalOnProperty、ConditionalOnResource、@ConditionalOnClass

因为在注册beanDefinition之前无法校验spring的bean，
所以要根据注册beanDefinition之前，和注册beanDefinition之后进行分开校验。

注册BeanDefinition之前

org.springframework.context.annotation.ConfigurationClassParser#doProcessConfigurationClass
注意这里默认是启动类，因为@ComponentScan 注解默认在启动类上面，当然如果再加一个@ComponentScan 注解也能走到这里
但是这里是 registerBeanDefinition 之前的校验

doScan

直接定位到doScan这里
org.springframework.context.annotation.ClassPathBeanDefinitionScanner#doScan
org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#findCandidateComponents
org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#scanCandidateComponents

isCandidateComponent

org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#isCandidateComponent(org.springframework.core.type.classreading.MetadataReader)

protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {
		for (TypeFilter tf : this.excludeFilters) {
			if (tf.match(metadataReader, getMetadataReaderFactory())) {
				return false;
			}
		}
		for (TypeFilter tf : this.includeFilters) {
			if (tf.match(metadataReader, getMetadataReaderFactory())) {
                // 执行这里
				return isConditionMatch(metadataReader);
			}
		}
		return false;
	}

	private boolean isConditionMatch(MetadataReader metadataReader) {
		if (this.conditionEvaluator == null) {
			this.conditionEvaluator =
					new ConditionEvaluator(getRegistry(), this.environment, this.resourcePatternResolver);
		}
		return !this.conditionEvaluator.shouldSkip(metadataReader.getAnnotationMetadata());
	}


image.png

注册BeanDefinition之后

org.springframework.context.annotation.ConfigurationClassPostProcessor#processConfigBeanDefinitions
image.png

loadBeanDefinitions

org.springframework.context.annotation.ConfigurationClassBeanDefinitionReader#loadBeanDefinitions

	public void loadBeanDefinitions(Set<ConfigurationClass> configurationModel) {
        // 创建 requiredPhase 的条件执行器，默认只有 OnBeanCondition 会生效
		TrackedConditionEvaluator trackedConditionEvaluator = new TrackedConditionEvaluator();
		for (ConfigurationClass configClass : configurationModel) {
			loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);
		}
	}

	private void loadBeanDefinitionsForConfigurationClass(
			ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {
		// requiredPhase 执行 OnBeanCondition类的校验
		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);
		}
		for (BeanMethod beanMethod : configClass.getBeanMethods()) {
			loadBeanDefinitionsForBeanMethod(beanMethod);
		}

		loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
		loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
	}


private class TrackedConditionEvaluator {

		private final Map<ConfigurationClass, Boolean> skipped = new HashMap<>();

		public boolean shouldSkip(ConfigurationClass configClass) {
			Boolean skip = this.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);
				}
				this.skipped.put(configClass, skip);
			}
			return skip;
		}
	}

matches

org.springframework.boot.autoconfigure.condition.SpringBootCondition#matches(org.springframework.context.annotation.ConditionContext, org.springframework.core.type.AnnotatedTypeMetadata)

	@Override
	public final boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
		String classOrMethodName = getClassOrMethodName(metadata);
		try {
            /*
            这里会根据this动态去执行：
            
            OnBeanCondition           ==》@ConditionalOnMissingBean、@ConditionalOnBean、@ConditionalOnSingleCandidate
            OnClassCondition          ==》@ConditionalOnClass、@ConditionalOnMissingClass
            OnWebApplicationCondition ==》@ConditionalOnWebApplication
            ||
            ==> getMatchOutcome
            */
			ConditionOutcome outcome = getMatchOutcome(context, metadata);
            // 打印日志
			logOutcome(classOrMethodName, outcome);
            // 用来记录自动化配置过程中条件匹配的详细信息及日志信息
            // 在完成finishRefresh时会在ConditionEvaluationReportLoggingListener监听消息打印日志
			recordEvaluation(context, classOrMethodName, outcome);

            // 返回 OnBeanCondition、OnClassCondition、OnClassCondition 匹配后返回的结果
			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);
		}
	}

getMatchOutcome

OnBeanCondition

案例
image.png
直接定位到具体判断的地方
org.springframework.boot.autoconfigure.condition.OnBeanCondition#containsBean
org.springframework.beans.factory.support.DefaultListableBeanFactory#containsBeanDefinition
image.png

OnClassCondition

org.springframework.boot.autoconfigure.condition.OnClassCondition#getMatchOutcome

@Override
	public ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata metadata) {
        // 获取当前线程的类加载器是Launcher$AppClassLoader
		ClassLoader classLoader = context.getClassLoader();
		ConditionMessage matchMessage = ConditionMessage.empty();
        /*
        todo *****************************这一步没看懂具体是咋解析的，有空再研究一下 *****************************
        这一步是获取当前注解上的值,
        如： @ConditionalOnClass(DataSource.class) 解析出 javax.sql.DataSource
        */
		List<String> onClasses = getCandidates(metadata, ConditionalOnClass.class);
		if (onClasses != null) {
           /*
            这一步是精髓了，用classLoader.loadClass(className);检测当前类加载器中是否存在指定class文件
            ClassNameFilter.MISSING 检测丢失的
            ClassNameFilter.PRESENT 检测存在的
           */
			List<String> missing = filter(onClasses, ClassNameFilter.MISSING, classLoader);
			if (!missing.isEmpty()) {
                // 如果不存在写入日志
                // 且标记 ConditionOutcome.match=true
				return ConditionOutcome.noMatch(ConditionMessage.forCondition(ConditionalOnClass.class)
						.didNotFind("required class", "required classes").items(Style.QUOTE, missing));
			}
            // 存在记录
			matchMessage = matchMessage.andCondition(ConditionalOnClass.class)
					.found("required class", "required classes")
					.items(Style.QUOTE, filter(onClasses, ClassNameFilter.PRESENT, classLoader));
		}
        // 对@ConditionalOnMissingClass 注解的解析与@ConditionalOnClass逻辑是相反的
		List<String> onMissingClasses = getCandidates(metadata, ConditionalOnMissingClass.class);
		if (onMissingClasses != null) {
			List<String> present = filter(onMissingClasses, ClassNameFilter.PRESENT, classLoader);
			if (!present.isEmpty()) {
				return ConditionOutcome.noMatch(ConditionMessage.forCondition(ConditionalOnMissingClass.class)
						.found("unwanted class", "unwanted classes").items(Style.QUOTE, present));
			}
			matchMessage = matchMessage.andCondition(ConditionalOnMissingClass.class)
					.didNotFind("unwanted class", "unwanted classes")
					.items(Style.QUOTE, filter(onMissingClasses, ClassNameFilter.MISSING, classLoader));
		}

        // 走到这里标记 ConditionOutcome.match=true
		return ConditionOutcome.match(matchMessage);
	}

org.springframework.boot.autoconfigure.condition.FilteringSpringBootCondition#filter


abstract class FilteringSpringBootCondition extends SpringBootCondition
implements AutoConfigurationImportFilter, BeanFactoryAware, BeanClassLoaderAware {
    protected final List<String> filter(Collection<String> classNames, ClassNameFilter classNameFilter,
                                        ClassLoader classLoader) {
        if (CollectionUtils.isEmpty(classNames)) {
            return Collections.emptyList();
        }
        List<String> matches = new ArrayList<>(classNames.size());
        for (String candidate : classNames) {
            if (classNameFilter.matches(candidate, classLoader)) {
                matches.add(candidate);
            }
        }
        return matches;
    }

    protected enum ClassNameFilter {

        PRESENT {

            @Override
            public boolean matches(String className, ClassLoader classLoader) {
                return isPresent(className, classLoader);
            }

        },

        MISSING {

            @Override
            public boolean matches(String className, ClassLoader classLoader) {
                return !isPresent(className, classLoader);
            }

        };

        abstract boolean matches(String className, ClassLoader classLoader);

        static boolean isPresent(String className, ClassLoader classLoader) {
            if (classLoader == null) {
                classLoader = ClassUtils.getDefaultClassLoader();
            }
            try {
                resolve(className, classLoader);
                return true;
            }
            catch (Throwable ex) {
                return false;
            }
        }
    }
    protected static Class<?> resolve(String className, ClassLoader classLoader) throws ClassNotFoundException {
        if (classLoader != null) {
            return classLoader.loadClass(className);
        }
        return Class.forName(className);
    }

}


OnWebApplicationCondition
十三月tlz
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
@ConditionalOnClass和@ConditionalOnMissingClass的神秘探索
昆仔的博客
01-20 7944
疑问 为什么打开部分字节码文件(.class)文件,看到部分类报红,找不到该类,难道真的没有该类？那编译的时候不报错吗? Spring在启动的时候为什么会可以正常启动,没有该类还会正常启动,Spring是如何加载和处理这些类的呢？ 项目启动后,该类会被JVM加载初始化吗? 疑点分析 这里我随便找了一个类,里面包含一些没有的class,见下图 发现字节码文件(RxReactiveStreams.class)不存在,那我在另外一个比较完整的项目,找到该类属于[rxjava-reactive-s
Spring条件注解@Conditional示例详解
08-25
@Conditional的源码分析 @Conditional注解的源码中可以看到，它可以用在类和方法上，需要传入一个实现了Condition接口的class数组。这个接口中的matches方法将决定是否创建Bean。 Condition接口的使用示例 ...
springboot 自动装配之@ConditionalOnClass，@ConditionalOnMissingClass
enthan809882的博客
01-12 6312
@ConditionalOnClass 表示如果有后面的类，那么就加载这个自动配置 @ConditionalOnMissingClass 如果没有后面的类，才自动配置 这2个注解对实现自动配置很重要。 @Configuration @ConditionalOnClass({ DataSource.class, EmbeddedDatabaseType.class }) @EnableConfi...
@ConditionalOnMissingBean
热门推荐
m0_69798017的博客
11-03 1万+
@ConditionalOnMissingBean 详解以及使用方式
ConditionalOnMissingClass注解使用介绍、应用场景以及示例代码
最新发布
a_beiyo的博客
07-11 270
是 Spring Framework 中的一个条件注解，它用于在类路径中缺少指定的类时决定是否创建一个 bean 或配置一个 bean。这个注解允许开发者根据类的存在与否来动态地配置应用程序上下文中的组件。
SpringBoot原理篇:bean的加载控制(注解式)、@ConditionalOnClass、@ConditionalOnMissingClass、 @ConditionalOnBean
m0_45877477的博客
07-08 2181
@ConditionalOnClass → 如果有属性里的 class就加载对应的bean @ConditionalOnMissingClass → 如果没有属性里的class才加载对应的bean @ConditionalOnBean → 如果spring容器里有属性里写的bean,就返回对应的bean
条件注解 ConditionalOnBean、ConditionalOnMissingBean、ConditionalOnClass、ConditionalOnMissingClass
weixin_40910372的博客
08-24 3587
SpringBoot中的自动配置类有很多ConditionalOnClass注解，@ConditionalOnClass在注解值中所有的类都存在时（通过尝试使用类加载器加载指定的类的方式判断）才会匹配，那么它们都是有哪些作用呢？ @ConditionalOnBean // 当给定的在bean存在时,则实例化当前Bean @ConditionalOnMissingBean // 当给定的在bean不存在时,则实例化当前Bean @ConditionalOnClass //.
SpringBoot源码分析Demo
11-18
此外，SpringBoot还使用`@Conditional`系列注解来控制Bean的创建条件，如`@ConditionalOnClass`和`@ConditionalOnProperty`等，这些注解使得配置更加灵活和精确。 在`july-springboot`这个目录中，我们可以找到具体...
springboot:springboot源码分析
03-28
5. **条件注解（Conditional Annotation）** - 如`@ConditionalOnClass`, `@ConditionalOnMissingBean`等，这些注解允许SpringBoot在满足特定条件时才进行配置，增强了灵活性。 6. **Actuator** - Actuator是...
springboot+bootstrap博客系统源码
12-10
3. **自动配置（Auto Configuration）**：基于@Conditional注解，根据类路径中的存在情况自动配置Bean。 4. **运行器（Runners）**：如CommandLineRunner和ApplicationRunner，方便在应用启动时执行代码。 5. **...
Spring源码
10-25
- **Spring Boot**：如果源码中包含了Spring Boot，可以研究其自动配置机制，以及`@EnableAutoConfiguration`和`@Conditional`注解的作用。 - **Spring Data**：学习Spring Data如何简化数据库操作，特别是其对JPA...
SpringBoot - @ConditionalOnMissingBean注解使用详解
记录并分享
12-30 1万+
@ConditionalOnMissingBean作用在@Bean定义上，也就是说在容器加载它作用的Bean时，检查容器中是否存在目标类型（@ConditionalOnMissingBean注解的value值）的Bean了，如果存在则跳过Bean的默认加载动作，如果不存在则加载该Bean完成注册。
@ConditionalOnBean源码分析
李小德不晓得的博客
11-27 165
@ConditionalOnBean源码分析
【springboot】springboot 注解之 @Conditional
zzd13546036394的博客
03-30 1479
conditional 这个英文单词翻译过来是有条件的，所以 @Conditional 注解是作为条件存在的，如果满足配置的条件则执行，如果没有满足的话就不执行。
@ConditionalOnBean、@ConditionalOnProperty、@ConditionalOnClass、@Conditional和Condition接口的使用
dhklsl的专栏
03-22 5071
一、@ConditionalOnBean、@ConditionalOnProperty、@ConditionalOnClass @ConditionalOnBean是指当spring容器中有某个bean时才装配。 @ConditionalOnClass是指当classpath下有某个类时才装配 @ConditionalOnProperty是指当某个配置项为某个值时才装配 例如：@ConditionalOnBean(name="user")表示当容器中有名字为user的bean时才装配。 下面做下验
spring源码 - 条件注解@ConditionnalOnClass的原理分析
理想万岁万万岁的博客
03-31 4821
用过springboot的小伙伴们都知道，相比于spring，它最大的优势是帮我们省去了一大堆超大一堆繁琐的配置。比如在spring中，当我们需要在项目中整合第三方插件(如redis、mybatis、rabbitmq)时，往往需要在xml配置文件中去配置这些插件的等将其与spring进行整合。而在springboot中，他会根据项目中引入哪些插件自动地将插件进行整合，这都得益于springboot的自动装配或称为自动配置。
@ConditionalOnClass、@ConditionalOnMissing、@ConditionalOnProperty注解的使用
qq_58341172的博客
12-05 504
Spring Boot框架中的条件注解，用于控制Bean的创建和配置。只有当配置文件中没有。这个属性时，才会创建。只有当配置文件中存在。这个属性时，才会创建。
详解Spring Boot框架中的@Conditional系列注解
Dream_it_possible！的博客
09-13 2066
当Spring加载的Bean被@ConditionOnClass注解标记时，类加载器会先去先找到指定的Class, 如果没有找到目标Class,那么被ConditionOnClass注解标记的类不会被Spring装载,相反ConditionalOnMissingBean是指如果没有找到目标Class, 那么就装载该类。实现Condition接口, 例如在配置文件里配置了dataSource.none=true, 那么表示不需要使用数据源，那么Spring在扫描的时候会自动跳过该配置类。
面试官问：SpringBoot中条件注解底层如何实现的？
Java精选
05-27 154
SpringBoot内部提供了特有的注解：条件注解（Conditional Annotation）。比如@ConditionalOnBean、@ConditionalOnClass、@ConditionalOnExpression、@ConditionalOnMissingBean等。条件注解存在的意义在于动态识别（也可以说是代码自动化执行）。比如@ConditionalOnClass会检查类加载...
@Conditional注解
07-14
@Conditional注解可以与其他条件注解一起使用，如@ConditionalOnClass、@ConditionalOnBean、@ConditionalOnProperty等。这些条件注解可以根据类的存在、Bean的存在或配置属性的值来判断是否满足条件。 当满足@...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值