Spring条件注解@ConditionnalOnClass的原理分析

@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(OnClassCondition.class)
public @interface ConditionalOnClass {
    // The classes that must be present.
	Class<?>[] value() default {};
    // The classes names that must be present.
	String[] name() default {};

}

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Conditional {

   /**
    * All {@link Condition} classes that must {@linkplain Condition#matches match}
    * in order for the component to be registered.
    */
   Class<? extends Condition>[] value();

}

@FunctionalInterface
public interface Condition {
    /**
     * 决定条件是否通过
     * @param context - 条件上下文
     * @param metadata - 元数据，里面标注该注解的类或方法
     * @return true-通过，false-不通过
     **/
   boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata);
}

public abstract class SpringBootCondition implements Condition {
	private final Log logger = LogFactory.getLog(getClass());
    /**
     * matches()方法的实现————决定条件是否通过
     * @param context - 条件上下文
     * @param metadata - 元数据，里面标注该注解的类或方法
     * @return true-通过，false-不通过
     **/
	@Override
	public final boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        // 获取方法名或类名
		String classOrMethodName = getClassOrMethodName(metadata);
		try {
            // 对元数据进行判断，看是否符合要求。
            // ConditionOutcome中封装了判断的结果和相应的结果信息，
			ConditionOutcome outcome = getMatchOutcome(context, metadata);
            // 日志，
			logOutcome(classOrMethodName, outcome);
            // 记录
			recordEvaluation(context, classOrMethodName, outcome);
            // 如果isMatch()的值为true，则表示条件通过
			return outcome.isMatch();
		}
		catch (NoClassDefFoundError ex) {
			// 抛出IllegalStateException异常
		}
		catch (RuntimeException ex) {
			// 抛出IllegalStateException异常
		}
	}
    public abstract ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata metadata);
}

class OnClassCondition extends FilteringSpringBootCondition {
    // 该方法分三部分
    // 1. 处理ConditionalOnClass注解
    // 2. 处理ConditionalOnMissingClass注解
    // 3. 返回条件判断的结果
    @Override
	public ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata metadata) {
		ClassLoader classLoader = context.getClassLoader();
        // 通过静态方法，创建一个ConditionMessage实例，用来保存条件判断结果对应的信息
		ConditionMessage matchMessage = ConditionMessage.empty();
        // 1. 处理ConditionalOnClass注解
        // 获取该元数据表示的类或方法上的ConditionalOnClass注解中标注的类的限定名，
        // 表示这些类应当在classpath类路径中存在，所以叫onClass
        // 例如：@ConditionalOnClass({ RabbitTemplate.class, Channel.class })，
        //      则返回RabbitTemplate和Channel的全限定类名
		List<String> onClasses = getCandidates(metadata, ConditionalOnClass.class);
		if (onClasses != null) {
            // filter()方法内部 对onClass表示的类进行反射，条件为MISSING，
            // 如果得到的集合不为空，则说明类路径中不存在ConditionalOnClass注解中标注的类
            // 这种情况下直接通过ConditionOutcome.noMatch()封装ConditionOutcome条件判断的结果并返回，noMatch()即表示不通过。
			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));
			}
            // 对ConditionalOnClass注解的条件判断通过，并保存对应的信息到matchMessage
			matchMessage = matchMessage.andCondition(ConditionalOnClass.class)
					.found("required class", "required classes")
					.items(Style.QUOTE, filter(onClasses, ClassNameFilter.PRESENT, classLoader));
		}
        // 2. 处理ConditionalOnMissingClass注解
        // 获取该元数据表示的类或方法上的ConditionalOnMissingClass注解中标注的类的限定名，
        // 表示这些类应当在classpath类路径中不存在，所以叫onMissingClass
        // 例如：@ConditionalOnMissingClass({ RabbitTemplate.class, Channel.class })，
        //      则返回RabbitTemplate和Channel的全限定类名
		List<String> onMissingClasses = getCandidates(metadata, ConditionalOnMissingClass.class);
		if (onMissingClasses != null) {
            // filter()方法内部 对onMissingClasses表示的类进行反射，条件为PRESENT，
            // 如果得到的集合不为空，则说明类路径中存在ConditionalOnMissingClass注解中标注的类
            // 这种情况下直接通过ConditionOutcome.noMatch()封装ConditionOutcome条件判断的结果并返回，noMatch()即表示不通过。
			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));
			}
            // 对ConditionalOnMissingClass注解的条件判断通过，并保存对应的信息到matchMessage
			matchMessage = matchMessage.andCondition(ConditionalOnMissingClass.class)
					.didNotFind("unwanted class", "unwanted classes")
					.items(Style.QUOTE, filter(onMissingClasses, ClassNameFilter.MISSING, classLoader));
		}
        // 3. 返回条件判断的结果，到这一步，就说明ConditionalOnClass注解和ConditionalOnMissingClass注解上的条件都已经通过了。
		return ConditionOutcome.match(matchMessage);
	}
}