spring-boot @ConditionalOnClass如何工作？（spring boot classpath）

25-02-27 11

本文的目的是介绍spring-boot@ConditionalOnClass如何工作？的详细情况，特别关注springbootclasspath的相关信息。我们将通过专业的研究、有关数据的分析等多种方

本文的目的是介绍spring-boot @ConditionalOnClass如何工作？的详细情况，特别关注spring boot classpath的相关信息。我们将通过专业的研究、有关数据的分析等多种方式，为您呈现一个全面的了解spring-boot @ConditionalOnClass如何工作？的机会，同时也不会遗漏关于006-Spring Boot自动配置-Condition、Conditional、Spring提供的Conditional自动配置、@Conditional、@ConditionalOnClass 等条件注解的作用、org.springframework.boot.autoconfigure.condition.ConditionalOnBean的实例源码、org.springframework.boot.autoconfigure.condition.ConditionalOnClass的实例源码的知识。

本文目录一览：

spring-boot @ConditionalOnClass如何工作？（spring boot classpath）
006-Spring Boot自动配置-Condition、Conditional、Spring提供的Conditional自动配置
@Conditional、@ConditionalOnClass 等条件注解的作用
org.springframework.boot.autoconfigure.condition.ConditionalOnBean的实例源码
org.springframework.boot.autoconfigure.condition.ConditionalOnClass的实例源码

spring-boot @ConditionalOnClass如何工作？（spring boot classpath）

@ConditionalOnClass注释如何工作？

我的目标是仅在jar提供此类的类包含在类路径中时才加载特定的bean 。

我以为我可以一个注释@Bean与@ConditionalOnClass(MyService.class)和Maven作为可选声明依赖性：

<dependency>    <groupId>de.my</groupId>    <artifactId>my-framework<artifactId>    <optional>true</optional></dependency>@Bean@ConditionalOnClass(MyService.class)public MyConditionalBean statistics() {    return new MyConditionalBean();}

现在，任何具有my-frameworkas依赖关系的人都应该自动连接该bean。但是没有依赖项的任何人都应该跳过它。

但是，当我启动该应用程序时，出现以下错误：

Caused by: java.lang.ClassNotFoundException: de.MyService.class    at org.apache.catalina.loader.WebappClassLoader.loadClass(WebappClassLoader.java:1702) ~[catalina.jar:7.0.50]    at org.apache.catalina.loader.WebappClassLoader.loadClass(WebappClassLoader.java:1547) ~[catalina.jar:7.0.50]

所以我可能做错了。然后，如何在依赖关系jar和类路径中包含的类的条件下创建bean？

从春季文档：

必须存在的类。由于此注释是通过加载类字节码解析的，因此可以在此处指定最终可能不在类路径中的类是安全的。

但是错误状态有所不同…

答案1

小编典典

接得好！

您可以在@Bean方法级别使用，但在这种情况下，您必须将您的类指定为String文字：

@Bean@ConditionalOnClass(name ="de.MyService")public MyConditionalBean statistics() {    return new MyConditionalBean();}

我还没有记住“为什么”，但是它来自Spring Boot源代码的现有代码。

006-Spring Boot自动配置-Condition、Conditional、Spring提供的Conditional自动配置

一、接口Condition、Conditional（原理）

主要提供一下方法

boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata);

true：表示装配

false：表示不装配

1.1、Conditional

　　在Spring4中引入，其主要作用就是判断条件是否满足，从而决定是否初始化并向容器注册Bean

注解：Conditional() 参数是数组，数组内的都是true才装配

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
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();

}

View Code

通常配合使用。

示例：

接口：EncodingConvert

package com.lhx.spring.springboot_auto_config;

public interface EncodingConvert {

}

View Code

接口实现一：UTF8EncodingConvert

package com.lhx.spring.springboot_auto_config;

public class UTF8EncodingConvert implements EncodingConvert {

}

View Code

接口实现二：GBKEncodingConvert

package com.lhx.spring.springboot_auto_config;

public class GBKEncodingConvert implements EncodingConvert {

}

View Code

配置类：

package com.lhx.spring.springboot_auto_config;

import org.springframework.boot.SpringBootConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;

@SpringBootConfiguration
public class EncodingConvertConfiguration {
    @Bean
    public EncodingConvert createGBKEncodingConvert() {
        return new GBKEncodingConvert();
    }

    @Bean
    public EncodingConvert createUTF8EncodingConvert() {
        return new UTF8EncodingConvert();
    }
}

View Code

App：

package com.lhx.spring.springboot_auto_config;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.Conditional;

@SpringBootApplication
public class App {
    @Bean
    public Runnable createRunnable() {
        return () -> {
            System.out.println("spring boot is running");
        };
    }

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(App.class, args);
        context.getBean(Runnable.class).run();
        //可以通过启动参数修改-Dfile.encoding=GBK
        System.out.println(System.getProperty("file.encoding"));
        System.out.println(context.getBeansOfType(EncodingConvert.class));
        context.close();
    }
}

View Code

此时，会发现连个接口实现都会被装配进来。

UTF8Condition实现Condition接口

package com.lhx.spring.springboot_auto_config;

import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;

public class UTF8Condition implements Condition {

    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        String encoding = System.getProperty("file.encoding");
        if (encoding != null) {
            return "utf-8".equalsIgnoreCase(encoding);
        }
        return false;
    }

}

View Code

GBKCondition实现Condition接口

package com.lhx.spring.springboot_auto_config;

import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;

public class GBKCondition implements Condition {

    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        String encoding = System.getProperty("file.encoding");
        if (encoding != null) {
            return "gbk".equalsIgnoreCase(encoding);
        }
        return false;
    }

}

View Code

修改配置类

package com.lhx.spring.springboot_auto_config;

import org.springframework.boot.SpringBootConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;

@SpringBootConfiguration
public class EncodingConvertConfiguration {
    @Bean
    @Conditional(GBKCondition.class)
    public EncodingConvert createGBKEncodingConvert() {
        return new GBKEncodingConvert();
    }

    @Bean
    @Conditional(UTF8Condition.class)
    public EncodingConvert createUTF8EncodingConvert() {
        return new UTF8EncodingConvert();
    }
}

View Code

此时，会发现会根据file.encoding值来装配接口类。

可在启动参数增加

　　-Dfile.encoding=GBK　　

然后调试，发现装配类也变了

注意：@Conditional也可以作用在类上

二、Spring提供的Conditional自动配置

jar：spring-boot-autoconfigure中，org.springframework.boot.autoconfigure.condition;即spring-boot提供

ConditionalOnBean：当存在某个bean时候装配

ConditionalOnMissingBean：当不存在某个bean时候装配注解的bean

ConditionalOnClass：当classpath有才装配

ConditionalOnExpression：

ConditionalOnJava：JDK版本符合时候才装配

ConditionalOnNotWebApplication：不是web环境才装配

ConditionalOnWebApplication：是web环境才装配

ConditionalOnResource：资源存在才装配

ConditionalOnProperty：配置存在才装配

2.1、ConditionalOnProperty 配置存在匹配时候才配置

增加配置类

package com.lhx.spring.springboot_auto_config;

import org.springframework.boot.SpringBootConfiguration;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Bean;

@SpringBootConfiguration
public class UserConfiguration {

    @Bean
    @ConditionalOnProperty(name = "runnable.enable", havingValue = "true")
    public Runnable createRunnable() {
        return () -> {
        };
    }

}

View Code

App2编写

package com.lhx.spring.springboot_auto_config;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.Conditional;

@SpringBootApplication
public class App2 {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(App2.class, args);
        System.out.println(context.getBeansOfType(Runnable.class));
        context.close();
    }
}

View Code

默认是不能装配的

可以再application.properties中添加runnable.enable=true即可装配

或者@ConditionalOnProperty(name = "runnable.enable", havingValue = "true")增加

matchIfMissing=true，表示配置没有的时候也生效

2.2、ConditionalOnClass classpath 有某个类才装配

增加或删除maven，查看效果

<dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.8.2</version>
        </dependency>

使用代码

    @Bean
    @ConditionalOnClass(name="com.google.gson.Gson")
    public Runnable createGsonRunnable() {
        return () -> {
        };
    }

2.3、ConditionalOnBean：根据容器中是否存在某个Bean进行装配

    @Bean
    @ConditionalOnBean(name="user")
    public Runnable createOnBeanRunnable() {
        return () -> {
        };
    }

示例一、根据配置选择不同的实现类注入

需求：根据配置选择不同的实现类注入，有个业务逻辑，有两套模式，大部分功能流程一致，但涉及某些实现不一致，标准的模板模式:004-行为型-02-模板方法模式（Template Method）

实际使用中会有，默认是一种实现，如果有某个配置，则生效。可以参看springboot自动装配实现，如Cache等

实现：https://github.com/bjlhx15/common.git spring-framework-core/spring-aop/testconditional

基础业务接口

public interface ITestConditionalService {
    String getBefore();
    String get();
}

如果新增业务需要新增配置

public class ConstBean {
    public final static String atest="atest";
    public final static String btest="btest";
}

抽象类实现公共方案步骤

public abstract class AbstractTestConditionalService implements ITestConditionalService {

    @Override
    public abstract String getBefore();

    @Override
    public String get() {
        String before = this.getBefore();
        // do something
        return "before:" + before;
    }
}

第一种实现方案：也就是默认方案

@Service("aTestConditionalServiceImpl")
@ConditionalOnProperty(name = "set.test",havingValue = ConstBean.atest,matchIfMissing = true)
public class ATestConditionalServiceImpl extends AbstractTestConditionalService {
    @Override
    public String getBefore() {
        return "atest test";
    }
}

第二种方案

@Service("bTestConditionalServiceImpl")
@ConditionalOnProperty(name = "set.test",havingValue = ConstBean.btest)
public class BTestConditionalServiceImpl extends AbstractTestConditionalService {
    @Override
    public String getBefore() {
        return "btest test";
    }
}

配置如果是a逻辑可默认不写

# 配置实现 atest、btest
set.test=atest

@Conditional、@ConditionalOnClass 等条件注解的作用

Spring 4 框架的新特性：@Conditional 注释，此注释使得只有在特定条件满足时才启用一些配置。

目录：

（1）例子说明
（2）编码思路
（3）编写条件类 WindowCondition 和 LinuxCondition
（4）编写接口 CmdService 以及两个实现类
（5）编写配置类，根据条件进行注入不同的类
（6）编写测试代码
（7）Spring 提供的 Condition
（8）题外话：怎么在 Condition 中获取 application.properties 的配置项

（1）例子说明

在 java 中这种情况，调用系统的 cmd 命令，但是我们知道在 window 和 linux 下命令有些有些时候是不一样的，那么我们以前一般是这么处理；

//伪代码：
if(window) {
//具体的处理代码
} else if(Linux) {
//具体的处理代码.
}

当具体的处理代码很多的时候，我们会放到另外一个处理类来进行处理，比如：WindowService 和 LinuxService。你有没有发现这里如果我们使用了 @Service 进行注解 WindowServie 和 LinuxService 的话，那么内存中就会存在两个 Service，而实际上有一个 service 根本一次都不会执行到。好了，针对于这个问题 @Conditional 就可以解决。当然它还有其它强大的地方。

（2）编码思路

（a）首先这里的话，有一个条件表达式的编写，满足什么条件下返回 true，这个是接口 Condition，我们需要去实现它；

（b）当满足条件的时候，进行做什么事情，这里使用的是 @Conditional，当 @Conditional（条件类.class）中的条件类返回 true 的时候，@Conditional 所注解的类或者方法就会执行。

（3）编写条件类 WindowCondition 和 LinuxCondition

WindowCondition：

package com.kfit.demo.condition;
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;
/**
* window操作系统的条件：当在Window系统下运行的时候，matches方法会返回true,否则返回false.
* @author Angel --守护天使
* @version v.0.1
* @date 2017年8月23日
*/
public class WindowCondition implements Condition{
/**
* 这里写自己的逻辑，只有返回true，才会启用配置
*/
@Override
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
return context.getEnvironment().getProperty("os.name").contains("Windows");
}
}

window 操作系统的条件：当在 Window 系统下运行的时候，matches 方法会返回 true, 否则返回 false.

LinuxCondition:

package com.kfit.demo.condition;
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;
/**
* Linux操作系统的条件：当在Linux系统下运行的时候，matches方法会返回true,否则返回false.
* @author Angel --守护天使
* @version v.0.1
* @date 2017年8月23日
*/
public class LinuxCondition implements Condition{
/**
* 这里写自己的逻辑，只有返回true，才会启用配置
*/
@Override
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
return context.getEnvironment().getProperty("os.name").contains("Linux");
}
}

Linux 操作系统的条件：当在 Linux 系统下运行的时候，matches 方法会返回 true, 否则返回 false.

（4）编写接口 CmdService 以及两个实现类

CmdService：

package com.kfit.demo;
public interface CmdService {
public void print();
}

接口类，具体实现代码有两个 service，WindowCmdService 和 LinuxCmdService。

WindowCmdService：

package com.kfit.demo.service;
import com.kfit.demo.CmdService;
public class WindowCmdService implements CmdService{
@Override
public void print() {
System.out.println("Window cmd...");
}
}

LinuxCmdService:

package com.kfit.demo.service;
import com.kfit.demo.CmdService;
public class LinuxCmdService implements CmdService{
@Override
public void print() {
System.out.println("Linux cmd...");
}
}

注意：以上的两个实现类 WindowCmdService 和 LinuxCmdService 这里我们并没有使用 @Service 注解进行注入，下面我们使用配置类根据不同的系统注入不同的类。

（5）编写配置类，根据条件进行注入不同的类

CmdServiceConditionConfig：

package com.kfit.demo.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;
import com.kfit.demo.CmdService;
import com.kfit.demo.condition.LinuxCondition;
import com.kfit.demo.condition.WindowCondition;
import com.kfit.demo.service.LinuxCmdService;
import com.kfit.demo.service.WindowCmdService;
/**
* 条件配置类.
* @author Angel --守护天使
* @version v.0.1
* @date 2017年8月23日
*/
@Configuration
public class CmdServiceConditionConfig {
/**
* 当WindowCondition方法中的matches返回true的时候，
* WindowCmdService会被注入，否则不注入。
*/
@Bean("cmdService")
@Conditional(WindowCondition.class)
public CmdService windowCmdService(){
return new WindowCmdService();
}
/**
* 当LinuxCondition方法中的matches返回true的时候，
* LinuxCmdService会被注入，否则不注入。
*/
@Bean("cmdService")
@Conditional(LinuxCondition.class)
public CmdService LinuxCmdService(){
return new LinuxCmdService();
}
}

这里使用 @Conditional 根据满足不同的条件注入不同的类，在 Linux 下会注入实现类 LinuxCmdService, 在 Window 下会注入 WindowCmdService。

（6）编写测试代码

在启动类的 main 方法中编写测试代码：

public static void main(String[] args) {
ApplicationContext ctx = (ApplicationContext) SpringApplication.run(App.class, args);
CmdService cmdService = ctx.getBean(CmdService.class);
cmdService.print();
}

在 Window 下运行控制台打印信息：

Window cmd...

在 Linux 下运行控制台打印信息（亲测）：

Linux cmd...

（7）Spring 提供的 Condition

除了自己自定义 Condition 之外，Spring 还提供了很多 Condition 给我们用

（a）@ConditionalOnBean

仅仅在当前上下文中存在某个对象时，才会实例化一个 Bean。

（b）@ConditionalOnClass

某个 class 位于类路径上，才会实例化一个 Bean

（c）@ConditionalOnExpression

当表达式为 true 的时候，才会实例化一个 Bean。

比如：

@ConditionalOnExpression("true")

@ConditionalOnExpression("${my.controller.enabled:false}")

（d）@ConditionalOnMissingBean

仅仅在当前上下文中不存在某个对象时，才会实例化一个 Bean

（e）@ConditionalOnMissingClass

某个 class 类路径上不存在的时候，才会实例化一个 Bean

（f）@ConditionalOnNotWebApplication

不是 web 应用

（8）题外话：怎么在 Condition 中获取 application.properties 的配置项

String port = context.getEnvironment().getProperty("server.port");
System.out.println(port);

org.springframework.boot.autoconfigure.condition.ConditionalOnBean的实例源码

项目：xitikit-blue 文件：B2CServicesAutoConfiguration.java

@Bean("blueKitB2CAuthenticationService")
@Autowired
@ConditionalOnMissingBean(B2CAuthenticationService.class)
@ConditionalOnBean(
  value = {B2CProperties.class,SignUpPolicy.class,SignInPolicy.class,SignUpOrSignInPolicy.class,ResetPasswordPolicy.class,EditProfilePolicy.class,SignOutPolicy.class,NonceProperties.class,NonceService.class})
public B2CAuthenticationService blueKitB2CAuthenticationService(
  final ClaimValidationService claimValidationService,final NonceService nonceService,final UrlService urlService,final RestTemplate restTemplate){

    return new SimpleB2CAuthenticationService(
      claimValidationService,nonceService,urlService,restTemplate);
}

项目：zipkin-sparkstreaming 文件：ZipkinStorageConsumerAutoConfiguration.java

@ConditionalOnBean(StorageComponent.class)
@Bean StorageConsumer storageConsumer(
    StorageComponent component,@Value("${zipkin.sparkstreaming.consumer.storage.fail-fast:true}") boolean failFast,beanfactory bf
) throws IOException {
  if (failFast) checkStorageOk(component);
  Properties properties = extractZipkinProperties(bf.getBean(ConfigurableEnvironment.class));
  if (component instanceof V2StorageComponent) {
    zipkin2.storage.StorageComponent v2Storage = ((V2StorageComponent) component).delegate();
    if (v2Storage instanceof ElasticsearchHttpStorage) {
      return new ElasticsearchStorageConsumer(properties);
    } else if (v2Storage instanceof zipkin2.storage.cassandra.CassandraStorage) {
      return new Cassandra3StorageConsumer(properties);
    } else {
      throw new UnsupportedOperationException(v2Storage + " not yet supported");
    }
  } else if (component instanceof CassandraStorage) {
    return new CassandraStorageConsumer(properties);
  } else if (component instanceof MysqLStorage) {
    return new MysqLStorageConsumer(properties);
  } else {
    throw new UnsupportedOperationException(component + " not yet supported");
  }
}

项目：sample-boot-hibernate 文件：ApplicationConfig.java

/** 営業日チェック */
@Bean
@ConditionalOnBean(BusinessDayHandler.class)
Healthindicator dayIndicator(final Timestamper time,final BusinessDayHandler day) {
    return new AbstractHealthindicator() {
        @Override
        protected void doHealthCheck(Builder builder) throws Exception {
            builder.up();
            builder.withDetail("day",day.day())
                    .withDetail("dayMinus1",day.day(-1))
                    .withDetail("dayPlus1",day.day(1))
                    .withDetail("dayPlus2",day.day(2))
                    .withDetail("dayPlus3",day.day(3));
        }
    };
}

项目：onetwo 文件：BootSecurityCommonContextConfig.java

@Bean
@ConditionalOnMissingBean({LoggerInterceptor.class})
@ConditionalOnBean(BootSiteConfig.class)
@ConditionalOnProperty(value=AccessLogProperties.ENABLE_MVC_LOGGER_INTERCEPTOR,matchIfMissing=true,havingValue="true")
public LoggerInterceptor loggerInterceptor(){
    LoggerInterceptor log = new LoggerInterceptor();
    log.setUserDetailRetriever(()->{
        if(SecurityContextHolder.getContext().getAuthentication()==null)
            return null;
        Object user = SecurityContextHolder.getContext().getAuthentication().getPrincipal();
        if(UserDetail.class.isinstance(user)){
            return (UserDetail)user;
        }else if(User.class.isinstance(user)){
            User suser = (User)user;
            SimpleUserDetail ud = new SimpleUserDetail();
            ud.setUserName(suser.getUsername());
            return ud;
        }
        return null;
    });
    log.setPathPatterns(accessLogProperties.getPathPatterns());
    return log;
}

项目：onetwo 文件：WebAdminPluginContext.java

@Bean
    @Autowired
    @ConditionalOnBean(RootMenuClassprovider.class)
    public AdminPermissionConfigListAdapetor adminPermissionConfigListAdapetor(List<RootMenuClassprovider> providers){
        AdminPermissionConfigListAdapetor list = new AdminPermissionConfigListAdapetor();
        providers.forEach(provider->{
            Collection<Class<?>> rooMenuClassList = new HashSet<>();
            if(provider instanceof RootMenuClassListProvider){
                rooMenuClassList.addAll(((RootMenuClassListProvider)provider).rootMenuClassList());
            }else{
                rooMenuClassList.add(provider.rootMenuClass());
            }
            rooMenuClassList.forEach(rootMenuClass->{
                WebAdminPermissionConfig config = new WebAdminPermissionConfig();
//              config.setRootMenuClassprovider(provider);
                config.setRootMenuClass(rootMenuClass);
                list.add(config);
            });
        });
        return list;
    }

项目：uimaster 文件：PersistentConfig.java

@Bean
    @ConditionalOnBean(name = "dataSource")
    public EntityManagerFactory entityManagerFactory() {
        HibernateJpavendorAdapter vendorAdapter = new HibernateJpavendorAdapter();
        vendorAdapter.setGenerateDdl(true);

        LocalContainerEntityManagerfactorybean factory = new LocalContainerEntityManagerfactorybean();
        factory.setJpavendorAdapter(vendorAdapter);
        factory.setPackagesToScan("org.shaolin");
        factory.setDataSource(dataSource());
//      factory.setPersistenceUnitManager(persistenceUnitManager);
//      factory.setMappingResources(mappingResources);
        factory.afterPropertiesSet();

        return factory.getobject();
    }

项目：spring-security-oauth2-boot 文件：ResourceServerTokenServicesConfiguration.java

@Bean
@ConditionalOnBean(ConnectionFactoryLocator.class)
@ConditionalOnMissingBean(ResourceServerTokenServices.class)
public SpringSocialTokenServices socialTokenServices() {
    return new SpringSocialTokenServices(this.connectionFactory,this.sso.getClientId());
}

项目：cas-5.1.0 文件：CasReportsConfiguration.java

@Profile("standalone")
@ConditionalOnBean(name = "configurationPropertiesEnvironmentManager")
@Bean
@RefreshScope
public MvcEndpoint internalConfigController() {
    return new ConfigurationStateController(casProperties);
}

项目：cereebro 文件：CereebroEurekaInstanceAutoConfiguration.java

@Bean
@ConditionalOnBean(SnitchEndpoint.class)
public EurekaMetadataPopulator eurekaMetadataPopulator(SnitchEndpoint snitch,ApplicationInfoManager manager,ObjectMapper mapper) {
    RelaxedPropertyResolver relaxedPropertyResolver = new RelaxedPropertyResolver(env,"cereebro.snitch.eureka.");
    EurekaInstanceSnitchProperties props = new EurekaInstanceSnitchProperties();
    props.setEndpointUrl(relaxedPropertyResolver.getProperty("endpointUrl"));
    props.setEndpointUrlPath(relaxedPropertyResolver.getProperty("endpointUrlPath"));
    EurekaMetadataPopulator MetadataPopulator = new EurekaMetadataPopulator(snitch,manager,props,mapper);
    MetadataPopulator.populate();
    return MetadataPopulator;
}

项目：elephant 文件：ActivemqConfig.java

@Bean
@ConditionalOnBean(jmstemplate.class)
public ProducerService activemqProducerService(jmstemplate jmstemplate){
    ActivemqProducerService activemqProducer = new ActivemqProducerService();
    activemqProducer.setjmstemplate(jmstemplate);
    return activemqProducer;
}

项目：spring-boot-autoconfigure 文件：MyBatisAutoConfiguration.java

@Bean
@Scope(Configurablebeanfactory.ScopE_PROTOTYPE)
@ConditionalOnBean(sqlSession.class)
@ConditionalOnMissingBean
public sqlMapper sqlMapper(sqlSession sqlSession) {
    return new sqlMapper(sqlSession);
}

项目：spring-data-sNowdrop 文件：SNowdropDataInfinispanEmbeddedAutoConfiguration.java

@Bean
@ConditionalOnMissingBean(EntityToCacheMapper.class)
@ConditionalOnBean(EmbeddedCacheManager.class)
public EntityToCacheMapper createDefaultEntityToCacheMapper(final EmbeddedCacheManager cacheManager) {
    return new EntityToCacheMapper() {
        public <ID,T> Cache<ID,T> getCache(Class<T> entityClass) {
            return cacheManager.getCache(); // always return default cache
        }
    };
}

项目：spring-data-sNowdrop 文件：SNowdropDataInfinispanRemoteAutoConfiguration.java

@Bean
@ConditionalOnMissingBean(EntityToRemoteCacheMapper.class)
@ConditionalOnBean(RemoteCacheManager.class)
public EntityToRemoteCacheMapper createDefaultEntityToCacheMapper(final RemoteCacheManager cacheManager) {
    return new EntityToRemoteCacheMapper() {
        public <ID,T> RemoteCache<ID,T> getRemoteCache(Class<T> entityClass) {
            return cacheManager.getCache(); // always return default cache
        }
    };
}

项目：quickfixj-spring-boot-starter 文件：QuickFixJServerEndpointAutoConfiguration.java

@Bean
@ConditionalOnBean(name = {"serverAcceptor","serverSessionSettings"})
@ConditionalOnClass({Acceptor.class,SessionSettings.class})
@ConditionalOnMissingBean
@ConditionalOnEnabledEndpoint("quickfixjserver")
public QuickFixJServerEndpoint quickfixjServerEndpoint(Acceptor serverAcceptor,SessionSettings serverSessionSettings) {
    return new QuickFixJServerEndpoint(serverAcceptor,serverSessionSettings);
}

项目：quickfixj-spring-boot-starter 文件：QuickFixJClientEndpointAutoConfiguration.java

@Bean
   @ConditionalOnBean(name = {"clientinitiator","clientSessionSettings"})
   @ConditionalOnClass({Initiator.class,SessionSettings.class})
   @ConditionalOnMissingBean
@ConditionalOnEnabledEndpoint("quickfixjclient")
   public QuickFixJClientEndpoint quickfixjClientEndpoint(Initiator clientinitiator,SessionSettings clientSessionSettings) {
       return new QuickFixJClientEndpoint(clientinitiator,clientSessionSettings);
   }

项目：spring-cloud-dashboard 文件：DataFlowControllerAutoConfiguration.java

@Bean
@ConditionalOnBean(ApplicationDeFinitionRepository.class)
public ApplicationDeFinitionController applicationDeFinitionController(ApplicationDeFinitionRepository repository,DeploymentIdRepository deploymentIdRepository,ApplicationDeploymentController deploymentController,AppDeployer deployer,AppRegistry appRegistry) {
    return new ApplicationDeFinitionController(repository,deploymentIdRepository,deploymentController,deployer,appRegistry);
}

项目：spring-cloud-dashboard 文件：DataFlowControllerAutoConfiguration.java

@Bean
@ConditionalOnBean(ApplicationDeFinitionRepository.class)
public ApplicationDeploymentController applicationDeploymentController(ApplicationDeFinitionRepository repository,EavRegistryRepository eavRegistryRepository,AppRegistry appRegistry,ApplicationConfigurationMetadataResolver MetadataResolver,CommonApplicationProperties appsProperties) {
    return new ApplicationDeploymentController(repository,eavRegistryRepository,appRegistry,MetadataResolver,appsProperties);
}

项目：java-spring-cloud 文件：WebsocketAutoConfiguration.java

@Bean
@ConditionalOnBean(WebSocketMessagebrokerConfigurationSupport.class)
public TracingChannelInterceptor tracingInboundChannelInterceptor(
    WebSocketMessagebrokerConfigurationSupport config) {
  TracingChannelInterceptor interceptor = new TracingChannelInterceptor(tracer,Tags.SPAN_KIND_SERVER);
  config.clientInboundChannel().addInterceptor(interceptor);
  return interceptor;
}

项目：java-spring-cloud 文件：WebsocketAutoConfiguration.java

@Bean
@ConditionalOnBean(WebSocketMessagebrokerConfigurationSupport.class)
public TracingChannelInterceptor tracingOutboundChannelInterceptor(
    WebSocketMessagebrokerConfigurationSupport config) {
  TracingChannelInterceptor interceptor = new TracingChannelInterceptor(tracer,Tags.SPAN_KIND_CLIENT);
  config.clientOutboundChannel().addInterceptor(interceptor);
  return interceptor;
}

项目：nakadi-producer-spring-boot-starter 文件：NakadiProducerAutoConfiguration.java

@Bean
@ConditionalOnBean(SnapshotEventCreationEndpoint.class)
@ConditionalOnEnabledEndpoint("snapshot_event_creation")
public SnapshotEventCreationMvcEndpoint snapshotEventCreationMvcEndpoint(
        SnapshotEventCreationEndpoint snapshotEventCreationEndpoint) {
    return new SnapshotEventCreationMvcEndpoint(snapshotEventCreationEndpoint);
}