You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@camel.apache.org by zr...@apache.org on 2018/06/07 12:32:38 UTC
[camel] branch master updated (b513fd3 -> abc3405)
This is an automated email from the ASF dual-hosted git repository.
zregvart pushed a change to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git.
from b513fd3 CAMEL-12556: camel-servicenow: add metadata option to list available import set
new 8d10593 Remove unused imports
new abc3405 Refactor spring-boot CamelAutoConfiguration
The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
.../camel/spring/boot/CamelAutoConfiguration.java | 250 +++++++--------------
.../CamelRoutesEndpointAutoConfiguration.java | 2 -
2 files changed, 85 insertions(+), 167 deletions(-)
--
To stop receiving notification emails like this one, please contact
zregvart@apache.org.
[camel] 01/02: Remove unused imports
Posted by zr...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
zregvart pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git
commit 8d10593510d47fb88526c5581d7e494f84b5c1be
Author: Zoran Regvart <zr...@apache.org>
AuthorDate: Thu Jun 7 13:47:12 2018 +0200
Remove unused imports
---
.../boot/actuate/endpoint/CamelRoutesEndpointAutoConfiguration.java | 2 --
1 file changed, 2 deletions(-)
diff --git a/components/camel-spring-boot/src/main/java/org/apache/camel/spring/boot/actuate/endpoint/CamelRoutesEndpointAutoConfiguration.java b/components/camel-spring-boot/src/main/java/org/apache/camel/spring/boot/actuate/endpoint/CamelRoutesEndpointAutoConfiguration.java
index 8a2ccda..b8642b5 100644
--- a/components/camel-spring-boot/src/main/java/org/apache/camel/spring/boot/actuate/endpoint/CamelRoutesEndpointAutoConfiguration.java
+++ b/components/camel-spring-boot/src/main/java/org/apache/camel/spring/boot/actuate/endpoint/CamelRoutesEndpointAutoConfiguration.java
@@ -18,9 +18,7 @@ package org.apache.camel.spring.boot.actuate.endpoint;
import org.apache.camel.CamelContext;
import org.apache.camel.spring.boot.CamelAutoConfiguration;
-import org.springframework.boot.actuate.autoconfigure.endpoint.EndpointAutoConfiguration;
import org.springframework.boot.actuate.autoconfigure.endpoint.condition.ConditionalOnEnabledEndpoint;
-import org.springframework.boot.actuate.autoconfigure.endpoint.web.WebEndpointAutoConfiguration;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
--
To stop receiving notification emails like this one, please contact
zregvart@apache.org.
[camel] 02/02: Refactor spring-boot CamelAutoConfiguration
Posted by zr...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
zregvart pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git
commit abc340506ea584b153ab2b9ac21531d01593500a
Author: Zoran Regvart <zr...@apache.org>
AuthorDate: Thu Jun 7 14:30:34 2018 +0200
Refactor spring-boot CamelAutoConfiguration
This refactors spring-boot CamelAutoConfiguration to use helper methods
in order to reduce the amount of duplicated code.
---
.../camel/spring/boot/CamelAutoConfiguration.java | 250 +++++++--------------
1 file changed, 85 insertions(+), 165 deletions(-)
diff --git a/components/camel-spring-boot/src/main/java/org/apache/camel/spring/boot/CamelAutoConfiguration.java b/components/camel-spring-boot/src/main/java/org/apache/camel/spring/boot/CamelAutoConfiguration.java
index 95cb392..2388cb5 100644
--- a/components/camel-spring-boot/src/main/java/org/apache/camel/spring/boot/CamelAutoConfiguration.java
+++ b/components/camel-spring-boot/src/main/java/org/apache/camel/spring/boot/CamelAutoConfiguration.java
@@ -21,6 +21,8 @@ import java.util.Collection;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
import org.apache.camel.CamelContext;
import org.apache.camel.ConsumerTemplate;
@@ -361,120 +363,36 @@ public class CamelAutoConfiguration {
LOG.info("Using custom Tracer: {}", tracer);
camelContext.addInterceptStrategy(tracer);
}
- BacklogTracer backlogTracer = getSingleBeanOfType(applicationContext, BacklogTracer.class);
- if (backlogTracer != null) {
- LOG.info("Using custom BacklogTracer: {}", backlogTracer);
- camelContext.addInterceptStrategy(backlogTracer);
- }
- HandleFault handleFault = getSingleBeanOfType(applicationContext, HandleFault.class);
- if (handleFault != null) {
- LOG.info("Using custom HandleFault: {}", handleFault);
- camelContext.addInterceptStrategy(handleFault);
- }
- InflightRepository inflightRepository = getSingleBeanOfType(applicationContext, InflightRepository.class);
- if (inflightRepository != null) {
- LOG.info("Using custom InflightRepository: {}", inflightRepository);
- camelContext.setInflightRepository(inflightRepository);
- }
- AsyncProcessorAwaitManager asyncProcessorAwaitManager = getSingleBeanOfType(applicationContext, AsyncProcessorAwaitManager.class);
- if (asyncProcessorAwaitManager != null) {
- LOG.info("Using custom AsyncProcessorAwaitManager: {}", asyncProcessorAwaitManager);
- camelContext.setAsyncProcessorAwaitManager(asyncProcessorAwaitManager);
- }
- ManagementStrategy managementStrategy = getSingleBeanOfType(applicationContext, ManagementStrategy.class);
- if (managementStrategy != null) {
- LOG.info("Using custom ManagementStrategy: {}", managementStrategy);
- camelContext.setManagementStrategy(managementStrategy);
- }
- ManagementNamingStrategy managementNamingStrategy = getSingleBeanOfType(applicationContext, ManagementNamingStrategy.class);
- if (managementNamingStrategy != null) {
- LOG.info("Using custom ManagementNamingStrategy: {}", managementNamingStrategy);
- camelContext.getManagementStrategy().setManagementNamingStrategy(managementNamingStrategy);
- }
- EventFactory eventFactory = getSingleBeanOfType(applicationContext, EventFactory.class);
- if (eventFactory != null) {
- LOG.info("Using custom EventFactory: {}", eventFactory);
- camelContext.getManagementStrategy().setEventFactory(eventFactory);
- }
- UnitOfWorkFactory unitOfWorkFactory = getSingleBeanOfType(applicationContext, UnitOfWorkFactory.class);
- if (unitOfWorkFactory != null) {
- LOG.info("Using custom UnitOfWorkFactory: {}", unitOfWorkFactory);
- camelContext.setUnitOfWorkFactory(unitOfWorkFactory);
- }
- RuntimeEndpointRegistry runtimeEndpointRegistry = getSingleBeanOfType(applicationContext, RuntimeEndpointRegistry.class);
- if (runtimeEndpointRegistry != null) {
- LOG.info("Using custom RuntimeEndpointRegistry: {}", runtimeEndpointRegistry);
- camelContext.setRuntimeEndpointRegistry(runtimeEndpointRegistry);
- }
- // custom type converters defined as <bean>s
- Map<String, TypeConverters> typeConverters = applicationContext.getBeansOfType(TypeConverters.class);
- if (typeConverters != null && !typeConverters.isEmpty()) {
- for (Map.Entry<String, TypeConverters> entry : typeConverters.entrySet()) {
- TypeConverters converter = entry.getValue();
- LOG.info("Adding custom TypeConverters with id: {} and implementation: {}", entry.getKey(), converter);
- camelContext.getTypeConverterRegistry().addTypeConverters(converter);
- }
- }
- // set the event notifier strategies if defined
- Map<String, EventNotifier> eventNotifiers = applicationContext.getBeansOfType(EventNotifier.class);
- if (eventNotifiers != null && !eventNotifiers.isEmpty()) {
- for (Map.Entry<String, EventNotifier> entry : eventNotifiers.entrySet()) {
- EventNotifier notifier = entry.getValue();
- // do not add if already added, for instance a tracer that is also an InterceptStrategy class
- if (!camelContext.getManagementStrategy().getEventNotifiers().contains(notifier)) {
- LOG.info("Using custom EventNotifier with id: {} and implementation: {}", entry.getKey(), notifier);
- camelContext.getManagementStrategy().addEventNotifier(notifier);
- }
- }
- }
- // set endpoint strategies if defined
- Map<String, EndpointStrategy> endpointStrategies = applicationContext.getBeansOfType(EndpointStrategy.class);
- if (endpointStrategies != null && !endpointStrategies.isEmpty()) {
- for (Map.Entry<String, EndpointStrategy> entry : endpointStrategies.entrySet()) {
- EndpointStrategy strategy = entry.getValue();
- LOG.info("Using custom EndpointStrategy with id: {} and implementation: {}", entry.getKey(), strategy);
- camelContext.addRegisterEndpointCallback(strategy);
- }
- }
- // shutdown
- ShutdownStrategy shutdownStrategy = getSingleBeanOfType(applicationContext, ShutdownStrategy.class);
- if (shutdownStrategy != null) {
- LOG.info("Using custom ShutdownStrategy: " + shutdownStrategy);
- camelContext.setShutdownStrategy(shutdownStrategy);
- }
- // add global interceptors
- Map<String, InterceptStrategy> interceptStrategies = applicationContext.getBeansOfType(InterceptStrategy.class);
- if (interceptStrategies != null && !interceptStrategies.isEmpty()) {
- for (Map.Entry<String, InterceptStrategy> entry : interceptStrategies.entrySet()) {
- InterceptStrategy strategy = entry.getValue();
- // do not add if already added, for instance a tracer that is also an InterceptStrategy class
- if (!camelContext.getInterceptStrategies().contains(strategy)) {
- LOG.info("Using custom InterceptStrategy with id: {} and implementation: {}", entry.getKey(), strategy);
- camelContext.addInterceptStrategy(strategy);
- }
- }
- }
- // set the lifecycle strategy if defined
- Map<String, LifecycleStrategy> lifecycleStrategies = applicationContext.getBeansOfType(LifecycleStrategy.class);
- if (lifecycleStrategies != null && !lifecycleStrategies.isEmpty()) {
- for (Map.Entry<String, LifecycleStrategy> entry : lifecycleStrategies.entrySet()) {
- LifecycleStrategy strategy = entry.getValue();
- // do not add if already added, for instance a tracer that is also an InterceptStrategy class
- if (!camelContext.getLifecycleStrategies().contains(strategy)) {
- LOG.info("Using custom LifecycleStrategy with id: {} and implementation: {}", entry.getKey(), strategy);
- camelContext.addLifecycleStrategy(strategy);
- }
- }
- }
- // cluster service
- Map<String, CamelClusterService> clusterServices = applicationContext.getBeansOfType(CamelClusterService.class);
- if (clusterServices != null && !clusterServices.isEmpty()) {
- for (Map.Entry<String, CamelClusterService> entry : clusterServices.entrySet()) {
- CamelClusterService service = entry.getValue();
- LOG.info("Using CamelClusterService with id: {} and implementation: {}", service.getId(), service);
- camelContext.addService(service);
- }
- }
+
+ final ManagementStrategy managementStrategy = camelContext.getManagementStrategy();
+
+ registerPropertyForBeanType(applicationContext, BacklogTracer.class, camelContext::addInterceptStrategy);
+ registerPropertyForBeanType(applicationContext, HandleFault.class, camelContext::addInterceptStrategy);
+ registerPropertyForBeanType(applicationContext, InflightRepository.class, camelContext::setInflightRepository);
+ registerPropertyForBeanType(applicationContext, AsyncProcessorAwaitManager.class, camelContext::setAsyncProcessorAwaitManager);
+ registerPropertyForBeanType(applicationContext, ManagementStrategy.class, camelContext::setManagementStrategy);
+ registerPropertyForBeanType(applicationContext, ManagementNamingStrategy.class, managementStrategy::setManagementNamingStrategy);
+ registerPropertyForBeanType(applicationContext, EventFactory.class, managementStrategy::setEventFactory);
+ registerPropertyForBeanType(applicationContext, UnitOfWorkFactory.class, camelContext::setUnitOfWorkFactory);
+ registerPropertyForBeanType(applicationContext, RuntimeEndpointRegistry.class, camelContext::setRuntimeEndpointRegistry);
+
+ registerPropertiesForBeanTypes(applicationContext, TypeConverters.class, camelContext.getTypeConverterRegistry()::addTypeConverters);
+
+ final Predicate<EventNotifier> containsEventNotifier = managementStrategy.getEventNotifiers()::contains;
+ registerPropertiesForBeanTypesWithCondition(applicationContext, EventNotifier.class, containsEventNotifier.negate(), managementStrategy::addEventNotifier);
+
+ registerPropertiesForBeanTypes(applicationContext, EndpointStrategy.class, camelContext::addRegisterEndpointCallback);
+
+ registerPropertyForBeanType(applicationContext, ShutdownStrategy.class, camelContext::setShutdownStrategy);
+
+ final Predicate<InterceptStrategy> containsInterceptStrategy = camelContext.getInterceptStrategies()::contains;
+ registerPropertiesForBeanTypesWithCondition(applicationContext, InterceptStrategy.class, containsInterceptStrategy.negate(), camelContext::addInterceptStrategy);
+
+ final Predicate<LifecycleStrategy> containsLifecycleStrategy = camelContext.getLifecycleStrategies()::contains;
+ registerPropertiesForBeanTypesWithCondition(applicationContext, LifecycleStrategy.class, containsLifecycleStrategy.negate(), camelContext::addLifecycleStrategy);
+
+ registerPropertiesForBeanTypes(applicationContext, CamelClusterService.class, addServiceToContext(camelContext));
+
// service registry
Map<String, ServiceRegistry> serviceRegistries = applicationContext.getBeansOfType(ServiceRegistry.class);
if (serviceRegistries != null && !serviceRegistries.isEmpty()) {
@@ -489,15 +407,9 @@ public class CamelAutoConfiguration {
camelContext.addService(service);
}
}
- // add route policy factories
- Map<String, RoutePolicyFactory> routePolicyFactories = applicationContext.getBeansOfType(RoutePolicyFactory.class);
- if (routePolicyFactories != null && !routePolicyFactories.isEmpty()) {
- for (Map.Entry<String, RoutePolicyFactory> entry : routePolicyFactories.entrySet()) {
- RoutePolicyFactory factory = entry.getValue();
- LOG.info("Using custom RoutePolicyFactory with id: {} and implementation: {}", entry.getKey(), factory);
- camelContext.addRoutePolicyFactory(factory);
- }
- }
+
+ registerPropertiesForBeanTypes(applicationContext, RoutePolicyFactory.class, camelContext::addRoutePolicyFactory);
+
// add SSL context parameters
GlobalSSLContextParametersSupplier sslContextParametersSupplier = getSingleBeanOfType(applicationContext, GlobalSSLContextParametersSupplier.class);
if (sslContextParametersSupplier != null) {
@@ -513,54 +425,62 @@ public class CamelAutoConfiguration {
healthCheckRegistry = camelContext.getHealthCheckRegistry();
healthCheckRegistry.setCamelContext(camelContext);
}
- // Health check repository
- Map<String, HealthCheckRepository> repositories = applicationContext.getBeansOfType(HealthCheckRepository.class);
- if (ObjectHelper.isNotEmpty(repositories)) {
- for (HealthCheckRepository repository: repositories.values()) {
- healthCheckRegistry.addRepository(repository);
- }
- }
- // Health check service
- HealthCheckService healthCheckService = getSingleBeanOfType(applicationContext, HealthCheckService.class);
- if (healthCheckService != null) {
- LOG.info("Using HealthCheckService: {}", healthCheckService);
- camelContext.addService(healthCheckService);
- }
- // Route controller
- RouteController routeController = getSingleBeanOfType(applicationContext, RouteController.class);
- if (routeController != null) {
- LOG.info("Using RouteController: " + routeController);
- camelContext.setRouteController(routeController);
- }
- // UuidGenerator
- UuidGenerator uuidGenerator = getSingleBeanOfType(applicationContext, UuidGenerator.class);
- if (uuidGenerator != null) {
- LOG.info("Using custom UuidGenerator: {}", uuidGenerator);
- camelContext.setUuidGenerator(uuidGenerator);
- }
- // LogListener
- Map<String, LogListener> logListeners = applicationContext.getBeansOfType(LogListener.class);
- if (logListeners != null && !logListeners.isEmpty()) {
- for (Map.Entry<String, LogListener> entry : logListeners.entrySet()) {
- LogListener logListener = entry.getValue();
- if (!camelContext.getLogListeners().contains(logListener)) {
- LOG.info("Using custom LogListener with id: {} and implementation: {}", entry.getKey(), logListener);
- camelContext.addLogListener(logListener);
- }
- }
- }
- // ExecutorServiceManager
- final ExecutorServiceManager executorServiceManager = getSingleBeanOfType(applicationContext, ExecutorServiceManager.class);
- if (executorServiceManager != null) {
- LOG.info("Using custom ExecutorServiceManager: {}", executorServiceManager);
- camelContext.setExecutorServiceManager(executorServiceManager);
- }
+ registerPropertiesForBeanTypes(applicationContext, HealthCheckRepository.class, healthCheckRegistry::addRepository);
+
+ registerPropertyForBeanType(applicationContext, HealthCheckService.class, addServiceToContext(camelContext));
+ registerPropertyForBeanType(applicationContext, RouteController.class, camelContext::setRouteController);
+ registerPropertyForBeanType(applicationContext, UuidGenerator.class, camelContext::setUuidGenerator);
+
+ final Predicate<LogListener> containsLogListener = camelContext.getLogListeners()::contains;
+ registerPropertiesForBeanTypesWithCondition(applicationContext, LogListener.class, containsLogListener.negate(), camelContext::addLogListener);
+
+ registerPropertyForBeanType(applicationContext, ExecutorServiceManager.class, camelContext::setExecutorServiceManager);
// set the default thread pool profile if defined
initThreadPoolProfiles(applicationContext, camelContext);
}
+ private static <T> Consumer<T> addServiceToContext(final CamelContext camelContext) {
+ return service -> {
+ try {
+ camelContext.addService(service);
+ } catch (Exception e) {
+ throw new RuntimeException("Unable to add service to Camel context", e);
+ }
+ };
+ }
+
+ private static <T> void registerPropertyForBeanType(final ApplicationContext applicationContext, final Class<T> beanType, final Consumer<T> propertySetter) {
+ T propertyBean = getSingleBeanOfType(applicationContext, beanType);
+ if (propertyBean == null) {
+ return;
+ }
+
+ LOG.info("Using custom {}: {}", beanType.getSimpleName(), propertyBean);
+ propertySetter.accept(propertyBean);
+ }
+
+ private static <T> void registerPropertiesForBeanTypes(final ApplicationContext applicationContext, final Class<T> beanType, final Consumer<T> propertySetter) {
+ registerPropertiesForBeanTypesWithCondition(applicationContext, beanType, b -> true, propertySetter);
+ }
+
+ private static <T> void registerPropertiesForBeanTypesWithCondition(final ApplicationContext applicationContext, final Class<T> beanType, final Predicate<T> condition,
+ final Consumer<T> propertySetter) {
+ final Map<String, T> beans = applicationContext.getBeansOfType(beanType);
+ if (!ObjectHelper.isNotEmpty(beans)) {
+ return;
+ }
+
+ final String simpleName = beanType.getSimpleName();
+ beans.forEach((name, bean) -> {
+ if (condition.test(bean)) {
+ LOG.info("Adding custom {} with id: {} and implementation: {}", simpleName, name, bean);
+ propertySetter.accept(bean);
+ }
+ });
+ }
+
private static void initThreadPoolProfiles(ApplicationContext applicationContext, CamelContext camelContext) {
Set<String> defaultIds = new HashSet<>();
--
To stop receiving notification emails like this one, please contact
zregvart@apache.org.