org.apache.camel.spring.CamelContextFactoryBean Maven / Gradle / Ivy
/**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.camel.spring;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlElements;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlTransient;
import org.apache.camel.CamelContext;
import org.apache.camel.LoggingLevel;
import org.apache.camel.RoutesBuilder;
import org.apache.camel.ShutdownRoute;
import org.apache.camel.ShutdownRunningTask;
import org.apache.camel.TypeConverterExists;
import org.apache.camel.builder.RouteBuilder;
import org.apache.camel.component.properties.PropertiesComponent;
import org.apache.camel.core.xml.AbstractCamelContextFactoryBean;
import org.apache.camel.core.xml.CamelJMXAgentDefinition;
import org.apache.camel.core.xml.CamelPropertyPlaceholderDefinition;
import org.apache.camel.core.xml.CamelProxyFactoryDefinition;
import org.apache.camel.core.xml.CamelServiceExporterDefinition;
import org.apache.camel.core.xml.CamelStreamCachingStrategyDefinition;
import org.apache.camel.model.ContextScanDefinition;
import org.apache.camel.model.InterceptDefinition;
import org.apache.camel.model.InterceptFromDefinition;
import org.apache.camel.model.InterceptSendToEndpointDefinition;
import org.apache.camel.model.OnCompletionDefinition;
import org.apache.camel.model.OnExceptionDefinition;
import org.apache.camel.model.PackageScanDefinition;
import org.apache.camel.model.PropertiesDefinition;
import org.apache.camel.model.RestContextRefDefinition;
import org.apache.camel.model.RouteBuilderDefinition;
import org.apache.camel.model.RouteContextRefDefinition;
import org.apache.camel.model.RouteDefinition;
import org.apache.camel.model.ThreadPoolProfileDefinition;
import org.apache.camel.model.dataformat.DataFormatsDefinition;
import org.apache.camel.model.rest.RestConfigurationDefinition;
import org.apache.camel.model.rest.RestDefinition;
import org.apache.camel.spi.PackageScanFilter;
import org.apache.camel.spi.Registry;
import org.apache.camel.spring.spi.BridgePropertyPlaceholderConfigurer;
import org.apache.camel.util.CamelContextHelper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
import static org.apache.camel.util.ObjectHelper.wrapRuntimeCamelException;
/**
* A Spring {@link FactoryBean} to create and initialize a
* {@link SpringCamelContext} and install routes either explicitly configured in
* Spring XML or found by searching the classpath for Java classes which extend
* {@link RouteBuilder} using the nested {@link #setPackages(String[])}.
*
* @version
*/
@XmlRootElement(name = "camelContext")
@XmlAccessorType(XmlAccessType.FIELD)
public class CamelContextFactoryBean extends AbstractCamelContextFactoryBean
implements FactoryBean, InitializingBean, DisposableBean, ApplicationContextAware, ApplicationListener {
private static final Logger LOG = LoggerFactory.getLogger(CamelContextFactoryBean.class);
@XmlAttribute(name = "depends-on", required = false)
private String dependsOn;
@XmlAttribute(required = false)
private String trace;
@XmlAttribute(required = false)
private String messageHistory;
@XmlAttribute(required = false)
private String streamCache;
@XmlAttribute(required = false)
private String delayer;
@XmlAttribute(required = false)
private String handleFault;
@XmlAttribute(required = false)
private String errorHandlerRef;
@XmlAttribute(required = false)
private String autoStartup;
@XmlAttribute(required = false)
private String shutdownEager;
@XmlAttribute(required = false)
private String useMDCLogging;
@XmlAttribute(required = false)
private String useBreadcrumb;
@XmlAttribute(required = false)
private String allowUseOriginalMessage;
@XmlAttribute(required = false)
private String runtimeEndpointRegistryEnabled;
@XmlAttribute(required = false)
private String managementNamePattern;
@XmlAttribute(required = false)
private String threadNamePattern;
@XmlAttribute(required = false)
private ShutdownRoute shutdownRoute;
@XmlAttribute(required = false)
private ShutdownRunningTask shutdownRunningTask;
@XmlAttribute(required = false)
@Deprecated
private Boolean lazyLoadTypeConverters;
@XmlAttribute(required = false)
private Boolean typeConverterStatisticsEnabled;
@XmlAttribute(required = false)
private TypeConverterExists typeConverterExists;
@XmlAttribute(required = false)
private LoggingLevel typeConverterExistsLoggingLevel;
@XmlElement(name = "properties", required = false)
private PropertiesDefinition properties;
@XmlElement(name = "propertyPlaceholder", type = CamelPropertyPlaceholderDefinition.class, required = false)
private CamelPropertyPlaceholderDefinition camelPropertyPlaceholder;
@XmlElement(name = "package", required = false)
private String[] packages = {};
@XmlElement(name = "packageScan", type = PackageScanDefinition.class, required = false)
private PackageScanDefinition packageScan;
@XmlElement(name = "contextScan", type = ContextScanDefinition.class, required = false)
private ContextScanDefinition contextScan;
@XmlElement(name = "streamCaching", type = CamelStreamCachingStrategyDefinition.class, required = false)
private CamelStreamCachingStrategyDefinition camelStreamCachingStrategy;
@XmlElement(name = "jmxAgent", type = CamelJMXAgentDefinition.class, required = false)
private CamelJMXAgentDefinition camelJMXAgent;
@XmlElements({
@XmlElement(name = "template", type = CamelProducerTemplateFactoryBean.class, required = false),
@XmlElement(name = "consumerTemplate", type = CamelConsumerTemplateFactoryBean.class, required = false),
@XmlElement(name = "proxy", type = CamelProxyFactoryDefinition.class, required = false),
@XmlElement(name = "export", type = CamelServiceExporterDefinition.class, required = false),
@XmlElement(name = "errorHandler", type = ErrorHandlerDefinition.class, required = false)})
private List beans;
@XmlElement(name = "routeBuilder", required = false)
private List builderRefs = new ArrayList();
@XmlElement(name = "routeContextRef", required = false)
private List routeRefs = new ArrayList();
@XmlElement(name = "restContextRef", required = false)
private List restRefs = new ArrayList();
@XmlElement(name = "threadPoolProfile", required = false)
private List threadPoolProfiles;
@XmlElement(name = "threadPool", required = false)
private List threadPools;
@XmlElement(name = "endpoint", required = false)
private List endpoints;
@XmlElement(name = "dataFormats", required = false)
private DataFormatsDefinition dataFormats;
@XmlElement(name = "redeliveryPolicyProfile", required = false)
private List redeliveryPolicies;
@XmlElement(name = "onException", required = false)
private List onExceptions = new ArrayList();
@XmlElement(name = "onCompletion", required = false)
private List onCompletions = new ArrayList();
@XmlElement(name = "intercept", required = false)
private List intercepts = new ArrayList();
@XmlElement(name = "interceptFrom", required = false)
private List interceptFroms = new ArrayList();
@XmlElement(name = "interceptSendToEndpoint", required = false)
private List interceptSendToEndpoints = new ArrayList();
@XmlElement(name = "restConfiguration", required = false)
private RestConfigurationDefinition restConfiguration;
@XmlElement(name = "rest", required = false)
private List rests = new ArrayList();
@XmlElement(name = "route", required = false)
private List routes = new ArrayList();
@XmlTransient
private SpringCamelContext context;
@XmlTransient
private ClassLoader contextClassLoaderOnStart;
@XmlTransient
private ApplicationContext applicationContext;
@XmlTransient
private BeanPostProcessor beanPostProcessor;
@XmlTransient
private boolean implicitId;
@Override
public Class getObjectType() {
return SpringCamelContext.class;
}
protected S getBeanForType(Class clazz) {
S bean = null;
String[] names = getApplicationContext().getBeanNamesForType(clazz, true, true);
if (names.length == 1) {
bean = getApplicationContext().getBean(names[0], clazz);
}
if (bean == null) {
ApplicationContext parentContext = getApplicationContext().getParent();
if (parentContext != null) {
names = parentContext.getBeanNamesForType(clazz, true, true);
if (names.length == 1) {
bean = parentContext.getBean(names[0], clazz);
}
}
}
return bean;
}
@Override
protected void findRouteBuildersByPackageScan(String[] packages, PackageScanFilter filter, List builders) throws Exception {
// add filter to class resolver which then will filter
getContext().getPackageScanClassResolver().addFilter(filter);
PackageScanRouteBuilderFinder finder = new PackageScanRouteBuilderFinder(getContext(), packages, getContextClassLoaderOnStart(),
getBeanPostProcessor(), getContext().getPackageScanClassResolver());
finder.appendBuilders(builders);
// and remove the filter
getContext().getPackageScanClassResolver().removeFilter(filter);
}
@Override
protected void findRouteBuildersByContextScan(PackageScanFilter filter, boolean includeNonSingletons, List builders) throws Exception {
ContextScanRouteBuilderFinder finder = new ContextScanRouteBuilderFinder(getContext(), filter, includeNonSingletons);
finder.appendBuilders(builders);
}
protected void initBeanPostProcessor(SpringCamelContext context) {
if (beanPostProcessor != null) {
if (beanPostProcessor instanceof ApplicationContextAware) {
((ApplicationContextAware) beanPostProcessor).setApplicationContext(applicationContext);
}
if (beanPostProcessor instanceof CamelBeanPostProcessor) {
((CamelBeanPostProcessor) beanPostProcessor).setCamelContext(getContext());
}
}
}
protected void postProcessBeforeInit(RouteBuilder builder) {
if (beanPostProcessor != null) {
// Inject the annotated resource
beanPostProcessor.postProcessBeforeInitialization(builder, builder.toString());
}
}
@Override
public void afterPropertiesSet() throws Exception {
super.afterPropertiesSet();
Boolean shutdownEager = CamelContextHelper.parseBoolean(getContext(), getShutdownEager());
if (shutdownEager != null) {
LOG.debug("Using shutdownEager: " + shutdownEager);
getContext().setShutdownEager(shutdownEager);
}
}
protected void initCustomRegistry(SpringCamelContext context) {
Registry registry = getBeanForType(Registry.class);
if (registry != null) {
LOG.info("Using custom Registry: " + registry);
context.setRegistry(registry);
}
}
@Override
protected void initPropertyPlaceholder() throws Exception {
super.initPropertyPlaceholder();
Map beans = applicationContext.getBeansOfType(BridgePropertyPlaceholderConfigurer.class);
if (beans.size() == 1) {
// setup properties component that uses this beans
BridgePropertyPlaceholderConfigurer configurer = beans.values().iterator().next();
String id = beans.keySet().iterator().next();
LOG.info("Bridging Camel and Spring property placeholder configurer with id: " + id);
// get properties component
PropertiesComponent pc = (PropertiesComponent) getContext().getComponent("properties", false);
if (pc == null) {
// do not auto create the component as spring autowrire by constructor causes a side effect when using bridge
pc = new PropertiesComponent();
getContext().addComponent("properties", pc);
}
// use the spring system properties mode which has a different value than Camel may have
pc.setSystemPropertiesMode(configurer.getSystemPropertiesMode());
// replace existing resolver with us
configurer.setResolver(pc.getPropertiesResolver());
configurer.setParser(pc.getPropertiesParser());
String ref = "ref:" + id;
// use the bridge to handle the resolve and parsing
pc.setPropertiesResolver(configurer);
pc.setPropertiesParser(configurer);
// and update locations to have our as ref first
String[] locations = pc.getLocations();
String[] updatedLocations;
if (locations != null && locations.length > 0) {
updatedLocations = new String[locations.length + 1];
updatedLocations[0] = ref;
System.arraycopy(locations, 0, updatedLocations, 1, locations.length);
} else {
updatedLocations = new String[]{ref};
}
pc.setLocations(updatedLocations);
} else if (beans.size() > 1) {
LOG.warn("Cannot bridge Camel and Spring property placeholders, as exact only 1 bean of type BridgePropertyPlaceholderConfigurer"
+ " must be defined, was {} beans defined.", beans.size());
}
}
public void onApplicationEvent(ApplicationEvent event) {
// From Spring 3.0.1, The BeanFactory applicationEventListener
// and Bean's applicationEventListener will be called,
// So we just delegate the onApplicationEvent call here.
SpringCamelContext context = getContext(false);
if (context != null) {
// we need to defer setting up routes until Spring has done all its dependency injection
// which is only guaranteed to be done when it emits the ContextRefreshedEvent event.
if (event instanceof ContextRefreshedEvent) {
try {
setupRoutes();
} catch (Exception e) {
throw wrapRuntimeCamelException(e);
}
}
// let the spring camel context handle the events
context.onApplicationEvent(event);
} else {
LOG.debug("Publishing spring-event: {}", event);
if (event instanceof ContextRefreshedEvent) {
// now lets start the CamelContext so that all its possible
// dependencies are initialized
try {
// we need to defer setting up routes until Spring has done all its dependency injection
// which is only guaranteed to be done when it emits the ContextRefreshedEvent event.
setupRoutes();
LOG.trace("Starting the context now");
getContext().start();
} catch (Exception e) {
throw wrapRuntimeCamelException(e);
}
}
}
}
// Properties
// -------------------------------------------------------------------------
public ApplicationContext getApplicationContext() {
if (applicationContext == null) {
throw new IllegalArgumentException("No applicationContext has been injected!");
}
return applicationContext;
}
public void setApplicationContext(ApplicationContext applicationContext) {
this.applicationContext = applicationContext;
}
public void setBeanPostProcessor(BeanPostProcessor postProcessor) {
this.beanPostProcessor = postProcessor;
}
public BeanPostProcessor getBeanPostProcessor() {
return beanPostProcessor;
}
// Implementation methods
// -------------------------------------------------------------------------
/**
* Create the context
*/
protected SpringCamelContext createContext() {
SpringCamelContext ctx = newCamelContext();
ctx.setName(getId());
return ctx;
}
protected SpringCamelContext newCamelContext() {
return new SpringCamelContext(getApplicationContext());
}
public SpringCamelContext getContext(boolean create) {
if (context == null && create) {
context = createContext();
}
return context;
}
public void setContext(SpringCamelContext context) {
this.context = context;
}
public List getRoutes() {
return routes;
}
public void setRoutes(List routes) {
this.routes = routes;
}
public List getRests() {
return rests;
}
public void setRests(List rests) {
this.rests = rests;
}
public RestConfigurationDefinition getRestConfiguration() {
return restConfiguration;
}
public void setRestConfiguration(RestConfigurationDefinition restConfiguration) {
this.restConfiguration = restConfiguration;
}
public List getEndpoints() {
return endpoints;
}
public void setEndpoints(List endpoints) {
this.endpoints = endpoints;
}
public List getRedeliveryPolicies() {
return redeliveryPolicies;
}
public List getIntercepts() {
return intercepts;
}
public void setIntercepts(List intercepts) {
this.intercepts = intercepts;
}
public List getInterceptFroms() {
return interceptFroms;
}
public void setInterceptFroms(List interceptFroms) {
this.interceptFroms = interceptFroms;
}
public List getInterceptSendToEndpoints() {
return interceptSendToEndpoints;
}
public void setInterceptSendToEndpoints(List interceptSendToEndpoints) {
this.interceptSendToEndpoints = interceptSendToEndpoints;
}
public PropertiesDefinition getProperties() {
return properties;
}
public void setProperties(PropertiesDefinition properties) {
this.properties = properties;
}
public String[] getPackages() {
return packages;
}
/**
* Sets the package names to be recursively searched for Java classes which
* extend {@link org.apache.camel.builder.RouteBuilder} to be auto-wired up to the
* {@link CamelContext} as a route. Note that classes are excluded if
* they are specifically configured in the spring.xml
*
* A more advanced configuration can be done using {@link #setPackageScan(org.apache.camel.model.PackageScanDefinition)}
*
* @param packages the package names which are recursively searched
* @see #setPackageScan(org.apache.camel.model.PackageScanDefinition)
*/
public void setPackages(String[] packages) {
this.packages = packages;
}
public PackageScanDefinition getPackageScan() {
return packageScan;
}
/**
* Sets the package scanning information. Package scanning allows for the
* automatic discovery of certain camel classes at runtime for inclusion
* e.g. {@link org.apache.camel.builder.RouteBuilder} implementations
*
* @param packageScan the package scan
*/
public void setPackageScan(PackageScanDefinition packageScan) {
this.packageScan = packageScan;
}
public ContextScanDefinition getContextScan() {
return contextScan;
}
/**
* Sets the context scanning (eg Spring's ApplicationContext) information.
* Context scanning allows for the automatic discovery of Camel routes runtime for inclusion
* e.g. {@link org.apache.camel.builder.RouteBuilder} implementations
*
* @param contextScan the context scan
*/
public void setContextScan(ContextScanDefinition contextScan) {
this.contextScan = contextScan;
}
public CamelPropertyPlaceholderDefinition getCamelPropertyPlaceholder() {
return camelPropertyPlaceholder;
}
public void setCamelPropertyPlaceholder(CamelPropertyPlaceholderDefinition camelPropertyPlaceholder) {
this.camelPropertyPlaceholder = camelPropertyPlaceholder;
}
public CamelStreamCachingStrategyDefinition getCamelStreamCachingStrategy() {
return camelStreamCachingStrategy;
}
public void setCamelStreamCachingStrategy(CamelStreamCachingStrategyDefinition camelStreamCachingStrategy) {
this.camelStreamCachingStrategy = camelStreamCachingStrategy;
}
public void setCamelJMXAgent(CamelJMXAgentDefinition agent) {
camelJMXAgent = agent;
}
public String getTrace() {
return trace;
}
public void setTrace(String trace) {
this.trace = trace;
}
public String getMessageHistory() {
return messageHistory;
}
public void setMessageHistory(String messageHistory) {
this.messageHistory = messageHistory;
}
public String getStreamCache() {
return streamCache;
}
public void setStreamCache(String streamCache) {
this.streamCache = streamCache;
}
public String getDelayer() {
return delayer;
}
public void setDelayer(String delayer) {
this.delayer = delayer;
}
public String getHandleFault() {
return handleFault;
}
public void setHandleFault(String handleFault) {
this.handleFault = handleFault;
}
public String getAutoStartup() {
return autoStartup;
}
public void setAutoStartup(String autoStartup) {
this.autoStartup = autoStartup;
}
public String getShutdownEager() {
return shutdownEager;
}
public void setShutdownEager(String shutdownEager) {
this.shutdownEager = shutdownEager;
}
public String getUseMDCLogging() {
return useMDCLogging;
}
public void setUseMDCLogging(String useMDCLogging) {
this.useMDCLogging = useMDCLogging;
}
public String getUseBreadcrumb() {
return useBreadcrumb;
}
public void setUseBreadcrumb(String useBreadcrumb) {
this.useBreadcrumb = useBreadcrumb;
}
public String getAllowUseOriginalMessage() {
return allowUseOriginalMessage;
}
public void setAllowUseOriginalMessage(String allowUseOriginalMessage) {
this.allowUseOriginalMessage = allowUseOriginalMessage;
}
public String getRuntimeEndpointRegistryEnabled() {
return runtimeEndpointRegistryEnabled;
}
public void setRuntimeEndpointRegistryEnabled(String runtimeEndpointRegistryEnabled) {
this.runtimeEndpointRegistryEnabled = runtimeEndpointRegistryEnabled;
}
public String getManagementNamePattern() {
return managementNamePattern;
}
public void setManagementNamePattern(String managementNamePattern) {
this.managementNamePattern = managementNamePattern;
}
public String getThreadNamePattern() {
return threadNamePattern;
}
public void setThreadNamePattern(String threadNamePattern) {
this.threadNamePattern = threadNamePattern;
}
@Deprecated
public Boolean getLazyLoadTypeConverters() {
return lazyLoadTypeConverters;
}
@Deprecated
public void setLazyLoadTypeConverters(Boolean lazyLoadTypeConverters) {
this.lazyLoadTypeConverters = lazyLoadTypeConverters;
}
public Boolean getTypeConverterStatisticsEnabled() {
return typeConverterStatisticsEnabled;
}
public void setTypeConverterStatisticsEnabled(Boolean typeConverterStatisticsEnabled) {
this.typeConverterStatisticsEnabled = typeConverterStatisticsEnabled;
}
public TypeConverterExists getTypeConverterExists() {
return typeConverterExists;
}
public void setTypeConverterExists(TypeConverterExists typeConverterExists) {
this.typeConverterExists = typeConverterExists;
}
public LoggingLevel getTypeConverterExistsLoggingLevel() {
return typeConverterExistsLoggingLevel;
}
public void setTypeConverterExistsLoggingLevel(LoggingLevel typeConverterExistsLoggingLevel) {
this.typeConverterExistsLoggingLevel = typeConverterExistsLoggingLevel;
}
public CamelJMXAgentDefinition getCamelJMXAgent() {
return camelJMXAgent;
}
public List getBuilderRefs() {
return builderRefs;
}
public void setBuilderRefs(List builderRefs) {
this.builderRefs = builderRefs;
}
public List getRouteRefs() {
return routeRefs;
}
public void setRouteRefs(List routeRefs) {
this.routeRefs = routeRefs;
}
public List getRestRefs() {
return restRefs;
}
public void setRestRefs(List restRefs) {
this.restRefs = restRefs;
}
public String getErrorHandlerRef() {
return errorHandlerRef;
}
/**
* Sets the name of the error handler object used to default the error handling strategy
*
* @param errorHandlerRef the Spring bean ref of the error handler
*/
public void setErrorHandlerRef(String errorHandlerRef) {
this.errorHandlerRef = errorHandlerRef;
}
public void setDataFormats(DataFormatsDefinition dataFormats) {
this.dataFormats = dataFormats;
}
public DataFormatsDefinition getDataFormats() {
return dataFormats;
}
public void setOnExceptions(List onExceptions) {
this.onExceptions = onExceptions;
}
public List getOnExceptions() {
return onExceptions;
}
public List getOnCompletions() {
return onCompletions;
}
public void setOnCompletions(List onCompletions) {
this.onCompletions = onCompletions;
}
public ShutdownRoute getShutdownRoute() {
return shutdownRoute;
}
public void setShutdownRoute(ShutdownRoute shutdownRoute) {
this.shutdownRoute = shutdownRoute;
}
public ShutdownRunningTask getShutdownRunningTask() {
return shutdownRunningTask;
}
public void setShutdownRunningTask(ShutdownRunningTask shutdownRunningTask) {
this.shutdownRunningTask = shutdownRunningTask;
}
public List getThreadPoolProfiles() {
return threadPoolProfiles;
}
public void setThreadPoolProfiles(List threadPoolProfiles) {
this.threadPoolProfiles = threadPoolProfiles;
}
public String getDependsOn() {
return dependsOn;
}
public void setDependsOn(String dependsOn) {
this.dependsOn = dependsOn;
}
public boolean isImplicitId() {
return implicitId;
}
public void setImplicitId(boolean flag) {
implicitId = flag;
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy