上一节讲到springboot自动化配置是以@Conditional相关注解作为判断条件，那么这一节我们来了解一下@Conditional相关注解的原理。
@Conditional使用示范
新建一个ControllerConditional类，实现Condition接口，实现matches方法，返回false
public class ControllerConditional implements Condition {
@Override
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
return false;
}
}
在Controller类上添加@Conditional(ControllerConditional.class)注解
@RestController
@Conditional(ControllerConditional.class)
public class Controller {
@RequestMapping("/hello")
public String hello(){
return "hello";
}
}
在main函数中尝试获取Controller类。
@SpringBootApplication
public class Application {
public static void main(String[] args) {
ApplicationContext context = SpringApplication.run(Application.class, args);
String[] beanNamesForType = context.getBeanNamesForType(Controller.class);
System.out.println(Arrays.toString(beanNamesForType));
}
}
不出意外控制台会打印出空数组[]。此时去掉Controller类上的@Conditional(ControllerConditional.class)注解，控制台又可以打印出[controller]
@Conditional注解的原理
经过上面的简单示例，对于@Conditional注解的使用大家应该清楚了，如果matches方法返回false，那么这个类就不会被扫描，反之则会被扫描进spring容器。下面就来了解一下他们的原理。
回到上一节我们讲解析Component，PropertySources，ComponentScan这几个注解的地方，进入processConfigurationClass方法，发现在解析之前有一行代码。
protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
return;
}
shouldSkip方法就是判断@Conditional注解的地方(这个shouldSkip方法其他地方也有，但是基本原理都是一样的，或者说就是一样的)，在进入之前，我们先了解一下他的参数以及conditionEvaluator。找到当前类的构造函数，发现如下信息。
public ConfigurationClassParser(MetadataReaderFactory metadataReaderFactory,
ProblemReporter problemReporter, Environment environment, ResourceLoader resourceLoader,
BeanNameGenerator componentScanBeanNameGenerator, BeanDefinitionRegistry registry) {
...
this.conditionEvaluator = new ConditionEvaluator(registry, environment, resourceLoader);
}
public ConditionEvaluator(@Nullable BeanDefinitionRegistry registry,
@Nullable Environment environment, @Nullable ResourceLoader resourceLoader) {
this.context = new ConditionContextImpl(registry, environment, resourceLoader);
}
构造函数不复杂，应该没啥问题。接下来了解一下shouldSkip方法的两个参数，顺着方法找回去。
this.metadata = new StandardAnnotationMetadata(beanClass, true);
public StandardAnnotationMetadata(Class<?> introspectedClass, boolean nestedAnnotationsAsMap) {
super(introspectedClass);
this.annotations = introspectedClass.getAnnotations();
this.nestedAnnotationsAsMap = nestedAnnotationsAsMap;
}
metadata就是这边的StandardAnnotationMetadata，第二个参数是一个枚举。做好这些准备工作后，开始进入shouldSkip方法。
public boolean shouldSkip(@Nullable AnnotatedTypeMetadata metadata, @Nullable ConfigurationPhase phase) {
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);
}
//获取该类的所有@Conditional注解里面的参数类
List<Condition> conditions = new ArrayList<>();
for (String[] conditionClasses : getConditionClasses(metadata)) {
for (String conditionClass : conditionClasses) {
Condition condition = getCondition(conditionClass, this.context.getClassLoader());
conditions.add(condition);
}
}
AnnotationAwareOrderComparator.sort(conditions);
for (Condition condition : conditions) {
ConfigurationPhase requiredPhase = null;
if (condition instanceof ConfigurationCondition) {
requiredPhase = ((ConfigurationCondition) condition).getConfigurationPhase();
}
//依次判断每个类的matches方法，有一个方法返回false则跳过这个类
if ((requiredPhase == null || requiredPhase == phase) && !condition.matches(this.context, metadata)) {
return true;
}
}
return false;
}
shouldSkip方法的逻辑不复杂，获取所有conditional注解里的参数类，依次调用matches方法，如果任意方法返回false则跳过该类。所以在这儿，我们就看到了matches方法的参数以及调用。这样的话，conditional注解的原理大家应该没啥问题了。
那么下面通过举例来看看由conditional注解衍生出的ConditionalOnXXX类型注解。
@ConditionalOnClass注解的原理
打开ConditionalOnClass注解的源代码，本身带有两个属性，一个class类型的value，一个String类型的name。同时ConditionalOnClass注解本身还带了一个@Conditional(OnClassCondition.class)注解。所以，其实ConditionalOnClass注解的判断条件就在于OnClassCondition这个类的matches方法。
@Conditional(OnClassCondition.class)
public @interface ConditionalOnClass {
Class<?>[] value() default {};
String[] name() default {};
}
所以没啥好说的，直接进入OnClassCondition类，寻找matches方法。最终，在他的父类SpringBootCondition中，找到了matches方法。代码如下:
@Override
public final boolean matches(ConditionContext context,
AnnotatedTypeMetadata metadata) {
//获取加上了@ConditionalOnClass注解的类或者方法的名称(我们就以类分析，加在方法上是一个原理)
String classOrMethodName = getClassOrMethodName(metadata);
try {
//获取匹配结果
ConditionOutcome outcome = getMatchOutcome(context, metadata);
logOutcome(classOrMethodName, outcome);
recordEvaluation(context, classOrMethodName, outcome);
return outcome.isMatch();
}
...
}
从代码不难看出，关键方法在getMatchOutcome里，所以进入该方法。
@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) {
//筛选这些类，判断条件为ClassNameFilter.MISSING
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));
}
...
return ConditionOutcome.match(matchMessage);
}
该方法并不复杂，和ConditionalOnClass有关的代码主要有两行，getCandidates和filter。 首先看看getCandidates:
private List<String> getCandidates(AnnotatedTypeMetadata metadata,
Class<?> annotationType) {
MultiValueMap<String, Object> attributes = metadata
.getAllAnnotationAttributes(annotationType.getName(), true);
if (attributes == null) {
return null;
}
List<String> candidates = new ArrayList<>();
addAll(candidates, attributes.get("value"));
addAll(candidates, attributes.get("name"));
return candidates;
}
主要是获取了ConditionalOnClass的name属性和value属性。
接下来看看filter方法，在进入filter方法前，先看一下判断条件ClassNameFilter.MISSING
MISSING {
@Override
public boolean matches(String className, ClassLoader classLoader) {
return !isPresent(className, classLoader);
}
};
public static boolean isPresent(String className, ClassLoader classLoader) {
if (classLoader == null) {
classLoader = ClassUtils.getDefaultClassLoader();
}
try {
forName(className, classLoader);
return true;
}
catch (Throwable ex) {
return false;
}
}
private static Class<?> forName(String className, ClassLoader classLoader)
throws ClassNotFoundException {
if (classLoader != null) {
return classLoader.loadClass(className);
}
return Class.forName(className);
}
逻辑很清晰，如果该类能被加载则判断成功，否则判断失败。现在进入filter方法。
protected 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) {
//逐个判断我们添加的判断条件，如果有不符合的即添加进list
if (classNameFilter.matches(candidate, classLoader)) {
matches.add(candidate);
}
}
return matches;
}
filter方法就是利用刚刚的判断条件进行判断，发现不符合的添加进list一并返回，最后生成结果。
所以到这儿，conditional相关注解的原理应该都清楚了，其他衍生类原理也大多相似，就不再一一分析。
