@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
public @interface Conditional {/*** All {@link Condition}s that must {@linkplain Condition#matches match}* in order for the component to be registered.*/Class<? extends Condition>[] value();}

public interface Condition {/*** Determine if the condition matches.* @param context the condition context* @param metadata metadata of the {@link org.springframework.core.type.AnnotationMetadata class}* or {@link org.springframework.core.type.MethodMetadata method} being checked.* @return {@code true} if the condition matches and the component can be registered* or {@code false} to veto registration.*/boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata);}

@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(OnBeanCondition.class)
public @interface ConditionalOnBean {/*** The class type of bean that should be checked. The condition matches when all of* the classes specified are contained in the {@link ApplicationContext}.* @return the class types of beans to check*/Class<?>[] value() default {};/*** The class type names of bean that should be checked. The condition matches when all* of the classes specified are contained in the {@link ApplicationContext}.* @return the class type names of beans to check*/String[] type() default {};/*** The annotation type decorating a bean that should be checked. The condition matches* when all of the annotations specified are defined on beans in the* {@link ApplicationContext}.* @return the class-level annotation types to check*/Class<? extends Annotation>[] annotation() default {};/*** The names of beans to check. The condition matches when all of the bean names* specified are contained in the {@link ApplicationContext}.* @return the name of beans to check*/String[] name() default {};/*** Strategy to decide if the application context hierarchy (parent contexts) should be* considered.* @return the search strategy*/SearchStrategy search() default SearchStrategy.ALL;}

@Order(Ordered.LOWEST_PRECEDENCE)
class OnBeanCondition extends SpringBootCondition implements ConfigurationCondition {/*** Bean definition attribute name for factory beans to signal their product type (if* known and it can't be deduced from the factory bean class).*/public static final String FACTORY_BEAN_OBJECT_TYPE = BeanTypeRegistry.FACTORY_BEAN_OBJECT_TYPE;@Overridepublic ConfigurationPhase getConfigurationPhase() {return ConfigurationPhase.REGISTER_BEAN;}@Overridepublic ConditionOutcome getMatchOutcome(ConditionContext context,AnnotatedTypeMetadata metadata) {ConditionMessage matchMessage = ConditionMessage.empty();if (metadata.isAnnotated(ConditionalOnBean.class.getName())) {BeanSearchSpec spec = new BeanSearchSpec(context, metadata,ConditionalOnBean.class);MatchResult matchResult = getMatchingBeans(context, spec);if (!matchResult.isAllMatched()) {String reason = createOnBeanNoMatchReason(matchResult);return ConditionOutcome.noMatch(ConditionMessage.forCondition(ConditionalOnBean.class, spec).because(reason));}matchMessage = matchMessage.andCondition(ConditionalOnBean.class, spec).found("bean", "beans").items(Style.QUOTE, matchResult.getNamesOfAllMatches());}if (metadata.isAnnotated(ConditionalOnSingleCandidate.class.getName())) {BeanSearchSpec spec = new SingleCandidateBeanSearchSpec(context, metadata,ConditionalOnSingleCandidate.class);MatchResult matchResult = getMatchingBeans(context, spec);if (!matchResult.isAllMatched()) {return ConditionOutcome.noMatch(ConditionMessage.forCondition(ConditionalOnSingleCandidate.class, spec).didNotFind("any beans").atAll());}else if (!hasSingleAutowireCandidate(context.getBeanFactory(),matchResult.getNamesOfAllMatches(),spec.getStrategy() == SearchStrategy.ALL)) {return ConditionOutcome.noMatch(ConditionMessage.forCondition(ConditionalOnSingleCandidate.class, spec).didNotFind("a primary bean from beans").items(Style.QUOTE, matchResult.getNamesOfAllMatches()));}matchMessage = matchMessage.andCondition(ConditionalOnSingleCandidate.class, spec).found("a primary bean from beans").items(Style.QUOTE, matchResult.namesOfAllMatches);}if (metadata.isAnnotated(ConditionalOnMissingBean.class.getName())) {BeanSearchSpec spec = new BeanSearchSpec(context, metadata,ConditionalOnMissingBean.class);MatchResult matchResult = getMatchingBeans(context, spec);if (matchResult.isAnyMatched()) {String reason = createOnMissingBeanNoMatchReason(matchResult);return ConditionOutcome.noMatch(ConditionMessage.forCondition(ConditionalOnMissingBean.class, spec).because(reason));}matchMessage = matchMessage.andCondition(ConditionalOnMissingBean.class, spec).didNotFind("any beans").atAll();}return ConditionOutcome.match(matchMessage);}
}

@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(OnClassCondition.class)
public @interface ConditionalOnClass {/*** The classes that must be present. Since this annotation parsed by loading class* bytecode it is safe to specify classes here that may ultimately not be on the* classpath.* @return the classes that must be present*/Class<?>[] value() default {};/*** The classes names that must be present.* @return the class names that must be present.*/String[] name() default {};}

@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(OnCloudPlatformCondition.class)
public @interface ConditionalOnCloudPlatform {/*** The {@link CloudPlatform cloud platform} that must be active.* @return the expected cloud platform*/CloudPlatform value();}

/*** Configuration annotation for a conditional element that depends on the value of a SpEL* expression.** @author Dave Syer*/
@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.TYPE, ElementType.METHOD })
@Documented
@Conditional(OnExpressionCondition.class)
public @interface ConditionalOnExpression {/*** The SpEL expression to evaluate. Expression should return {@code true} if the* condition passes or {@code false} if it fails.* @return the SpEL expression*/String value() default "true";}

/*** {@link Conditional} that matches based on the JVM version the application is running* on.** @author Oliver Gierke* @author Phillip Webb* @author Andy Wilkinson* @since 1.1.0*/
@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(OnJavaCondition.class)
public @interface ConditionalOnJava {/*** Configures whether the value configured in {@link #value()} shall be considered the* upper exclusive or lower inclusive boundary. Defaults to* {@link Range#EQUAL_OR_NEWER}.* @return the range*/Range range() default Range.EQUAL_OR_NEWER;/*** The {@link JavaVersion} to check for. Use {@link #range()} to specify whether the* configured value is an upper-exclusive or lower-inclusive boundary.* @return the java version*/JavaVersion value();/*** Range options.*/enum Range {/*** Equal to, or newer than the specified {@link JavaVersion}.*/EQUAL_OR_NEWER,/*** Older than the specified {@link JavaVersion}.*/OLDER_THAN}/*** Java versions.*/enum JavaVersion {/*** Java 1.9.*/NINE(9, "1.9", "java.security.cert.URICertStoreParameters"),/*** Java 1.8.*/EIGHT(8, "1.8", "java.util.function.Function");private final int value;private final String name;private final boolean available;JavaVersion(int value, String name, String className) {this.value = value;this.name = name;this.available = ClassUtils.isPresent(className, getClass().getClassLoader());}/*** Determines if this version is within the specified range of versions.* @param range the range* @param version the bounds of the range* @return if this version is within the specified range*/public boolean isWithin(Range range, JavaVersion version) {Assert.notNull(range, "Range must not be null");Assert.notNull(version, "Version must not be null");switch (range) {case EQUAL_OR_NEWER:return this.value >= version.value;case OLDER_THAN:return this.value < version.value;}throw new IllegalStateException("Unknown range " + range);}@Overridepublic String toString() {return this.name;}/*** Returns the {@link JavaVersion} of the current runtime.* @return the {@link JavaVersion}*/public static JavaVersion getJavaVersion() {for (JavaVersion candidate : JavaVersion.values()) {if (candidate.available) {return candidate;}}return EIGHT;}}}

/*** {@link Conditional} that matches based on the availability of a JNDI* {@link InitialContext} and the ability to lookup specific locations.** @author Phillip Webb* @since 1.2.0*/
@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(OnJndiCondition.class)
public @interface ConditionalOnJndi {/*** JNDI Locations, one of which must exist. If no locations are specific the condition* matches solely based on the presence of an {@link InitialContext}.* @return the JNDI locations*/String[] value() default {};}

/*** {@link Conditional} that only matches when the specified bean classes and/or names are* not already contained in the {@link BeanFactory}.* <p>* The condition can only match the bean definitions that have been processed by the* application context so far and, as such, it is strongly recommended to use this* condition on auto-configuration classes only. If a candidate bean may be created by* another auto-configuration, make sure that the one using this condition runs after.** @author Phillip Webb* @author Andy Wilkinson*/
@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(OnBeanCondition.class)
public @interface ConditionalOnMissingBean {/*** The class type of bean that should be checked. The condition matches when each* class specified is missing in the {@link ApplicationContext}.* @return the class types of beans to check*/Class<?>[] value() default {};/*** The class type names of bean that should be checked. The condition matches when* each class specified is missing in the {@link ApplicationContext}.* @return the class type names of beans to check*/String[] type() default {};/*** The class type of beans that should be ignored when identifying matching beans.* @return the class types of beans to ignore* @since 1.2.5*/Class<?>[] ignored() default {};/*** The class type names of beans that should be ignored when identifying matching* beans.* @return the class type names of beans to ignore* @since 1.2.5*/String[] ignoredType() default {};/*** The annotation type decorating a bean that should be checked. The condition matches* when each annotation specified is missing from all beans in the* {@link ApplicationContext}.* @return the class-level annotation types to check*/Class<? extends Annotation>[] annotation() default {};/*** The names of beans to check. The condition matches when each bean name specified is* missing in the {@link ApplicationContext}.* @return the name of beans to check*/String[] name() default {};/*** Strategy to decide if the application context hierarchy (parent contexts) should be* considered.* @return the search strategy*/SearchStrategy search() default SearchStrategy.ALL;}

/*** {@link Conditional} that only matches when the specified classes are not on the* classpath.** @author Dave Syer*/
@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(OnClassCondition.class)
public @interface ConditionalOnMissingClass {/*** The names of the classes that must not be present.* @return the names of the classes that must not be present*/String[] value() default {};}

/*** {@link Conditional} that only matches when the application context is a not a web* application context.** @author Dave Syer*/
@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(OnWebApplicationCondition.class)
public @interface ConditionalOnNotWebApplication {}

/*** {@link Conditional} that checks if the specified properties have a specific value. By* default the properties must be present in the {@link Environment} and* <strong>not</strong> equal to {@code false}. The {@link #havingValue()} and* {@link #matchIfMissing()} attributes allow further customizations.** <p>* The {@link #havingValue} attribute can be used to specify the value that the property* should have. The table below shows when a condition matches according to the property* value and the {@link #havingValue()} attribute:** <table summary="having values" border="1">* <tr>* <th>Property Value</th>* <th>{@code havingValue=""}</th>* <th>{@code havingValue="true"}</th>* <th>{@code havingValue="false"}</th>* <th>{@code havingValue="foo"}</th>* </tr>* <tr>* <td>{@code "true"}</td>* <td>yes</td>* <td>yes</td>* <td>no</td>* <td>no</td>* </tr>* <tr>* <td>{@code "false"}</td>* <td>no</td>* <td>no</td>* <td>yes</td>* <td>no</td>* </tr>* <tr>* <td>{@code "foo"}</td>* <td>yes</td>* <td>no</td>* <td>no</td>* <td>yes</td>* </tr>* </table>** <p>* If the property is not contained in the {@link Environment} at all, the* {@link #matchIfMissing()} attribute is consulted. By default missing attributes do not* match.** @author Maciej Walkowiak* @author Stephane Nicoll* @author Phillip Webb* @since 1.1.0*/
@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.TYPE, ElementType.METHOD })
@Documented
@Conditional(OnPropertyCondition.class)
public @interface ConditionalOnProperty {/*** Alias for {@link #name()}.* @return the names*/String[] value() default {};/*** A prefix that should be applied to each property. The prefix automatically ends* with a dot if not specified.* @return the prefix*/String prefix() default "";/*** The name of the properties to test. If a prefix has been defined, it is applied to* compute the full key of each property. For instance if the prefix is* {@code app.config} and one value is {@code my-value}, the fully key would be* {@code app.config.my-value}* <p>* Use the dashed notation to specify each property, that is all lower case with a "-"* to separate words (e.g. {@code my-long-property}).* @return the names*/String[] name() default {};/*** The string representation of the expected value for the properties. If not* specified, the property must <strong>not</strong> be equals to {@code false}.* @return the expected value*/String havingValue() default "";/*** Specify if the condition should match if the property is not set. Defaults to* {@code false}.* @return if should match if the property is missing*/boolean matchIfMissing() default false;/*** If relaxed names should be checked. Defaults to {@code true}.* @return if relaxed names are used*/boolean relaxedNames() default true;}

/*** {@link Conditional} that only matches when the specified resources are on the* classpath.** @author Dave Syer*/
@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(OnResourceCondition.class)
public @interface ConditionalOnResource {/*** The resources that must be present.* @return the resource paths that must be present.*/String[] resources() default {};}

/*** {@link Conditional} that only matches when the specified bean class is already* contained in the {@link BeanFactory} and a single candidate can be determined.* <p>* The condition will also match if multiple matching bean instances are already contained* in the {@link BeanFactory} but a primary candidate has been defined; essentially, the* condition match if auto-wiring a bean with the defined type will succeed.* <p>* The condition can only match the bean definitions that have been processed by the* application context so far and, as such, it is strongly recommended to use this* condition on auto-configuration classes only. If a candidate bean may be created by* another auto-configuration, make sure that the one using this condition runs after.** @author Stephane Nicoll* @since 1.3.0*/
@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(OnBeanCondition.class)
public @interface ConditionalOnSingleCandidate {/*** The class type of bean that should be checked. The condition match if the class* specified is contained in the {@link ApplicationContext} and a primary candidate* exists in case of multiple instances.* <p>* This attribute may <strong>not</strong> be used in conjunction with {@link #type()}* , but it may be used instead of {@link #type()}.* @return the class type of the bean to check*/Class<?> value() default Object.class;/*** The class type name of bean that should be checked. The condition matches if the* class specified is contained in the {@link ApplicationContext} and a primary* candidate exists in case of multiple instances.* <p>* This attribute may <strong>not</strong> be used in conjunction with* {@link #value()}, but it may be used instead of {@link #value()}.* @return the class type name of the bean to check*/String type() default "";/*** Strategy to decide if the application context hierarchy (parent contexts) should be* considered.* @return the search strategy*/SearchStrategy search() default SearchStrategy.ALL;}

/*** {@link Conditional} that matches when the application is a web application. By default,* any web application will match but it can be narrowed using the {@link #type()}* attribute.** @author Dave Syer* @author Stephane Nicoll*/
@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(OnWebApplicationCondition.class)
public @interface ConditionalOnWebApplication {/*** The required type of the web application.* @return the required web application type*/Type type() default Type.ANY;/*** Available application types.*/enum Type {/*** Any web application will match.*/ANY,/*** Only servlet-based web application will match.*/SERVLET,/*** Only reactive-based web application will match.*/REACTIVE}}