001    /**
002     * Licensed to the Apache Software Foundation (ASF) under one or more
003     * contributor license agreements.  See the NOTICE file distributed with
004     * this work for additional information regarding copyright ownership.
005     * The ASF licenses this file to You under the Apache License, Version 2.0
006     * (the "License"); you may not use this file except in compliance with
007     * the License.  You may obtain a copy of the License at
008     *
009     *      http://www.apache.org/licenses/LICENSE-2.0
010     *
011     * Unless required by applicable law or agreed to in writing, software
012     * distributed under the License is distributed on an "AS IS" BASIS,
013     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014     * See the License for the specific language governing permissions and
015     * limitations under the License.
016     */
017    package org.apache.camel.spring;
018    
019    import java.util.ArrayList;
020    import java.util.List;
021    import java.util.Map;
022    import javax.xml.bind.annotation.XmlAccessType;
023    import javax.xml.bind.annotation.XmlAccessorType;
024    import javax.xml.bind.annotation.XmlAttribute;
025    import javax.xml.bind.annotation.XmlElement;
026    import javax.xml.bind.annotation.XmlElements;
027    import javax.xml.bind.annotation.XmlRootElement;
028    import javax.xml.bind.annotation.XmlTransient;
029    
030    import org.apache.camel.CamelContext;
031    import org.apache.camel.RoutesBuilder;
032    import org.apache.camel.ShutdownRoute;
033    import org.apache.camel.ShutdownRunningTask;
034    import org.apache.camel.builder.RouteBuilder;
035    import org.apache.camel.component.properties.PropertiesComponent;
036    import org.apache.camel.core.xml.AbstractCamelContextFactoryBean;
037    import org.apache.camel.core.xml.CamelJMXAgentDefinition;
038    import org.apache.camel.core.xml.CamelPropertyPlaceholderDefinition;
039    import org.apache.camel.core.xml.CamelProxyFactoryDefinition;
040    import org.apache.camel.core.xml.CamelServiceExporterDefinition;
041    import org.apache.camel.core.xml.CamelStreamCachingStrategyDefinition;
042    import org.apache.camel.model.ContextScanDefinition;
043    import org.apache.camel.model.InterceptDefinition;
044    import org.apache.camel.model.InterceptFromDefinition;
045    import org.apache.camel.model.InterceptSendToEndpointDefinition;
046    import org.apache.camel.model.OnCompletionDefinition;
047    import org.apache.camel.model.OnExceptionDefinition;
048    import org.apache.camel.model.PackageScanDefinition;
049    import org.apache.camel.model.RouteBuilderDefinition;
050    import org.apache.camel.model.RouteContextRefDefinition;
051    import org.apache.camel.model.RouteDefinition;
052    import org.apache.camel.model.ThreadPoolProfileDefinition;
053    import org.apache.camel.model.config.PropertiesDefinition;
054    import org.apache.camel.model.dataformat.DataFormatsDefinition;
055    import org.apache.camel.spi.PackageScanFilter;
056    import org.apache.camel.spi.Registry;
057    import org.apache.camel.spring.spi.BridgePropertyPlaceholderConfigurer;
058    import org.apache.camel.util.CamelContextHelper;
059    import org.slf4j.Logger;
060    import org.slf4j.LoggerFactory;
061    import org.springframework.beans.factory.DisposableBean;
062    import org.springframework.beans.factory.FactoryBean;
063    import org.springframework.beans.factory.InitializingBean;
064    import org.springframework.beans.factory.config.BeanPostProcessor;
065    import org.springframework.context.ApplicationContext;
066    import org.springframework.context.ApplicationContextAware;
067    import org.springframework.context.ApplicationEvent;
068    import org.springframework.context.ApplicationListener;
069    import org.springframework.context.event.ContextRefreshedEvent;
070    
071    import static org.apache.camel.util.ObjectHelper.wrapRuntimeCamelException;
072    
073    /**
074     * A Spring {@link FactoryBean} to create and initialize a
075     * {@link SpringCamelContext} and install routes either explicitly configured in
076     * Spring XML or found by searching the classpath for Java classes which extend
077     * {@link RouteBuilder} using the nested {@link #setPackages(String[])}.
078     *
079     * @version 
080     */
081    @XmlRootElement(name = "camelContext")
082    @XmlAccessorType(XmlAccessType.FIELD)
083    public class CamelContextFactoryBean extends AbstractCamelContextFactoryBean<SpringCamelContext>
084            implements FactoryBean<SpringCamelContext>, InitializingBean, DisposableBean, ApplicationContextAware, ApplicationListener<ApplicationEvent> {
085        private static final Logger LOG = LoggerFactory.getLogger(CamelContextFactoryBean.class);
086    
087        @XmlAttribute(name = "depends-on", required = false)
088        private String dependsOn;
089        @XmlAttribute(required = false)
090        private String trace;
091        @XmlAttribute(required = false)
092        private String messageHistory;
093        @XmlAttribute(required = false)
094        private String streamCache;
095        @XmlAttribute(required = false)
096        private String delayer;
097        @XmlAttribute(required = false)
098        private String handleFault;
099        @XmlAttribute(required = false)
100        private String errorHandlerRef;
101        @XmlAttribute(required = false)
102        private String autoStartup;
103        @XmlAttribute(required = false)
104        private String shutdownEager;
105        @XmlAttribute(required = false)
106        private String useMDCLogging;
107        @XmlAttribute(required = false)
108        private String useBreadcrumb;
109        @XmlAttribute(required = false)
110        private String allowUseOriginalMessage;
111        @XmlAttribute(required = false)
112        private String runtimeEndpointRegistryEnabled;
113        @XmlAttribute(required = false)
114        private String managementNamePattern;
115        @XmlAttribute(required = false)
116        private String threadNamePattern;
117        @XmlAttribute(required = false)
118        private ShutdownRoute shutdownRoute;
119        @XmlAttribute(required = false)
120        private ShutdownRunningTask shutdownRunningTask;
121        @XmlAttribute(required = false)
122        @Deprecated
123        private Boolean lazyLoadTypeConverters;
124        @XmlAttribute(required = false)
125        private Boolean typeConverterStatisticsEnabled;
126        @XmlElement(name = "properties", required = false)
127        private PropertiesDefinition properties;
128        @XmlElement(name = "propertyPlaceholder", type = CamelPropertyPlaceholderDefinition.class, required = false)
129        private CamelPropertyPlaceholderDefinition camelPropertyPlaceholder;
130        @XmlElement(name = "package", required = false)
131        private String[] packages = {};
132        @XmlElement(name = "packageScan", type = PackageScanDefinition.class, required = false)
133        private PackageScanDefinition packageScan;
134        @XmlElement(name = "contextScan", type = ContextScanDefinition.class, required = false)
135        private ContextScanDefinition contextScan;
136        @XmlElement(name = "streamCaching", type = CamelStreamCachingStrategyDefinition.class, required = false)
137        private CamelStreamCachingStrategyDefinition camelStreamCachingStrategy;
138        @XmlElement(name = "jmxAgent", type = CamelJMXAgentDefinition.class, required = false)
139        private CamelJMXAgentDefinition camelJMXAgent;
140        @XmlElements({
141                @XmlElement(name = "template", type = CamelProducerTemplateFactoryBean.class, required = false),
142                @XmlElement(name = "consumerTemplate", type = CamelConsumerTemplateFactoryBean.class, required = false),
143                @XmlElement(name = "proxy", type = CamelProxyFactoryDefinition.class, required = false),
144                @XmlElement(name = "export", type = CamelServiceExporterDefinition.class, required = false),
145                @XmlElement(name = "errorHandler", type = ErrorHandlerDefinition.class, required = false)})
146        private List<?> beans;
147        @XmlElement(name = "routeBuilder", required = false)
148        private List<RouteBuilderDefinition> builderRefs = new ArrayList<RouteBuilderDefinition>();
149        @XmlElement(name = "routeContextRef", required = false)
150        private List<RouteContextRefDefinition> routeRefs = new ArrayList<RouteContextRefDefinition>();
151        @XmlElement(name = "threadPoolProfile", required = false)
152        private List<ThreadPoolProfileDefinition> threadPoolProfiles;
153        @XmlElement(name = "threadPool", required = false)
154        private List<CamelThreadPoolFactoryBean> threadPools;
155        @XmlElement(name = "endpoint", required = false)
156        private List<CamelEndpointFactoryBean> endpoints;
157        @XmlElement(name = "dataFormats", required = false)
158        private DataFormatsDefinition dataFormats;
159        @XmlElement(name = "redeliveryPolicyProfile", required = false)
160        private List<CamelRedeliveryPolicyFactoryBean> redeliveryPolicies;
161        @XmlElement(name = "onException", required = false)
162        private List<OnExceptionDefinition> onExceptions = new ArrayList<OnExceptionDefinition>();
163        @XmlElement(name = "onCompletion", required = false)
164        private List<OnCompletionDefinition> onCompletions = new ArrayList<OnCompletionDefinition>();
165        @XmlElement(name = "intercept", required = false)
166        private List<InterceptDefinition> intercepts = new ArrayList<InterceptDefinition>();
167        @XmlElement(name = "interceptFrom", required = false)
168        private List<InterceptFromDefinition> interceptFroms = new ArrayList<InterceptFromDefinition>();
169        @XmlElement(name = "interceptSendToEndpoint", required = false)
170        private List<InterceptSendToEndpointDefinition> interceptSendToEndpoints = new ArrayList<InterceptSendToEndpointDefinition>();
171        @XmlElement(name = "route", required = false)
172        private List<RouteDefinition> routes = new ArrayList<RouteDefinition>();
173        @XmlTransient
174        private SpringCamelContext context;
175        @XmlTransient
176        private ClassLoader contextClassLoaderOnStart;
177        @XmlTransient
178        private ApplicationContext applicationContext;
179        @XmlTransient
180        private BeanPostProcessor beanPostProcessor;
181        @XmlTransient
182        private boolean implicitId;
183        
184    
185        @Override
186        public Class<SpringCamelContext> getObjectType() {
187            return SpringCamelContext.class;
188        }
189        
190        protected <S> S getBeanForType(Class<S> clazz) {
191            S bean = null;
192            String[] names = getApplicationContext().getBeanNamesForType(clazz, true, true);
193            if (names.length == 1) {
194                bean = getApplicationContext().getBean(names[0], clazz);
195            }
196            if (bean == null) {
197                ApplicationContext parentContext = getApplicationContext().getParent();
198                if (parentContext != null) {
199                    names = parentContext.getBeanNamesForType(clazz, true, true);
200                    if (names.length == 1) {
201                        bean = parentContext.getBean(names[0], clazz);
202                    }
203                }
204            }
205            return bean;
206        }
207    
208        @Override
209        protected void findRouteBuildersByPackageScan(String[] packages, PackageScanFilter filter, List<RoutesBuilder> builders) throws Exception {
210            // add filter to class resolver which then will filter
211            getContext().getPackageScanClassResolver().addFilter(filter);
212    
213            PackageScanRouteBuilderFinder finder = new PackageScanRouteBuilderFinder(getContext(), packages, getContextClassLoaderOnStart(),
214                                                                                     getBeanPostProcessor(), getContext().getPackageScanClassResolver());
215            finder.appendBuilders(builders);
216    
217            // and remove the filter
218            getContext().getPackageScanClassResolver().removeFilter(filter);
219        }
220    
221        @Override
222        protected void findRouteBuildersByContextScan(PackageScanFilter filter, List<RoutesBuilder> builders) throws Exception {
223            ContextScanRouteBuilderFinder finder = new ContextScanRouteBuilderFinder(getContext(), filter);
224            finder.appendBuilders(builders);
225        }
226    
227        protected void initBeanPostProcessor(SpringCamelContext context) {
228            if (beanPostProcessor != null) {
229                if (beanPostProcessor instanceof ApplicationContextAware) {
230                    ((ApplicationContextAware) beanPostProcessor).setApplicationContext(applicationContext);
231                }
232                if (beanPostProcessor instanceof CamelBeanPostProcessor) {
233                    ((CamelBeanPostProcessor) beanPostProcessor).setCamelContext(getContext());
234                }
235            }
236        }
237    
238        protected void postProcessBeforeInit(RouteBuilder builder) {
239            if (beanPostProcessor != null) {
240                // Inject the annotated resource
241                beanPostProcessor.postProcessBeforeInitialization(builder, builder.toString());
242            }
243        }
244    
245        @Override
246        public void afterPropertiesSet() throws Exception {
247            super.afterPropertiesSet();
248    
249            Boolean shutdownEager = CamelContextHelper.parseBoolean(getContext(), getShutdownEager());
250            if (shutdownEager != null) {
251                LOG.debug("Using shutdownEager: " + shutdownEager);
252                getContext().setShutdownEager(shutdownEager);
253            }
254        }
255    
256        protected void initCustomRegistry(SpringCamelContext context) {
257            Registry registry = getBeanForType(Registry.class);
258            if (registry != null) {
259                LOG.info("Using custom Registry: " + registry);
260                context.setRegistry(registry);
261            }
262        }
263    
264        @Override
265        protected void initPropertyPlaceholder() throws Exception {
266            super.initPropertyPlaceholder();
267    
268            Map<String, BridgePropertyPlaceholderConfigurer> beans = applicationContext.getBeansOfType(BridgePropertyPlaceholderConfigurer.class);
269            if (beans.size() == 1) {
270                // setup properties component that uses this beans
271                BridgePropertyPlaceholderConfigurer configurer = beans.values().iterator().next();
272                String id = beans.keySet().iterator().next();
273                LOG.info("Bridging Camel and Spring property placeholder configurer with id: " + id);
274    
275                // get properties component
276                PropertiesComponent pc = getContext().getComponent("properties", PropertiesComponent.class);
277                // replace existing resolver with us
278                configurer.setResolver(pc.getPropertiesResolver());
279                configurer.setParser(pc.getPropertiesParser());
280                String ref = "ref:" + id;
281                // use the bridge to handle the resolve and parsing
282                pc.setPropertiesResolver(configurer);
283                pc.setPropertiesParser(configurer);
284                // and update locations to have our as ref first
285                String[] locations = pc.getLocations();
286                String[] updatedLocations;
287                if (locations != null && locations.length > 0) {
288                    updatedLocations = new String[locations.length + 1];
289                    updatedLocations[0] = ref;
290                    System.arraycopy(locations, 0, updatedLocations, 1, locations.length);
291                } else {
292                    updatedLocations = new String[]{ref};
293                }
294                pc.setLocations(updatedLocations);
295            } else if (beans.size() > 1) {
296                LOG.warn("Cannot bridge Camel and Spring property placeholders, as exact only 1 bean of type BridgePropertyPlaceholderConfigurer"
297                        + " must be defined, was {} beans defined.", beans.size());
298            }
299        }
300    
301        public void onApplicationEvent(ApplicationEvent event) {
302            // From Spring 3.0.1, The BeanFactory applicationEventListener 
303            // and Bean's applicationEventListener will be called,
304            // So we just delegate the onApplicationEvent call here.
305    
306            SpringCamelContext context = getContext(false);
307            if (context != null) {
308                // we need to defer setting up routes until Spring has done all its dependency injection
309                // which is only guaranteed to be done when it emits the ContextRefreshedEvent event.
310                if (event instanceof ContextRefreshedEvent) {
311                    try {
312                        setupRoutes();
313                    } catch (Exception e) {
314                        throw wrapRuntimeCamelException(e);
315                    }
316                }
317                // let the spring camel context handle the events
318                context.onApplicationEvent(event);
319            } else {
320                LOG.debug("Publishing spring-event: {}", event);
321    
322                if (event instanceof ContextRefreshedEvent) {
323                    // now lets start the CamelContext so that all its possible
324                    // dependencies are initialized
325                    try {
326                        // we need to defer setting up routes until Spring has done all its dependency injection
327                        // which is only guaranteed to be done when it emits the ContextRefreshedEvent event.
328                        setupRoutes();
329                        LOG.trace("Starting the context now");
330                        getContext().start();
331                    } catch (Exception e) {
332                        throw wrapRuntimeCamelException(e);
333                    }
334                }
335            }
336        }
337    
338        // Properties
339        // -------------------------------------------------------------------------
340    
341        public ApplicationContext getApplicationContext() {
342            if (applicationContext == null) {
343                throw new IllegalArgumentException("No applicationContext has been injected!");
344            }
345            return applicationContext;
346        }
347    
348        public void setApplicationContext(ApplicationContext applicationContext) {
349            this.applicationContext = applicationContext;
350        }
351    
352        public void setBeanPostProcessor(BeanPostProcessor postProcessor) {
353            this.beanPostProcessor = postProcessor;
354        }
355    
356        public BeanPostProcessor getBeanPostProcessor() {
357            return beanPostProcessor;
358        }
359    
360        // Implementation methods
361        // -------------------------------------------------------------------------
362    
363        /**
364         * Create the context
365         */
366        protected SpringCamelContext createContext() {
367            SpringCamelContext ctx = newCamelContext();        
368            ctx.setName(getId());        
369            return ctx;
370        }
371    
372        protected SpringCamelContext newCamelContext() {
373            return new SpringCamelContext(getApplicationContext());
374        }
375    
376        public SpringCamelContext getContext(boolean create) {
377            if (context == null && create) {
378                context = createContext();
379            }
380            return context;
381        }
382    
383        public void setContext(SpringCamelContext context) {
384            this.context = context;
385        }
386    
387        public List<RouteDefinition> getRoutes() {
388            return routes;
389        }
390    
391        public void setRoutes(List<RouteDefinition> routes) {
392            this.routes = routes;
393        }
394    
395        public List<CamelEndpointFactoryBean> getEndpoints() {
396            return endpoints;
397        }
398    
399        public List<CamelRedeliveryPolicyFactoryBean> getRedeliveryPolicies() {
400            return redeliveryPolicies;
401        }
402    
403        public List<InterceptDefinition> getIntercepts() {
404            return intercepts;
405        }
406    
407        public void setIntercepts(List<InterceptDefinition> intercepts) {
408            this.intercepts = intercepts;
409        }
410    
411        public List<InterceptFromDefinition> getInterceptFroms() {
412            return interceptFroms;
413        }
414    
415        public void setInterceptFroms(List<InterceptFromDefinition> interceptFroms) {
416            this.interceptFroms = interceptFroms;
417        }
418    
419        public List<InterceptSendToEndpointDefinition> getInterceptSendToEndpoints() {
420            return interceptSendToEndpoints;
421        }
422    
423        public void setInterceptSendToEndpoints(List<InterceptSendToEndpointDefinition> interceptSendToEndpoints) {
424            this.interceptSendToEndpoints = interceptSendToEndpoints;
425        }
426    
427        public PropertiesDefinition getProperties() {
428            return properties;
429        }
430    
431        public void setProperties(PropertiesDefinition properties) {
432            this.properties = properties;
433        }
434    
435        public String[] getPackages() {
436            return packages;
437        }
438    
439        /**
440         * Sets the package names to be recursively searched for Java classes which
441         * extend {@link org.apache.camel.builder.RouteBuilder} to be auto-wired up to the
442         * {@link CamelContext} as a route. Note that classes are excluded if
443         * they are specifically configured in the spring.xml
444         * <p/>
445         * A more advanced configuration can be done using {@link #setPackageScan(org.apache.camel.model.PackageScanDefinition)}
446         *
447         * @param packages the package names which are recursively searched
448         * @see #setPackageScan(org.apache.camel.model.PackageScanDefinition)
449         */
450        public void setPackages(String[] packages) {
451            this.packages = packages;
452        }
453    
454        public PackageScanDefinition getPackageScan() {
455            return packageScan;
456        }
457    
458        /**
459         * Sets the package scanning information. Package scanning allows for the
460         * automatic discovery of certain camel classes at runtime for inclusion
461         * e.g. {@link org.apache.camel.builder.RouteBuilder} implementations
462         *
463         * @param packageScan the package scan
464         */
465        public void setPackageScan(PackageScanDefinition packageScan) {
466            this.packageScan = packageScan;
467        }
468    
469        public ContextScanDefinition getContextScan() {
470            return contextScan;
471        }
472    
473        /**
474         * Sets the context scanning (eg Spring's ApplicationContext) information.
475         * Context scanning allows for the automatic discovery of Camel routes runtime for inclusion
476         * e.g. {@link org.apache.camel.builder.RouteBuilder} implementations
477         *
478         * @param contextScan the context scan
479         */
480        public void setContextScan(ContextScanDefinition contextScan) {
481            this.contextScan = contextScan;
482        }
483    
484        public CamelPropertyPlaceholderDefinition getCamelPropertyPlaceholder() {
485            return camelPropertyPlaceholder;
486        }
487    
488        public void setCamelPropertyPlaceholder(CamelPropertyPlaceholderDefinition camelPropertyPlaceholder) {
489            this.camelPropertyPlaceholder = camelPropertyPlaceholder;
490        }
491    
492        public CamelStreamCachingStrategyDefinition getCamelStreamCachingStrategy() {
493            return camelStreamCachingStrategy;
494        }
495    
496        public void setCamelStreamCachingStrategy(CamelStreamCachingStrategyDefinition camelStreamCachingStrategy) {
497            this.camelStreamCachingStrategy = camelStreamCachingStrategy;
498        }
499    
500        public void setCamelJMXAgent(CamelJMXAgentDefinition agent) {
501            camelJMXAgent = agent;
502        }
503    
504        public String getTrace() {
505            return trace;
506        }
507    
508        public void setTrace(String trace) {
509            this.trace = trace;
510        }
511    
512        public String getMessageHistory() {
513            return messageHistory;
514        }
515    
516        public void setMessageHistory(String messageHistory) {
517            this.messageHistory = messageHistory;
518        }
519    
520        public String getStreamCache() {
521            return streamCache;
522        }
523    
524        public void setStreamCache(String streamCache) {
525            this.streamCache = streamCache;
526        }
527    
528        public String getDelayer() {
529            return delayer;
530        }
531    
532        public void setDelayer(String delayer) {
533            this.delayer = delayer;
534        }
535    
536        public String getHandleFault() {
537            return handleFault;
538        }
539    
540        public void setHandleFault(String handleFault) {
541            this.handleFault = handleFault;
542        }
543    
544        public String getAutoStartup() {
545            return autoStartup;
546        }
547    
548        public void setAutoStartup(String autoStartup) {
549            this.autoStartup = autoStartup;
550        }
551    
552        public String getShutdownEager() {
553            return shutdownEager;
554        }
555    
556        public void setShutdownEager(String shutdownEager) {
557            this.shutdownEager = shutdownEager;
558        }
559    
560        public String getUseMDCLogging() {
561            return useMDCLogging;
562        }
563    
564        public void setUseMDCLogging(String useMDCLogging) {
565            this.useMDCLogging = useMDCLogging;
566        }
567    
568        public String getUseBreadcrumb() {
569            return useBreadcrumb;
570        }
571    
572        public void setUseBreadcrumb(String useBreadcrumb) {
573            this.useBreadcrumb = useBreadcrumb;
574        }
575    
576        public String getAllowUseOriginalMessage() {
577            return allowUseOriginalMessage;
578        }
579    
580        public void setAllowUseOriginalMessage(String allowUseOriginalMessage) {
581            this.allowUseOriginalMessage = allowUseOriginalMessage;
582        }
583    
584        public String getRuntimeEndpointRegistryEnabled() {
585            return runtimeEndpointRegistryEnabled;
586        }
587    
588        public void setRuntimeEndpointRegistryEnabled(String runtimeEndpointRegistryEnabled) {
589            this.runtimeEndpointRegistryEnabled = runtimeEndpointRegistryEnabled;
590        }
591    
592        public String getManagementNamePattern() {
593            return managementNamePattern;
594        }
595    
596        public void setManagementNamePattern(String managementNamePattern) {
597            this.managementNamePattern = managementNamePattern;
598        }
599    
600        public String getThreadNamePattern() {
601            return threadNamePattern;
602        }
603    
604        public void setThreadNamePattern(String threadNamePattern) {
605            this.threadNamePattern = threadNamePattern;
606        }
607    
608        @Deprecated
609        public Boolean getLazyLoadTypeConverters() {
610            return lazyLoadTypeConverters;
611        }
612    
613        @Deprecated
614        public void setLazyLoadTypeConverters(Boolean lazyLoadTypeConverters) {
615            this.lazyLoadTypeConverters = lazyLoadTypeConverters;
616        }
617    
618        public Boolean getTypeConverterStatisticsEnabled() {
619            return typeConverterStatisticsEnabled;
620        }
621    
622        public void setTypeConverterStatisticsEnabled(Boolean typeConverterStatisticsEnabled) {
623            this.typeConverterStatisticsEnabled = typeConverterStatisticsEnabled;
624        }
625    
626        public CamelJMXAgentDefinition getCamelJMXAgent() {
627            return camelJMXAgent;
628        }
629    
630        public List<RouteBuilderDefinition> getBuilderRefs() {
631            return builderRefs;
632        }
633    
634        public void setBuilderRefs(List<RouteBuilderDefinition> builderRefs) {
635            this.builderRefs = builderRefs;
636        }
637    
638        public List<RouteContextRefDefinition> getRouteRefs() {
639            return routeRefs;
640        }
641    
642        public void setRouteRefs(List<RouteContextRefDefinition> routeRefs) {
643            this.routeRefs = routeRefs;
644        }
645    
646        public String getErrorHandlerRef() {
647            return errorHandlerRef;
648        }
649    
650        /**
651         * Sets the name of the error handler object used to default the error handling strategy
652         *
653         * @param errorHandlerRef the Spring bean ref of the error handler
654         */
655        public void setErrorHandlerRef(String errorHandlerRef) {
656            this.errorHandlerRef = errorHandlerRef;
657        }
658    
659        public void setDataFormats(DataFormatsDefinition dataFormats) {
660            this.dataFormats = dataFormats;
661        }
662    
663        public DataFormatsDefinition getDataFormats() {
664            return dataFormats;
665        }
666    
667        public void setOnExceptions(List<OnExceptionDefinition> onExceptions) {
668            this.onExceptions = onExceptions;
669        }
670    
671        public List<OnExceptionDefinition> getOnExceptions() {
672            return onExceptions;
673        }
674    
675        public List<OnCompletionDefinition> getOnCompletions() {
676            return onCompletions;
677        }
678    
679        public void setOnCompletions(List<OnCompletionDefinition> onCompletions) {
680            this.onCompletions = onCompletions;
681        }
682    
683        public ShutdownRoute getShutdownRoute() {
684            return shutdownRoute;
685        }
686    
687        public void setShutdownRoute(ShutdownRoute shutdownRoute) {
688            this.shutdownRoute = shutdownRoute;
689        }
690    
691        public ShutdownRunningTask getShutdownRunningTask() {
692            return shutdownRunningTask;
693        }
694    
695        public void setShutdownRunningTask(ShutdownRunningTask shutdownRunningTask) {
696            this.shutdownRunningTask = shutdownRunningTask;
697        }
698    
699        public List<ThreadPoolProfileDefinition> getThreadPoolProfiles() {
700            return threadPoolProfiles;
701        }
702    
703        public void setThreadPoolProfiles(List<ThreadPoolProfileDefinition> threadPoolProfiles) {
704            this.threadPoolProfiles = threadPoolProfiles;
705        }
706    
707        public String getDependsOn() {
708            return dependsOn;
709        }
710    
711        public void setDependsOn(String dependsOn) {
712            this.dependsOn = dependsOn;
713        }
714        
715        public boolean isImplicitId() {
716            return implicitId;
717        }
718        
719        public void setImplicitId(boolean flag) {
720            implicitId = flag;
721        }
722    
723    }