Java Condition类代码示例

import org.springframework.context.annotation.Condition; //导入依赖的package包/类
public boolean allowStage(Conditional[] conditionalClasses, ConditionalMatchType conditionalMatchType, Method method,
                          MongoParameterAccessor mongoParameterAccessor,
                          ConvertingParameterAccessor convertingParameterAccessor) {
  boolean shouldProcess = true;
  try {
    for (Conditional conditional : conditionalClasses) {
      List<Object> parameterValues = getParameterValues(method, mongoParameterAccessor, convertingParameterAccessor);
      ConditionalAnnotationMetadata metadata = new ConditionalAnnotationMetadata(conditional);
      AggregateQueryMethodConditionContext context = new AggregateQueryMethodConditionContext(method,
          parameterValues);
      Condition condition = conditional.condition().newInstance();
      boolean isTrue = condition.matches(context, metadata);
      if (conditionalMatchType == ConditionalMatchType.ANY && isTrue) {
        return true;
      }
      if(conditionalMatchType == ConditionalMatchType.ALL) {
        shouldProcess &= condition.matches(context, metadata);
      }
    }
  } catch (InstantiationException | IllegalAccessException e) {
    throw new IllegalStateException("Could not create an instance of the condition class", e);
  }
  return conditionalMatchType == ConditionalMatchType.ANY ? ArrayUtils.isEmpty(conditionalClasses) : shouldProcess;
}
 

import org.springframework.context.annotation.Condition; //导入依赖的package包/类
@PostConstruct
public void setupAutoConfigurationReport() {
	ConditionEvaluationReport report = ConditionEvaluationReport
			.get(this.context.getBeanFactory());
	report.recordConditionEvaluation("a", mock(Condition.class),
			mock(ConditionOutcome.class));
	report.recordExclusions(Arrays.asList("com.foo.Bar"));
}
 

import org.springframework.context.annotation.Condition; //导入依赖的package包/类
public static boolean matches(ConditionContext context) {
	Class<AuthorizationServerEndpointsConfigurationBeanCondition> type = AuthorizationServerEndpointsConfigurationBeanCondition.class;
	Conditional conditional = AnnotationUtils.findAnnotation(type,
			Conditional.class);
	StandardAnnotationMetadata metadata = new StandardAnnotationMetadata(type);
	for (Class<? extends Condition> conditionType : conditional.value()) {
		Condition condition = BeanUtils.instantiateClass(conditionType);
		if (condition.matches(context, metadata)) {
			return true;
		}
	}
	return false;
}
 

import org.springframework.context.annotation.Condition; //导入依赖的package包/类
/**
 * Record the occurrence of condition evaluation.
 * @param source the source of the condition (class or method name)
 * @param condition the condition evaluated
 * @param outcome the condition outcome
 */
public void recordConditionEvaluation(String source, Condition condition,
		ConditionOutcome outcome) {
	Assert.notNull(source, "Source must not be null");
	Assert.notNull(condition, "Condition must not be null");
	Assert.notNull(outcome, "Outcome must not be null");
	this.unconditionalClasses.remove(source);
	if (!this.outcomes.containsKey(source)) {
		this.outcomes.put(source, new ConditionAndOutcomes());
	}
	this.outcomes.get(source).add(condition, outcome);
	this.addedAncestorOutcomes = false;
}
 

import org.springframework.context.annotation.Condition; //导入依赖的package包/类
private Map<AnnotationMetadata, List<Condition>> getMemberConditions(
		String[] members) {
	MultiValueMap<AnnotationMetadata, Condition> memberConditions = new LinkedMultiValueMap<AnnotationMetadata, Condition>();
	for (String member : members) {
		AnnotationMetadata metadata = getMetadata(member);
		for (String[] conditionClasses : getConditionClasses(metadata)) {
			for (String conditionClass : conditionClasses) {
				Condition condition = getCondition(conditionClass);
				memberConditions.add(metadata, condition);
			}
		}
	}
	return Collections.unmodifiableMap(memberConditions);
}
 

import org.springframework.context.annotation.Condition; //导入依赖的package包/类
public List<ConditionOutcome> getMatchOutcomes() {
	List<ConditionOutcome> outcomes = new ArrayList<ConditionOutcome>();
	for (Map.Entry<AnnotationMetadata, List<Condition>> entry : this.memberConditions
			.entrySet()) {
		AnnotationMetadata metadata = entry.getKey();
		List<Condition> conditions = entry.getValue();
		outcomes.add(new MemberOutcomes(this.context, metadata, conditions)
				.getUltimateOutcome());
	}
	return Collections.unmodifiableList(outcomes);
}
 

import org.springframework.context.annotation.Condition; //导入依赖的package包/类
MemberOutcomes(ConditionContext context, AnnotationMetadata metadata,
		List<Condition> conditions) {
	this.context = context;
	this.metadata = metadata;
	this.outcomes = new ArrayList<ConditionOutcome>(conditions.size());
	for (Condition condition : conditions) {
		this.outcomes.add(getConditionOutcome(metadata, condition));
	}
}
 

import org.springframework.context.annotation.Condition; //导入依赖的package包/类
private ConditionOutcome getConditionOutcome(AnnotationMetadata metadata,
		Condition condition) {
	if (condition instanceof SpringBootCondition) {
		return ((SpringBootCondition) condition).getMatchOutcome(this.context,
				metadata);
	}
	return new ConditionOutcome(condition.matches(this.context, metadata),
			ConditionMessage.empty());
}
 

import org.springframework.context.annotation.Condition; //导入依赖的package包/类
/**
 * Return true if any of the specified conditions match.
 * @param context the context
 * @param metadata the annotation meta-data
 * @param conditions conditions to test
 * @return {@code true} if any condition matches.
 */
protected final boolean anyMatches(ConditionContext context,
		AnnotatedTypeMetadata metadata, Condition... conditions) {
	for (Condition condition : conditions) {
		if (matches(context, metadata, condition)) {
			return true;
		}
	}
	return false;
}
 

import org.springframework.context.annotation.Condition; //导入依赖的package包/类
/**
 * Return true if any of the specified condition matches.
 * @param context the context
 * @param metadata the annotation meta-data
 * @param condition condition to test
 * @return {@code true} if the condition matches.
 */
protected final boolean matches(ConditionContext context,
		AnnotatedTypeMetadata metadata, Condition condition) {
	if (condition instanceof SpringBootCondition) {
		return ((SpringBootCondition) condition).getMatchOutcome(context, metadata)
				.isMatch();
	}
	return condition.matches(context, metadata);
}
 

import org.springframework.context.annotation.Condition; //导入依赖的package包/类
public MessageAndCondition(ConditionAndOutcome conditionAndOutcome) {
	Condition condition = conditionAndOutcome.getCondition();
	ConditionOutcome outcome = conditionAndOutcome.getOutcome();
	this.condition = ClassUtils.getShortName(condition.getClass());
	if (StringUtils.hasLength(outcome.getMessage())) {
		this.message = outcome.getMessage();
	}
	else {
		this.message = (outcome.isMatch() ? "matched" : "did not match");
	}
}
 

import org.springframework.context.annotation.Condition; //导入依赖的package包/类
public List<ConditionOutcome> getMatchOutcomes() {
	List<ConditionOutcome> outcomes = new ArrayList<ConditionOutcome>();
	for (Map.Entry<AnnotationMetadata, List<Condition>> entry : this.memberConditions
			.entrySet()) {
		AnnotationMetadata metadata = entry.getKey();
		for (Condition condition : entry.getValue()) {
			outcomes.add(getConditionOutcome(metadata, condition));
		}
	}
	return Collections.unmodifiableList(outcomes);
}
 

import org.springframework.context.annotation.Condition; //导入依赖的package包/类
private ConditionOutcome getConditionOutcome(AnnotationMetadata metadata,
		Condition condition) {
	String messagePrefix = "member condition on " + metadata.getClassName();
	if (condition instanceof SpringBootCondition) {
		ConditionOutcome outcome = ((SpringBootCondition) condition)
				.getMatchOutcome(this.context, metadata);
		String message = outcome.getMessage();
		return new ConditionOutcome(outcome.isMatch(), messagePrefix
				+ (StringUtils.hasLength(message) ? " : " + message : ""));
	}
	boolean matches = condition.matches(this.context, metadata);
	return new ConditionOutcome(matches, messagePrefix);
}
 

import org.springframework.context.annotation.Condition; //导入依赖的package包/类
public void add(Condition condition, ConditionOutcome outcome) {
	this.outcomes.add(new ConditionAndOutcome(condition, outcome));
}
 

import org.springframework.context.annotation.Condition; //导入依赖的package包/类
public ConditionAndOutcome(Condition condition, ConditionOutcome outcome) {
	this.condition = condition;
	this.outcome = outcome;
}