org.springframework.boot.autoconfigure.condition.ConditionalOnBean Java Examples

@Bean
@ConditionalOnBean(JavaMailSender.class)
public MailSender adiMailSender1(JavaMailSender sender, FreeMarkerConfigurer freeMarkerConfigurer) {
    if (mailProperties.getPreferIPv4Stack()) {
        System.setProperty("java.net.preferIPv4Stack", "true");
    }

    JavaMailSenderImpl js= (JavaMailSenderImpl) sender;
    Properties props = new Properties();
    props.put("mail.smtp.auth", true);
    props.put("mail.smtp.ssl.enable", true);
    props.put("mail.smtp.socketFactory.class","javax.net.ssl.SSLSocketFactory");
    props.put("mail.smtp.timeout", 25000);
    js.setJavaMailProperties(props);
    MailSender mailSender = new MailSender();
    mailSender.setJavaMailSender(js);
    mailSender.setFreeMarkerConfigurer(freeMarkerConfigurer);
    mailSender.setName(mailProperties.getName());
    mailSender.setFrom(mailProperties.getFrom());
    return mailSender;
}
 

@ConditionalOnBean(name = "EurekaClientProvider.class, EurekaClientConfigProvider.class")
@Bean
public ApiMediationClient apiMediationClient(EurekaClientProvider eurekaClientProvider, EurekaClientConfigProvider eurekaClientConfigProvider) {
    if (eurekaClientProvider != null) {
        if (eurekaClientConfigProvider != null) {
            return new ApiMediationClientImpl(eurekaClientProvider, eurekaClientConfigProvider);
        } else {
            return new ApiMediationClientImpl(eurekaClientProvider);
        }
    } else {
        if (eurekaClientConfigProvider != null) {
            return new ApiMediationClientImpl(new DiscoveryClientProvider(), eurekaClientConfigProvider);
        } else {
            return new ApiMediationClientImpl();
        }
    }
}
 

@Bean
@ConditionalOnMissingBean
@ConditionalOnBean({ConsumerFactory.class, KafkaMessageConverter.class, Fetcher.class})
@ConditionalOnProperty(value = "axon.kafka.consumer.event-processor-mode", havingValue = "TRACKING")
public StreamableKafkaMessageSource<String, byte[]> streamableKafkaMessageSource(
        ConsumerFactory<String, byte[]> kafkaConsumerFactory,
        Fetcher<String, byte[], KafkaEventMessage> kafkaFetcher,
        KafkaMessageConverter<String, byte[]> kafkaMessageConverter
) {
    return StreamableKafkaMessageSource.<String, byte[]>builder()
            .topics(Collections.singletonList(properties.getDefaultTopic()))
            .consumerFactory(kafkaConsumerFactory)
            .fetcher(kafkaFetcher)
            .messageConverter(kafkaMessageConverter)
            .bufferFactory(() -> new SortedKafkaMessageBuffer<>(properties.getFetcher().getBufferSize()))
            .build();
}
 

@Bean(BEAN_DEFAULT_EMBEDDED_WEBAPPS_ENDPOINT)
@ConditionalOnBean(name = BEAN_DEFAULT_EMBEDDED_WEBAPPS_PROPERTIES)
public GenericEmbeddedWebappsEndpoint defaultEmbeddedWebappsEndpoint(
		@Qualifier(BEAN_DEFAULT_EMBEDDED_WEBAPPS_PROPERTIES) GenericEmbeddedWebappsProperties config) {
	return new GenericEmbeddedWebappsEndpoint(config) {
	};
}
 

/**
 * Registers an empty {@link ExceptionLogger} in the absence of a custom logger.
 *
 * @return A no-op exception logger.
 */
@Bean
@ConditionalOnMissingBean
@ConditionalOnBean(WebErrorHandlers.class)
public ExceptionLogger exceptionLogger() {
    return ExceptionLogger.NoOp.INSTANCE;
}
 

@Bean
@ConditionalOnMissingBean
@ConditionalOnBean(type = "brave.Tracing")
public RSocketResponderHandlerFactory rsocketResponderHandlerFactoryWithZipkin(@Autowired LocalReactiveServiceCaller serviceCaller,
                                                                               @Autowired @Qualifier("reactiveCloudEventProcessor") TopicProcessor<CloudEventImpl> eventProcessor) {
    return (setupPayload, requester) -> Mono.fromCallable(() -> {
        RSocketResponderHandler responderHandler = new RSocketResponderHandler(serviceCaller, eventProcessor, requester, setupPayload);
        Tracing tracing = applicationContext.getBean(Tracing.class);
        responderHandler.setTracer(tracing.tracer());
        return responderHandler;
    });
}
 

@ConditionalOnBean(RecommendationService.class)
@Bean
@Autowired
public NamedEntityLinkerFactory namedEntityLinkerFactory(KnowledgeBaseService aKbService,
        ConceptLinkingService aClService, FeatureSupportRegistry aFsRegistry)
{
    return new NamedEntityLinkerFactory(aKbService, aClService, aFsRegistry);
}
 

@Bean
@ConditionalOnBean(SpecRegistry.class)
public List<Spec> specListFromSpecRegistry(SpecRegistry specRegistry) {
    List<Spec> specList = specRegistry.getSpecList();
    if (CollectionUtils.isEmpty(specList)) {
        throw new IllegalArgumentException("specList cannot be empty.");
    }
    return specList;
}
 

/**
 * Creates a new {@link XsuaaTokenFlows} bean that applications can auto-wire
 * into their controllers to perform a programmatic token flow exchange.
 *
 * @param xsuaaRestOperations
 *            - the {@link RestOperations} to use for the token flow exchange.
 * @param xsuaaServiceConfiguration
 *            - the {@link XsuaaServiceConfiguration} to configure the Xsuaa
 *            Base Url.
 * @return the {@link XsuaaTokenFlows} API.
 */
@Bean
@ConditionalOnBean({ XsuaaServiceConfiguration.class, RestOperations.class })
@ConditionalOnMissingBean
public XsuaaTokenFlows xsuaaTokenFlows(RestOperations xsuaaRestOperations,
		XsuaaServiceConfiguration xsuaaServiceConfiguration) {
	logger.debug("auto-configures XsuaaTokenFlows using restOperations of type: {}", xsuaaRestOperations);
	OAuth2ServiceEndpointsProvider endpointsProvider = new XsuaaDefaultEndpoints(
			xsuaaServiceConfiguration.getUaaUrl());
	ClientCredentials clientCredentials = new ClientCredentials(xsuaaServiceConfiguration.getClientId(),
			xsuaaServiceConfiguration.getClientSecret());
	OAuth2TokenService oAuth2TokenService = new XsuaaOAuth2TokenService(xsuaaRestOperations);
	return new XsuaaTokenFlows(oAuth2TokenService, endpointsProvider, clientCredentials);
}
 

@Bean
@ConditionalOnBean(XsrfProperties.class)
public FilterRegistrationBean xsrfProtectionSecurityFilterBean(XsrfProtectionSecurityFilter filter) {
	// Register XSRF filter
	FilterRegistrationBean filterBean = new FilterRegistrationBean(filter);
	filterBean.setOrder(ORDER_XSRF_PRECEDENCE);
	// Cannot use '/*' or it will not be added to the container chain (only
	// '/**')
	filterBean.addUrlPatterns("/*");
	return filterBean;
}
 

/**
 * Registers a {@link WebErrorHandler} to handle new Servlet exceptions defined in Spring Framework 5.1.
 * This handler would be registered iff we're using Spring Boot 2.1.0+.
 *
 * @return A web error handler to handle a few new servlet exceptions.
 */
@Bean
@ConditionalOnBean(WebErrorHandlers.class)
@ConditionalOnWebApplication(type = SERVLET)
@ConditionalOnClass(name = "org.springframework.web.bind.MissingRequestHeaderException")
public MissingRequestParametersWebErrorHandler missingRequestParametersWebErrorHandler() {
    return new MissingRequestParametersWebErrorHandler();
}
 

@Bean
@ConditionalOnBean(SpecRegistry.class)
public List<Spec> specListFromSpecRegistry(SpecRegistry specRegistry) {
    List<Spec> specList = specRegistry.getSpecList();
    if (CollectionUtils.isEmpty(specList)) {
        throw new IllegalArgumentException("specList cannot be empty.");
    }
    return specList;
}
 

@Bean
@ConditionalOnBean(FiscoBcosDelegate.class)
public IProducer fiscoIProducer(FiscoBcosDelegate fiscoBcosDelegate) {
    FiscoBcosBroker4Producer fiscoBcosBroker4Producer = new FiscoBcosBroker4Producer(fiscoBcosDelegate);
    fiscoBcosBroker4Producer.startProducer();
    return fiscoBcosBroker4Producer;
}
 

@ConditionalOnBean(EurekaClientProvider.class)
@Bean
public ApiMediationClient apiMediationClient(EurekaClientProvider eurekaClientProvider) {
    if (eurekaClientProvider == null) {
        return new ApiMediationClientImpl();
    }
    return new ApiMediationClientImpl(eurekaClientProvider);
}
 

@Bean
@ConditionalOnBean(FabricDelegate.class)
public IProducer fabricIProducer(FabricDelegate fabricDelegate) {
    FabricBroker4Producer fabricBroker4Producer = new FabricBroker4Producer(fabricDelegate);
    fabricBroker4Producer.startProducer();
    return fabricBroker4Producer;
}
 

@Bean
@ConditionalOnBean(RequestMappingHandlerMapping.class)
public RaptorProtoFilesEndpoint createRaptorProtoFilesEndpoint(RequestMappingHandlerMapping requestMappingHandlerMapping) {
    RaptorProtoFilesEndpoint raptorProtoFilesEndpoint = new RaptorProtoFilesEndpoint(requestMappingHandlerMapping);
    raptorProtoFilesEndpoint.setClassLoader(classLoader);
    return raptorProtoFilesEndpoint;
}
 

@Bean
@ConditionalOnJdwpDebug(enableProperty = KEY_PREFIX + ".enable")
@ConfigurationProperties(prefix = KEY_PREFIX)
@ConditionalOnBean(SqlSessionFactoryBean.class)
public HotspotLoadProperties hotspotLoaderProperties() {
	return new HotspotLoadProperties();
}
 

@Bean
@ConditionalOnBean(CacheChannel.class)
public J2CacheCacheManger cacheManager(CacheChannel cacheChannel) {
	List<String> cacheNames = cacheProperties.getCacheNames();
	J2CacheCacheManger cacheCacheManger = new J2CacheCacheManger(cacheChannel);
	cacheCacheManger.setAllowNullValues(j2CacheConfig.isAllowNullValues());
	cacheCacheManger.setCacheNames(cacheNames);
	return cacheCacheManger;
}
 

@Bean
@ConditionalOnBean(CacheChannel.class)
public J2CacheCacheManger cacheManager(CacheChannel cacheChannel) {
	List<String> cacheNames = cacheProperties.getCacheNames();
	J2CacheCacheManger cacheCacheManger = new J2CacheCacheManger(cacheChannel);
	cacheCacheManger.setAllowNullValues(j2CacheConfig.isAllowNullValues());
	cacheCacheManger.setCacheNames(cacheNames);
	return cacheCacheManger;
}
 

@Bean("j2CacheRedisTemplate")
@ConditionalOnBean(name = "j2CahceRedisConnectionFactory")
public RedisTemplate<String, Serializable> j2CacheRedisTemplate(
		@Qualifier("j2CahceRedisConnectionFactory") JedisConnectionFactory j2CahceRedisConnectionFactory) {
	RedisTemplate<String, Serializable> template = new RedisTemplate<String, Serializable>();
	template.setKeySerializer(new StringRedisSerializer());
	template.setHashKeySerializer(new StringRedisSerializer());
	template.setDefaultSerializer(new J2CacheSerializer());
	template.setConnectionFactory(j2CahceRedisConnectionFactory);
	return template;
}
 

@Bean
@ConditionalOnBean(SecureRuleRegistry.class)
public List<Rule> ruleListFromRegistry(SecureRuleRegistry secureRuleRegistry) {
	List<Rule> ruleList = secureRuleRegistry.getRuleList();
	if (CollectionUtils.isEmpty(ruleList)) {
		throw new IllegalArgumentException("规则列表不能为空");
	}
	return ruleList;
}
 

@Bean
@ConditionalOnBean(CacheChannel.class)
public J2CacheCacheManger cacheManager(CacheChannel cacheChannel) {
    Collection<String> cacheNames = cacheProperties.getCacheNames();
    J2CacheCacheManger cacheCacheManger = new J2CacheCacheManger(cacheChannel);
    cacheCacheManger.setAllowNullValues(j2CacheProperties.isAllowNullValues());
    cacheCacheManger.setCacheNames(cacheNames);
    return cacheCacheManger;
}
 

@Bean
@ConditionalOnBean({ApplicationConfig.class, RegistryConfig.class})
public ChronusSdkProcessor chronusSdkFacade() {
    ChronusSdkProcessor chronusClientFacade = new AbstractSdkService(){};
    ServiceConfig<ChronusSdkProcessor> serviceConfig = new ServiceConfig<>();
    serviceConfig.setApplication(applicationConfig);
    serviceConfig.setRegistry(registryConfig);
    serviceConfig.setInterface(ChronusSdkProcessor.class);
    serviceConfig.setRef(chronusClientFacade);
    serviceConfig.setPath("/" + applicationConfig.getName() + "/" + ChronusSdkProcessor.class.getName());
    //serviceConfig.setGroup(applicationConfig.getName());
    serviceConfig.export();
    return chronusClientFacade;
}
 

@Bean
@ConditionalOnBean(CorsProperties.class)
public CorsSecurityFilter corsSecurityFilter(CorsProperties config, IamCorsProcessor corsProcessor) {
	UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
	// Merger transformation configuration
	config.getRules().forEach((key, rule) -> source.registerCorsConfiguration(key, rule.resolveIamCorsConfiguration()));
	CorsSecurityFilter filter = new CorsSecurityFilter(source);
	filter.setCorsProcessor(corsProcessor);
	return filter;
}
 

@Bean
@ConditionalOnBean(OpenIdLoginConfigurer.class)
public OpenIdChannelSecurityConfigurer openIdChannelSecurityConfigurer(OpenIdLoginConfigurer openIdLoginConfigurer,
																	   OpenIdAuthenticationProvider openIdAuthenticationProvider,
																	   OpenIdProperties openIdProperties) {
	return new OpenIdChannelSecurityConfigurer(openIdLoginConfigurer,openIdAuthenticationProvider,openIdProperties);
}
 

/**
 * Creates {@link ServiceAnnotationBeanPostProcessor} Bean
 *
 * @param propertyResolver {@link PropertyResolver} Bean
 * @return {@link ServiceAnnotationBeanPostProcessor}
 */
@ConditionalOnProperty(prefix = DUBBO_SCAN_PREFIX, name = BASE_PACKAGES_PROPERTY_NAME)
@ConditionalOnBean(name = BASE_PACKAGES_PROPERTY_RESOLVER_BEAN_NAME)
@Bean
public ServiceAnnotationBeanPostProcessor serviceAnnotationBeanPostProcessor(
        @Qualifier(BASE_PACKAGES_PROPERTY_RESOLVER_BEAN_NAME) PropertyResolver propertyResolver) {
    Set<String> packagesToScan = propertyResolver.getProperty(BASE_PACKAGES_PROPERTY_NAME, Set.class, emptySet());
    return new ServiceAnnotationBeanPostProcessor(packagesToScan);
}
 

@Bean
@ConditionalOnBean({AuthenticationManager.class, AuthorizationServerTokenServices.class, ClientDetailsService.class})
public SmsTokenGranter smsTokenGranter(AuthenticationManager authenticationManager,
									   AuthorizationServerTokenServices tokenServices,
									   ClientDetailsService clientDetailsService) {
	return new SmsTokenGranter(authenticationManager, tokenServices, clientDetailsService, new DefaultOAuth2RequestFactory(clientDetailsService));
}
 

@ConditionalOnMissingBean(BraveHttpRequestInterceptor.class)
@ConditionalOnBean(Brave.class)
@Bean
public BraveHttpRequestInterceptor requestInterceptor(Brave brave) {
    return new BraveHttpRequestInterceptor(brave.clientRequestInterceptor(),
            new DefaultSpanNameProvider());
}
 

@Bean
@ConditionalOnBean(Notifier.class)
public CompositeNotifier compositeNotifier(Map<String, Notifier> notifiers) {
  return new CompositeNotifier(notifiers.values());
}
 

@Bean
@ConditionalOnBean(AccessPointContainer.class)
@ConditionalOnProperty(prefix = OMSSpringBootConsts.PREFIX + ".consumer", name = "enable", matchIfMissing = true, havingValue = "true")
public ConsumerRegistrar createConsumerRegistrar(AccessPointContainer accessPointContainer) {
    return new ConsumerRegistrar(accessPointContainer);
}