【Spring Boot 源码学习】OnClassCondition 详解

Huazie2024-03-12 13:34

《Spring Boot 源码学习系列》

引言

上篇博文带大家从源码深入了自动配置过滤匹配父类 FilteringSpringBootCondition ，那么笔者接下来的博文将要介绍它的三个子类 OnClassCondition、OnBeanCondition 和 OnWebApplicationCondition 的实现。

主要内容

话不多说，我们开始本篇的内容，重点详解 OnClassCondition 的实现。

1. getOutcomes 方法

OnClassCondition 也是 FilteringSpringBootCondition 的子类，我们首先从 getOutcomes 方法源码来分析【Spring Boot 2.7.9】：

java 复制代码 
// OnClassCondition 用于检查是否存在特定类
@Order(Ordered.HIGHEST_PRECEDENCE)
class OnClassCondition extends FilteringSpringBootCondition {

	@Override
	protected final ConditionOutcome[] getOutcomes(String[] autoConfigurationClasses,
			AutoConfigurationMetadata autoConfigurationMetadata) {
		// 如果有多个处理器可用，则拆分工作并在后台线程中执行一半。
		// 使用单个附加线程似乎可以提供最佳性能。
		// 线程越多，情况就越糟。
		if (autoConfigurationClasses.length > 1 && Runtime.getRuntime().availableProcessors() > 1) {
			return resolveOutcomesThreaded(autoConfigurationClasses, autoConfigurationMetadata);
		}
		else {
			OutcomesResolver outcomesResolver = new StandardOutcomesResolver(autoConfigurationClasses, 0,
					autoConfigurationClasses.length, autoConfigurationMetadata, getBeanClassLoader());
			return outcomesResolver.resolveOutcomes();
		}
	}
	// ...
}

上述 getOutcomes 方法中，如果有多个处理器可用，则拆分工作并在后台线程中执行一半，使用单个附加线程似乎可以提供最佳性能【不过线程越多，情况就越糟】；否则，直接新建 StandardOutcomesResolver 来处理。

2. 多处理器拆分处理

先来看看 resolveOutcomesThreaded 的源码【Spring Boot 2.7.9】：

java 复制代码 
private ConditionOutcome[] resolveOutcomesThreaded(String[] autoConfigurationClasses,
			AutoConfigurationMetadata autoConfigurationMetadata) {
	int split = autoConfigurationClasses.length / 2;
	OutcomesResolver firstHalfResolver = createOutcomesResolver(autoConfigurationClasses, 0, split, autoConfigurationMetadata);
	OutcomesResolver secondHalfResolver = new StandardOutcomesResolver(autoConfigurationClasses, split,
			autoConfigurationClasses.length, autoConfigurationMetadata, getBeanClassLoader());
	ConditionOutcome[] secondHalf = secondHalfResolver.resolveOutcomes();
	ConditionOutcome[] firstHalf = firstHalfResolver.resolveOutcomes();
	ConditionOutcome[] outcomes = new ConditionOutcome[autoConfigurationClasses.length];
	System.arraycopy(firstHalf, 0, outcomes, 0, firstHalf.length);
	System.arraycopy(secondHalf, 0, outcomes, split, secondHalf.length);
	return outcomes;
}

进入 resolveOutcomesThreaded 方法，我们可以看到这里主要采用了分半处理的方法来提升处理效率【单个附加线程处理一半数据，主线程处理一半数据】。

我们来仔细分析一下：

  • 首先，获取自动配置类数组的一半长度，用于后续分半处理。

  • 然后，通过调用 createOutcomesResolver 方法【入参表示要处理自动配置类数组的前面一半的数据】创建了一个OutcomesResolver 对象 firstHalfResolver；进入 createOutcomesResolver 方法，我们可以看到这里是先新建了一个 StandardOutcomesResolver，然后将其作为构造函数入参，返回一个 ThreadedOutcomesResolver 对象，通过翻看代码，发现就是这里面会新启动一个线程来处理数据。

    java 复制代码 
    private OutcomesResolver createOutcomesResolver(String[] autoConfigurationClasses, int start, int end,
  		AutoConfigurationMetadata autoConfigurationMetadata) {
  	OutcomesResolver outcomesResolver = new StandardOutcomesResolver(autoConfigurationClasses, start, end,
  			autoConfigurationMetadata, getBeanClassLoader());
  	try {
  		return new ThreadedOutcomesResolver(outcomesResolver);
  	}
  	catch (AccessControlException ex) {
  		return outcomesResolver;
  	}
}

  • 接着，先新建了一个 StandardOutcomesResolver【其构造方法入参表示要处理自动配置类数组的后面一半的数据】，并赋值给 一个 OutcomesResolver 对象 secondHalfResolver；

  • 最后，调用 firstHalfResolver 和 secondHalfResolver 的 resolveOutcomes 方法来处理自动配置类数据，并将处理结果合并到 outcomes 中返回。

通过上面分析，我们发现不论是 单个附加线程处理一半数据，还是 主线程处理一半数据，其核心还是 StandardOutcomesResolver 这个类。

3. StandardOutcomesResolver 内部类

下面我们来看看内部类 StandardOutcomesResolver 中的 resolveOutcomes 方法的实现代码【Spring Boot 2.7.9】：

java 复制代码 
private static final class StandardOutcomesResolver implements OutcomesResolver {
	// ...省略

	@Override
	public ConditionOutcome[] resolveOutcomes() {
		return getOutcomes(this.autoConfigurationClasses, this.start, this.end, this.autoConfigurationMetadata);
	}
}

进入 resolveOutcomes 方法，我们可以看到这里直接调用了 getOutcomes 方法并返回处理结果，如下所示：

java 复制代码 
	private ConditionOutcome[] getOutcomes(String[] autoConfigurationClasses, int start, int end,
			AutoConfigurationMetadata autoConfigurationMetadata) {
		ConditionOutcome[] outcomes = new ConditionOutcome[end - start];
		for (int i = start; i < end; i++) {
			String autoConfigurationClass = autoConfigurationClasses[i];
			if (autoConfigurationClass != null) {
				String candidates = autoConfigurationMetadata.get(autoConfigurationClass, "ConditionalOnClass");
				if (candidates != null) {
					outcomes[i - start] = getOutcome(candidates);
				}
			}
		}
		return outcomes;
	}

上述逻辑也好理解，那就是遍历并处理自动配置类数组 autoConfigurationClasses 在 索引 start 到 end - 1 之间的数据。其中循环里面：

  • 首先，获取要处理的自动配置类 autoConfigurationClass ；

  • 然后，通过调用 AutoConfigurationMetadata 接口的 get(String className, String key) 方法来获取与autoConfigurationClass 关联的名为 "ConditionalOnClass" 的条件属性值。而该 get 方法的具体实现可见 AutoConfigurationMetadataLoader 类，这个我们在上一篇博文中也提及到，它会加载 META-INF/spring-autoconfigure-metadata.properties 中的配置。

    java 复制代码 
    final class AutoConfigurationMetadataLoader {
  	// ... 省略

  	private static class PropertiesAutoConfigurationMetadata implements AutoConfigurationMetadata {
  		// ... 省略
  		@Override
  		public String get(String className, String key) {
  			return get(className, key, null);
  		}

  		@Override
  		public String get(String className, String key, String defaultValue) {
  			String value = this.properties.getProperty(className + "." + key);
  			return (value != null) ? value : defaultValue;
  		}
  	}
}

    通过上述截图和代码，我们可以看到 AutoConfigurationMetadataLoader 的内部类PropertiesAutoConfigurationMetadata 实现了 AutoConfigurationMetadata 接口的具体方法，其中就包含上述用到的 get(String className, String key) 方法。

    仔细查看 get 方法的实现，我们不难发现上述 getOutcomes 方法中获取的 candidates，其实就是 META-INF/spring-autoconfigure-metadata.properties 文件中配置的 key 为 自动配置类名.ConditionalOnClass 的字符串，而 value 为其获得的值。

    我们以 RedisCacheConfiguration 为例，可以看到如下配置：

  • 最后，调用 getOutcome(String candidates) 方法来完成最后的过滤匹配工作。

    下面来看看相关的源码实现：

    java 复制代码 
    private ConditionOutcome getOutcome(String candidates) {
	try {
		if (!candidates.contains(",")) {
			return getOutcome(candidates, this.beanClassLoader);
		}
		for (String candidate : StringUtils.commaDelimitedListToStringArray(candidates)) {
			ConditionOutcome outcome = getOutcome(candidate, this.beanClassLoader);
			if (outcome != null) {
				return outcome;
			}
		}
	}
	catch (Exception ex) {
		// We'll get another chance later
	}
	return null;
}

    如果 candidates 不包含逗号，说明只有一个，直接调用 getOutcome(String className, ClassLoader classLoader) 返回过滤匹配结果；否则就是包含多个，调用 StringUtils.commaDelimitedListToStringArray(candidates) 将逗号分隔的字符串（如candidates）转换为一个字符串数组，然后遍历处理，还是调用 getOutcome(String className, ClassLoader classLoader) 过滤匹配结果，如果 outcome 不为空，则直接返回 outcome 。

    StringUtils.commaDelimitedListToStringArray(candidates) 它会根据逗号来分割输入的字符串，并移除每个元素中的空格。返回的字符串数组包含了被分割后的各个元素

    下面我们直接进入 getOutcome(String className, ClassLoader classLoader) 方法查看其源码：

    java 复制代码 
    private ConditionOutcome getOutcome(String className, ClassLoader classLoader) {
	if (ClassNameFilter.MISSING.matches(className, classLoader)) {
		return ConditionOutcome.noMatch(ConditionMessage.forCondition(ConditionalOnClass.class)
			.didNotFind("required class")
			.items(Style.QUOTE, className));
	}
	return null;
}

    我们这里可以看到上面介绍过的 ClassNameFilter.MISSING ，它是用于校验指定的类是否加载失败。而这里意思就是如果 className 对应的类不存在，则返回没有满足过滤匹配的结果【即 ConditionOutcome.noMatch.didNotFind ，其中不存在需要的类】；否则返回 null。

结合 FilteringSpringBootCondition 的介绍，我们知道了 OnClassCondition 类 getOutComes 方法判断的是 自动配置类关联的 OnClassCondition 配置属性对应的类，如果它存在，则后面处理时保留自动配置类；否则，后面会清空自动配置类；

4. getMatchOutcome 方法

通过翻看源码，我们其实也可以发现，OnClassCondition 类还实现了 FilteringSpringBootCondition 的父类 SpringBootCondition 中的抽象方法。

如下是 SpringBootCondition 类的部分源码【Spring Boot 2.7.9】：

java 复制代码 
public abstract class SpringBootCondition implements Condition {

	// ...

	@Override
	public final boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
		String classOrMethodName = getClassOrMethodName(metadata);
		try {
			ConditionOutcome outcome = getMatchOutcome(context, metadata);
			// ...
			return outcome.isMatch();
		}
		catch (NoClassDefFoundError ex) {
			// ...
		}
		catch (RuntimeException ex) {
			// ...
		}
	}

	public abstract ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata metadata);

}

在 SpringBootCondition 中有个最终方法 matches，该方法逻辑很简单，就是调用 getMatchOutcome 方法获取过滤匹配结果，然后通过 outcome.isMatch() 返回过滤匹配结果值【true：满足过滤匹配 false：不满足过滤匹配】

简单了解上述内容之后，我们继续看 OnClassCondition 中 getMatchOutcome 的完整实现：

java 复制代码 
@Override
public ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata metadata) {
	ClassLoader classLoader = context.getClassLoader();
	ConditionMessage matchMessage = ConditionMessage.empty();
	List<String> onClasses = getCandidates(metadata, ConditionalOnClass.class);
	if (onClasses != null) {
		List<String> missing = filter(onClasses, ClassNameFilter.MISSING, classLoader);
		if (!missing.isEmpty()) {
			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));
	}
	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));
	}
	return ConditionOutcome.match(matchMessage);
}

上面的逻辑大致可以总结为如下两处：

  • 获取自动配置类上的 ConditionalOnClass 注解配置的类，然后调用父类 FilteringSpringBootCondition 中的 filter 方法，获取匹配失败的类集合。 如果匹配失败的类集合不为空，则返回不满足过滤匹配的结果【即 ConditionOutcome.noMatch.didNotFind，其中不存在需要的类】

    java 复制代码 
    List<String> missing = filter(onClasses, ClassNameFilter.MISSING, classLoader);
if (!missing.isEmpty()) {
	return ConditionOutcome.noMatch(ConditionMessage.forCondition(ConditionalOnClass.class)
		.didNotFind("required class", "required classes")
		.items(Style.QUOTE, missing));
}

    如果匹配失败的集合为空，则添加满足过滤匹配的结果，并返回【即 ConditionMessage.empty.andCondition.found，其中找到了需要的类】。

    java 复制代码 
    matchMessage = matchMessage.andCondition(ConditionalOnClass.class)
		.found("required class", "required classes")
		.items(Style.QUOTE, filter(onClasses, ClassNameFilter.PRESENT, classLoader));

return ConditionOutcome.match(matchMessage);

  • 获取自动配置类上的 ConditionalOnMissingClass 注解配置的类，然后调用父类 FilteringSpringBootCondition 中的 filter 方法，获取匹配成功的类集合。 如果匹配成功的类集合不为空，则返回不满足过滤匹配的结果【即 ConditionOutcome.noMatch.found，其中存在不想要的类】

    java 复制代码 
    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));
}

    如果匹配成功的类集合为空，则添加满足过滤匹配的结果【即 ConditionMessage.empty.andCondition.didNotFind，其中没有找到不想要的类】。

    java 复制代码 
    matchMessage = matchMessage.andCondition(ConditionalOnMissingClass.class)
	.didNotFind("unwanted class", "unwanted classes")
	.items(Style.QUOTE, filter(onMissingClasses, ClassNameFilter.MISSING, classLoader));

return ConditionOutcome.match(matchMessage);

总结

本篇 Huazie 带大家介绍了自动配置过滤匹配子类 OnClassCondition，内容较多，感谢大家的支持；笔者接下来的博文还将详解 OnBeanCondition 和 OnWebApplicationCondition 的实现，敬请期待！！！

相关推荐
WaaTong9 分钟前
《重学Java设计模式》之 原型模式
java·设计模式·原型模式
m0_743048449 分钟前
初识Java EE和Spring Boot
java·java-ee
AskHarries11 分钟前
Java字节码增强库ByteBuddy
java·后端
佳佳_25 分钟前
Spring Boot 应用启动时打印配置类信息
spring boot·后端
小灰灰__31 分钟前
IDEA加载通义灵码插件及使用指南
java·ide·intellij-idea
夜雨翦春韭34 分钟前
Java中的动态代理
java·开发语言·aop·动态代理
程序媛小果1 小时前
基于java+SpringBoot+Vue的宠物咖啡馆平台设计与实现
java·vue.js·spring boot
追风林1 小时前
mac m1 docker本地部署canal 监听mysql的binglog日志
java·docker·mac
芒果披萨1 小时前
El表达式和JSTL
java·el
许野平2 小时前
Rust： 利用 chrono 库实现日期和字符串互相转换
开发语言·后端·rust·字符串·转换·日期·chrono
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10【TC3xx芯片】TC3xx芯片电源管理系统PMS详解