前言
SpringBoot自动配置原理是基于其大量的条件注解ConditionalOnXXX
常见的@Conditionalxxx开头的注解我们称之为条件注解,常见的条件注解有
class条件注解:@ConditionalOnClass
bean条件注解:@ConditionalOnBean
属性条件注解:@ConditionalOnProperty
…
这几个注解通常会结合使用,一般都是在配置类中使用,SpringBoot各种xxxxAutoCconfiguration都用到了这些注解,这也是SpringBoot自动装配的重要工具。
在自动配置类中有很多Condition相关的注解,以AOP为例:
Configuration(proxyBeanMethods = false)
@ConditionalOnProperty(prefix = "spring.aop", name = "auto", havingValue = "true", matchIfMissing = true)
public class AopAutoConfiguration {
@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(Advice.class)
static class AspectJAutoProxyingConfiguration {
@Configuration(proxyBeanMethods = false)
@EnableAspectJAutoProxy(proxyTargetClass = false)
@ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "false",
matchIfMissing = false)
static class JdkDynamicAutoProxyConfiguration {
}
@Configuration(proxyBeanMethods = false)
@EnableAspectJAutoProxy(proxyTargetClass = true)
@ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "true",
matchIfMissing = true)
static class CglibAutoProxyConfiguration {
}
}
@Configuration(proxyBeanMethods = false)
@ConditionalOnMissingClass("org.aspectj.weaver.Advice")
@ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "true",
matchIfMissing = true)
static class ClassProxyingConfiguration {
ClassProxyingConfiguration(BeanFactory beanFactory) {
if (beanFactory instanceof BeanDefinitionRegistry) {
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry);
AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
}
}
}
}
这里就能看到@ConditionalOnProperty、@ConditionalOnClass、@ConditionalOnMissingClass,另外还有@ConditionalOnBean、@ConditionalOnMissingBean等等很多条件匹配注解。这些注解表示条件匹配才会加载该Bean,以@ConditionalOnProperty为例,表明配置文件中符合条件才会加载对应的Bean,prefix表示在配置文件中的前缀,name表示配置的名称,havingValue表示配置为该值时才匹配,matchIfMissing则是表示没有该配置是否默认加载对应的Bean。其它注解可类比理解记忆,下面主要来分析该注解的实现原理。
这里注解点进去看会发现每个注解上都标注了@Conditional注解,并且value值都对应一个类,比如OnBeanCondition,而这些类都实现了Condition接口,看看其继承体系:
我们还可以自己实现该接口来扩展@Condition注解。
Condition接口中有一个matches方法,这个方法返回true则表示匹配。该方法在ConfigurationClassParser中多处都有调用,也就是刚刚我提醒过的shouldSkip方法,具体实现是在ConditionEvaluator类中:
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;
}
@ConditionalOnXXX等条件注解都是派生注解,那么什么是派生注解呢?
我们打开ConditionalOnClass注解源码,如下:
@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(OnClassCondition.class)
public @interface ConditionalOnClass {
Class<?>[] value() default {};
String[] name() default {};
}
可以看到@ConditionalOnClass注解上面又标注了@Conditional(OnClassCondition.class)注解,因此@ConditionalOnClass是@Conditional的派生注解,@Conditional(OnClassCondition.class)和@ConditionalOnClass注解是等价的,即这两个注解标注在某个配置类上的效果是等价的。
而SpringBoot的自动配置原理正是建立在这些大量的派生条件注解@ConditionalOnXXX之上,而这些条件注解的原理跟Spring的Condition接口有关。
@ConditionalOnProperty注解
简单来讲,一般是在配置类上或者是@Bean修饰的方法上,添加此注解表示一个类是否要被Spring上下文加载,若满足条件则加载,若不满足条件则不加载。
我们在application.properties中配置的各种配置,添加配置之后即生效,就是这么控制的。
主要说一下这个属性matchIfMissing,该属性为true时,配置文件中缺少对应的value或name的对应的属性值,也会注入成功。
app.name=tom
配置类为
@ConditionalOnProperty(prefix = “app”,name=“name”,matchIfMissing = false)
@Configuration
public class ConfigureOne {
public ConfigureOne() {
System.out.println("--------构造ConfigureOne---------");
}
}
不配置havingValue的值
1.假如没有配置这个name的配置
1.1@ConditionalOnProperty(prefix = “app”,name=“name”,matchIfMissing = false)
假如没有配置这个name的配置,若matchIfMissing为false,则不会加载此配置类
假如配置了这个name的配置,若matchIfMissing为false,则会加载此配置类
1.2@ConditionalOnProperty(prefix = “app”,name=“name”,matchIfMissing = true)
假如没有配置这个name的配置,若matchIfMissing为true,则仍会加载此配置类
假如配置了这个name的配置,若matchIfMissing为true,则会加载此配置类
总结,若未配置havingValue的值,matchIfMissing为true则无论是否有配置都会加载配置类,matchIfMissing为false,有配置加载类,无配置不加载类。
配置错误的havingValue的值
2.1@ConditionalOnProperty(prefix = “app”,name=“name”,havingValue = “name1”,matchIfMissing = false)
假如配置了错误的name值,若matchIfMissing为false,配置类不会加载
假如配置了正确的name值,若matchIfMissing为false,配置类会加载
2.2@ConditionalOnProperty(prefix = “app”,name=“name”,havingValue = “name1”,matchIfMissing = true)
假如配置了错误的name值,若matchIfMissing为true,配置类不会加载
假如配置了正确的name值,若matchIfMissing为true,配置类会加载
总结,只要配置了正确的havingValue值,无论matchIfMissing怎么设置,都会加载,只要配置的havingValue值不正确,无论
matchIfMissing怎么设置,都不会加载。
Condition接口源码
分析Condition接口源码前先看下如何自定义ConditionalOnXXX注解,举个栗子,比如自定义一个@ConditionalOnLinux注解,该注解只有在其属性environment是"linux"才会创建相关的bean。定义了以下代码:
/**
* 实现spring 的Condition接口,并且重写matches()方法,如果@ConditionalOnLinux的注解属性environment是linux就返回true
*
*/
public class LinuxCondition implements Condition {
@Override
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
// 获得注解@ConditionalOnLinux的所有属性
List<AnnotationAttributes> allAnnotationAttributes = annotationAttributesFromMultiValueMap(
metadata.getAllAnnotationAttributes(
ConditionalOnLinux.class.getName()));
for (AnnotationAttributes annotationAttributes : allAnnotationAttributes) {
// 获得注解@ConditionalOnLinux的environment属性
String environment = annotationAttributes.getString("environment");
// 若environment等于linux,则返回true
if ("linux".equals(environment)) {
return true;
}
}
return false;
}
}
@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(LinuxCondition.class)
public @interface ConditionalOnLinux {
// 标注是哪个环境
String environment() default "";
}
@Configuration
public class ConditionConfig {
// 只有`@ConditionalOnLinux`的注解属性`environment`是"linux"时才会创建bean
@Bean
@ConditionalOnLinux(environment = "linux")
public Environment linuxEnvironment() {
return new LinuxEnvironment();
}
}
LinuxCondition实现了Condition接口并实现了matches方法,而matches方法则判断@ConditionalOnLinux的注解属性environment是否"linux",是则返回true,否则false。
然后我们再定义了一个注解@ConditionalOnLinux,这个注解是@Conditional的派生注解,与@Conditional(LinuxCondition.class)等价,注意@ConditionalOnLinux注解定义了一个属性environment。而我们最终可以利用LinuxCondition的matches方法中的参数AnnotatedTypeMetadata来获取@ConditionalOnLinux的注解属性environment的值,从而用来判断值是否为linux"。
最后我们又定义了一个配置类ConditionConfig,在linuxEnvironment方法上标注了@ConditionalOnLinux(environment = “linux”)。因此,这里只有 LinuxCondition的matches方法返回true才会创建bean。
Condition接口的源码:
@FunctionalInterface
public interface Condition {
boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata);
}
Condition接口主要有一个matches方法,该方法决定了是否要注册相应的bean对象。其中matches方法中有两个参数,参数类型分别是ConditionContext和AnnotatedTypeMetadata,这两个参数非常重要。它们分别用来获取一些环境信息和注解元数据从而用在matches方法中判断是否符合条件。
ConditionContext,顾名思义,主要是跟Condition的上下文有关,主要用来获取Registry,BeanFactory,Environment,ResourceLoader和ClassLoader等。那么获取这些用来干什么呢?举个栗子,比如OnResourceCondition需要靠ConditionContext来获取ResourceLoader来加载指定资源,OnClassCondition需要靠ConditionContext来获取ClassLoader来加载指定类等,下面看下其源码:
public interface ConditionContext {
BeanDefinitionRegistry getRegistry();
@Nullable
ConfigurableListableBeanFactory getBeanFactory();
Environment getEnvironment();
ResourceLoader getResourceLoader();
@Nullable
ClassLoader getClassLoader();
}
AnnotatedTypeMetadata,这个跟注解元数据有关,利用AnnotatedTypeMetadata可以拿到某个注解的一些元数据,而这些元数据就包含了某个注解里面的属性,比如前面的栗子,利用AnnotatedTypeMetadata可以拿到@ConditionalOnLinux的注解属性environment的值。下面看下其源码:
public interface AnnotatedTypeMetadata {
boolean isAnnotated(String annotationName);
Map<String, Object> getAnnotationAttributes(String annotationName);
Map<String, Object> getAnnotationAttributes(String annotationName, boolean classValuesAsString);
MultiValueMap<String, Object> getAllAnnotationAttributes(String annotationName);
MultiValueMap<String, Object> getAllAnnotationAttributes(String annotationName, boolean classValuesAsString);
}
@ConditionalOnLinux注解真正起作用的是Condition接口的具体实现类LinuxCondition的matches方法,
在ConditionEvaluator的shouldSkip方法中调用了LinuxCondition的matches方法,自然我们再去看看ConditionEvaluator的shouldSkip的方法执行了什么逻辑。
// 这个方法主要是如果是解析阶段则跳过,如果是注册阶段则不跳过
public boolean shouldSkip(@Nullable AnnotatedTypeMetadata metadata, @Nullable ConfigurationPhase phase) {
// 若没有被@Conditional或其派生注解所标注,则不会跳过
if (metadata == null || !metadata.isAnnotated(Conditional.class.getName())) {
return false;
}
// 没有指定phase,注意phase可以分为PARSE_CONFIGURATION或REGISTER_BEAN类型
if (phase == null) {
// 若标有@Component,@Import,@Bean或@Configuration等注解的话,则说明是PARSE_CONFIGURATION类型
if (metadata instanceof AnnotationMetadata &&
ConfigurationClassUtils.isConfigurationCandidate((AnnotationMetadata) metadata)) {
return shouldSkip(metadata, ConfigurationPhase.PARSE_CONFIGURATION);
}
// 否则是REGISTER_BEAN类型
return shouldSkip(metadata, ConfigurationPhase.REGISTER_BEAN);
}
List<Condition> conditions = new ArrayList<>();
// TODO 获得所有标有@Conditional注解或其派生注解里面的Condition接口实现类并实例化成对象。
// 比如@Conditional(OnBeanCondition.class)则获得OnBeanCondition.class,OnBeanCondition.class往往实现了Condition接口
for (String[] conditionClasses : getConditionClasses(metadata)) {
// 将类实例化成对象
for (String conditionClass : conditionClasses) {
Condition condition = getCondition(conditionClass, this.context.getClassLoader());
conditions.add(condition);
}
}
// 排序,即按照Condition的优先级进行排序
AnnotationAwareOrderComparator.sort(conditions);
for (Condition condition : conditions) {
ConfigurationPhase requiredPhase = null;
if (condition instanceof ConfigurationCondition) {
// 从condition中获得对bean是解析还是注册
requiredPhase = ((ConfigurationCondition) condition).getConfigurationPhase();
}
// 若requiredPhase为null或获取的阶段类型正是当前阶段类型且不符合condition的matches条件,则跳过
if ((requiredPhase == null || requiredPhase == phase) && !condition.matches(this.context, metadata)) {
return true;
}
}
return false;
}
shouldSkip这个方法执行的逻辑主要是如果是解析阶段则跳过,如果是注册阶段则不跳过;如果是在注册阶段即REGISTER_BEAN阶段的话,此时会得到所有的Condition接口的具体实现类并实例化这些实现类,然后再执行下面关键的代码进行判断是否需要跳过。
if ((requiredPhase == null || requiredPhase == phase) && !condition.matches(this.context, metadata)) {
return true;
}
上面代码最重要的逻辑是调用了Condition接口的具体实现类的matches方法,若matches返回false,则跳过,不进行注册bean的操作;若matches返回true,则不跳过,进行注册bean的操作;
Spring的内置Condition接口实现类
发现Spring内置的Condition接口的具体实现类虽然有多个,但只有ProfileCondition不是测试相关的,因此可以说真正的内置的Condition接口的具体实现类只有ProfileCondition一个,非常非常少,这跟SpringBoot的大量派生条件注解形成了鲜明的对比。ProfileCondition大家都知道,是跟环境有关,比如我们平时一般有dev,test和prod环境,而ProfileCondition就是判断我们项目配置了哪个环境的。下面是ProfileCondition的源码
class ProfileCondition implements Condition {
@Override
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
MultiValueMap<String, Object> attrs = metadata.getAllAnnotationAttributes(Profile.class.getName());
if (attrs != null) {
for (Object value : attrs.get("value")) {
if (context.getEnvironment().acceptsProfiles(Profiles.of((String[]) value))) {
return true;
}
}
return false;
}
return true;
}
}
OnXXXCondition继承了SpringBootCondition
SpringBoot条件注解的基类,处于整个类图的中心,它实现了Condition接口
SpringBootConditon实现了Condition接口,作为SpringBoot众多条件注解OnXXXCondtion的父类,它的作用主要就是打印一些条件注解评估报告的日志,比如打印哪些配置类是符合条件注解的,哪些是不符合的。
因为SpringBootConditon实现了Condition接口,也实现了matches方法,因此该方法同样也是被ConditionEvaluator的shouldSkip方法中调用,因此我们就以SpringBootConditon的matches方法为入口去进行分析。直接上代码:
// SpringBootCondition.java
public final boolean matches(ConditionContext context,
AnnotatedTypeMetadata metadata) {
// 得到metadata的类名或方法名
String classOrMethodName = getClassOrMethodName(metadata);
try {
// 判断每个配置类的每个条件注解@ConditionalOnXXX是否满足条件,然后记录到ConditionOutcome结果中
// 注意getMatchOutcome是一个抽象模板方法,交给OnXXXCondition子类去实现
ConditionOutcome outcome = getMatchOutcome(context, metadata);
// 打印condition评估的日志,哪些条件注解@ConditionalOnXXX是满足条件的,哪些是不满足条件的,这些日志都打印出来
logOutcome(classOrMethodName, outcome);
// 除了打印日志外,这些是否匹配的信息还要记录到ConditionEvaluationReport中
recordEvaluation(context, classOrMethodName, outcome);
// 最后返回@ConditionalOnXXX是否满足条件
return outcome.isMatch();
}
catch (NoClassDefFoundError ex) {
throw new IllegalStateException(
"Could not evaluate condition on " + classOrMethodName + " due to "
+ ex.getMessage() + " not "
+ "found. Make sure your own configuration does not rely on "
+ "that class. This can also happen if you are "
+ "@ComponentScanning a springframework package (e.g. if you "
+ "put a @ComponentScan in the default package by mistake)",
ex);
}
catch (RuntimeException ex) {
throw new IllegalStateException(
"Error processing condition on " + getName(metadata), ex);
}
}
上面代码的注释已经非常详细,我们知道了SpringBootCondition抽象了所有其具体实现类OnXXXCondition的共有逻辑–condition评估信息打印,最重要的是封装了一个模板方法getMatchOutcome(context, metadata),留给各个OnXXXCondition具体子类去覆盖实现属于自己的判断逻辑,然后再返回相应的匹配结果给SpringBootCondition用于日志打印。
因此我们知道了SpringBootCondition其实就是用来打印condition评估信息的,对于其他枝节方法我们不必追究过深,免得丢了主线。我们现在的重点是放在交给OnXXXCondition子类实现的模板方法上getMatchOutcome(context, metadata);,因为这个方法将会由很多OnXXXCondition覆盖重写判断逻辑,这里是我们接下来分析的重点。
因为SpringBootCondition有众多具体实现类,下面只挑OnWebApplicationCondition进行讲解
OnWebApplicationCondition同样继承了FilteringSpringBootCondition父类,覆盖了父类FilteringSpringBootCondition的getOutcomes方法。而FilteringSpringBootCondition又是SpringBootCondition的子类,FilteringSpringBootCondition跟自动配置类过滤有关,这里先不分析。值得注意的是OnWebApplicationCondition同样重写了SpringBootCondition的getMatchOutcome方法,用来判断当前应用是否web应用。同时是OnWebApplicationCondition是@ConditionalOnWebApplication的条件类。
同样,先来看OnWebApplicationCondition重写SpringBootCondition的getMatchOutcome方法:
public ConditionOutcome getMatchOutcome(ConditionContext context,
AnnotatedTypeMetadata metadata) {
// 配置类是否标注有@ConditionalOnWebApplication注解
boolean required = metadata
.isAnnotated(ConditionalOnWebApplication.class.getName());
// 调用isWebApplication方法返回匹配结果
ConditionOutcome outcome = isWebApplication(context, metadata, required);
// 若有标注@ConditionalOnWebApplication但不符合条件,则返回不匹配
if (required && !outcome.isMatch()) {
return ConditionOutcome.noMatch(outcome.getConditionMessage());
}
// 若没有标注@ConditionalOnWebApplication但符合条件,则返回不匹配
if (!required && outcome.isMatch()) {
return ConditionOutcome.noMatch(outcome.getConditionMessage());
}
// 这里返回匹配的情况,TODO 不过有个疑问:如果没有标注@ConditionalOnWebApplication注解,又不符合条件的话,也会执行到这里,返回匹配?
return ConditionOutcome.match(outcome.getConditionMessage());
}
上面代码的逻辑很简单,主要是调用isWebApplication方法来判断当前应用是否是web应用。因此,我们再来看下isWebApplication方法:
private ConditionOutcome isWebApplication(ConditionContext context,
AnnotatedTypeMetadata metadata, boolean required) {
// 调用deduceType方法判断是哪种类型,其中有SERVLET,REACTIVE和ANY类型,其中ANY表示了SERVLET或REACTIVE类型
switch (deduceType(metadata)) {
// SERVLET类型
case SERVLET:
return isServletWebApplication(context);
// REACTIVE类型
case REACTIVE:
return isReactiveWebApplication(context);
default:
return isAnyWebApplication(context, required);
}
}
在isWebApplication方法中,首先从@ConditionalOnWebApplication注解中获取其定义了什么类型,然后根据不同的类型进入不同的判断逻辑。这里我们只看下SERVLET的情况判断处理,看代码:
private ConditionOutcome isServletWebApplication(ConditionContext context) {
ConditionMessage.Builder message = ConditionMessage.forCondition("");
// 若classpath中不存在org.springframework.web.context.support.GenericWebApplicationContext.class,则返回不匹配
if (!ClassNameFilter.isPresent(SERVLET_WEB_APPLICATION_CLASS,
context.getClassLoader())) {
return ConditionOutcome.noMatch(
message.didNotFind("servlet web application classes").atAll());
}
// 若classpath中存在org.springframework.web.context.support.GenericWebApplicationContext.class,那么又分为以下几种匹配的情况
// session
if (context.getBeanFactory() != null) {
String[] scopes = context.getBeanFactory().getRegisteredScopeNames();
if (ObjectUtils.containsElement(scopes, "session")) {
return ConditionOutcome.match(message.foundExactly("'session' scope"));
}
}
// ConfigurableWebEnvironment
if (context.getEnvironment() instanceof ConfigurableWebEnvironment) {
return ConditionOutcome
.match(message.foundExactly("ConfigurableWebEnvironment"));
}
// WebApplicationContext
if (context.getResourceLoader() instanceof WebApplicationContext) {
return ConditionOutcome.match(message.foundExactly("WebApplicationContext"));
}
// 若以上三种都不匹配的话,则说明不是一个servlet web application
return ConditionOutcome.noMatch(message.because("not a servlet web application"));
}
对于是SERVLET的情况,首先根据classpath中是否存在org.springframework.web.context.support.GenericWebApplicationContext.class,如果不存在该类,则直接返回不匹配;若存在的话那么又分为以下几种匹配的情况:
session
ConfigurableWebEnvironment
WebApplicationContext
若上面三种情况都不匹配,则说明不是一个servlet web application。
扩展SpringBootCondition
import java.lang.annotation.*;
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(MyConditional.class)
public @interface MyConditionalIAnnotation {
String key();
String value();
}
import org.springframework.boot.autoconfigure.condition.ConditionOutcome;
import org.springframework.boot.autoconfigure.condition.SpringBootCondition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.context.annotation.Conditional;
import org.springframework.core.type.AnnotatedTypeMetadata;
import java.util.Map;
public class MyConditional extends SpringBootCondition {
@Override
public ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata metadata) {
Map<String, Object> annotationAttributes = metadata.getAnnotationAttributes(MyConditionalIAnnotation.class.getName());
Object key = annotationAttributes.get("key");//
Object value = annotationAttributes.get("value");
if(key == null || value == null){
return new ConditionOutcome(false, "error");
}
//获取environment中的值
String key1 = context.getEnvironment().getProperty(key.toString());
if (value.equals(key1)) {
//如果environment中的值与指定的value一致,则返回true
return new ConditionOutcome(true, "ok");
}
return new ConditionOutcome(false, "error");
}
}
import org.apache.log4j.Logger;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@Configuration
public class MyConditionalConfig {
public static Logger logger=Logger.getLogger(MyConditionalService.class);
/**
* 判断MyConditional 是否符合条件,是则运行MyConditionalService
* @return
*/
@MyConditionalIAnnotation(key = "com.example.conditional", value = "lbl")
@ConditionalOnClass(MyConditionalService.class)
@Bean
public MyConditionalService initMyConditionService() {
logger.info("MyConditionalService已加载。");
return new MyConditionalService();
}
}
配置文件:application.propeties
spring.application.name=gateway
server.port=8084
#conditional 动态配置,判断该值是否等于lbl,是则创建MyConditionalService实例
com.example.conditional=lbl
#支持自定义aop
spring.aop.auto=true