【spring之条件评估器】

1. ConditionEvaluator是干嘛的

内部的使用类,用来评估注解的

2. 先看其属性类ConditionContextImp context

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;
			this.beanFactory = deduceBeanFactory(registry);
			this.environment = (environment != null ? environment : deduceEnvironment(registry));
			this.resourceLoader = (resourceLoader != null ? resourceLoader : 
															deduceResourceLoader(registry));
			this.classLoader = deduceClassLoader(resourceLoader, this.beanFactory);
		}

		@Nullable
		// 根据子类类型，推到出beanFactory！
		private ConfigurableListableBeanFactory deduceBeanFactory(@Nullable 
													BeanDefinitionRegistry source) {
   
			if (source instanceof ConfigurableListableBeanFactory) {
   
				return (ConfigurableListableBeanFactory) source;
			}
			if (source instanceof ConfigurableApplicationContext) {
   
				return (((ConfigurableApplicationContext) source).getBeanFactory());
			}
			return null;
		}
		
		// 获取到环境
		private Environment deduceEnvironment(@Nullable BeanDefinitionRegistry source) {
   
			if (source instanceof EnvironmentCapable) {
   
				return ((EnvironmentCapable) source).getEnvironment();
			}
			return new StandardEnvironment();
		}
		// 推到出资源加载器
		private ResourceLoader deduceResourceLoader(@Nullable 
									BeanDefinitionRegistry source) {
   
			if (source instanceof ResourceLoader) {
   
				return (ResourceLoader) source;
			}
			// 不是ResouceLoader类型的话，就初始化一个默认资源加载器
			return new DefaultResourceLoader();
		}

		@Nullable
		// 不解释啦，看不懂就别看了
		private ClassLoader deduceClassLoader(@Nullable ResourceLoader resourceLoader,
				@Nullable ConfigurableListableBeanFactory beanFactory) {
   

			if (resourceLoader != null) {
   
				ClassLoader classLoader = resourceLoader.getClassLoader();
				if (classLoader != null) {
   
					return classLoader;
				}
			}
			if (beanFactory != null) {
   
				return beanFactory.getBeanClassLoader();
			}
			return ClassUtils.getDefaultClassLoader();
		}

		@Override
		// 获取beanDefinition注册器
		public BeanDefinitionRegistry getRegistry() {
   
			Assert.state(this.registry != null, "No BeanDefinitionRegistry available");
			return this.registry;
		}

		@Override
		@Nullable
		// 返回beanFactory
		public ConfigurableListableBeanFactory getBeanFactory() {
   
			return this.beanFactory;
		}

		@Override
		public Environment getEnvironment() {
   
			return this.environment;
		}

		@Override
		public ResourceLoader getResourceLoader() {
   
			return this.resourceLoader;
		}

		@Override
		@Nullable
		public ClassLoader getClassLoader() {
   
			return this.classLoader;
		}
}
// Context information for use by Condition implementations
// 条件实现类使用的上下文信息类
public interface ConditionContext {
   
	// 获取BeanDefinition信息
	BeanDefinitionRegistry getRegistry();
	// 这不用说获取容器
	ConfigurableListableBeanFactory getBeanFactory();
	// 获取环境
	Environment getEnvironment();
	// 获取资源加载器
	ResourceLoader getResourceLoader();
	// 获取类加载器
	ClassLoader getClassLoader();
}

3. 看ConditionEvaluator 的内部方法

// 构造器
public ConditionEvaluator(@Nullable BeanDefinitionRegistry registry,
	@Nullable Environment environment, @Nullable ResourceLoader resourceLoader) {
   
	// 根据参数实例化条件上下文
	this.context = new ConditionContextImpl(registry, environment, resourceLoader);
}

// 是否跳过
public boolean shouldSkip(AnnotatedTypeMetadata metadata) {
   
	return shouldSkip(metadata, null);
}


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);
	}

	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();
		}
		if ((requiredPhase == null || requiredPhase == phase) && 
									!condition.matches(this.context, metadata)) {
   
			return true;
		}
	}

	return false;
}

4. AnnotationTypeMetadata 是干嘛的

// 用于获取元素上的注解的元数据，不用看了！
MergedAnnotations getAnnotations();

default boolean isAnnotated(String annotationName) {
   
		return getAnnotations().isPresent(annotationName);
}

default Map<String, Object> getAnnotationAttributes(String annotationName) {
   
		return getAnnotationAttributes(annotationName, false);
}

default Map<String, Object> getAnnotationAttributes(String annotationName,
			boolean classValuesAsString) {
   

	MergedAnnotation<Annotation> annotation = getAnnotations().get(annotationName,
			null, MergedAnnotationSelectors.firstDirectlyDeclared());
	if (!annotation.isPresent()) {
   
		return null;
	}
	return annotation.asAnnotationAttributes(Adapt.values(classValuesAsString, true));
}

default MultiValueMap<String, Object> getAllAnnotationAttributes(String annotationName) {
   
		return getAllAnnotationAttributes(annotationName, false);
}

default MultiValueMap<String, Object> getAllAnnotationAttributes(
			String annotationName, boolean classValuesAsString) {
   

	Adapt[] adaptations = Adapt.values(classValuesAsString, true);
	return getAnnotations().stream(annotationName)
			.filter(MergedAnnotationPredicates.unique(MergedAnnotation::getMetaTypes))
			.map(MergedAnnotation::withNonMergedAttributes)
			.collect(MergedAnnotationCollectors.toMultiValueMap(map ->
					map.isEmpty() ? null : map, adaptations));
}

5. Condition 接口

boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata);