DefaultCamelContext (Camel :: Core 2.23.0 API)

java.lang.Object
- org.apache.camel.support.ServiceSupport
- - org.apache.camel.impl.DefaultCamelContext

All Implemented Interfaces:

CamelContext, ModelCamelContext, RuntimeConfiguration, Service, ShutdownableService, StatefulService, Suspendable, SuspendableService
```
public class DefaultCamelContext
extends ServiceSupport
implements ModelCamelContext, Suspendable
```
Represents the context used to configure routes and the policies to use.

Version:

Field Summary
- Fields inherited from class org.apache.camel.support.ServiceSupport
  shutdown, shuttingdown, started, starting, stopped, stopping, suspended, suspending

Constructor Summary

Constructors
Constructor and Description
`DefaultCamelContext()` Creates the `CamelContext` using `JndiRegistry` as registry, but will silently fallback and use `SimpleRegistry` if JNDI cannot be used.
`DefaultCamelContext(Context jndiContext)` Creates the `CamelContext` using the given JNDI context as the registry
`DefaultCamelContext(Registry registry)` Creates the `CamelContext` using the given registry

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`<T extends CamelContext> T`	`adapt(Class<T> type)` Adapts this `CamelContext` to the specialized type.
`void`	`addComponent(String componentName, Component component)` Adds a component to the context.
`Endpoint`	`addEndpoint(String uri, Endpoint endpoint)` Adds the endpoint to the `EndpointRegistry` using the given URI.
`protected Endpoint`	`addEndpointToRegistry(String uri, Endpoint endpoint)` Strategy to add the given endpoint to the internal endpoint registry
`void`	`addHystrixConfiguration(String id, HystrixConfigurationDefinition configuration)` Adds the Hystrix configuration
`void`	`addInterceptStrategy(InterceptStrategy interceptStrategy)` Adds the given interceptor strategy
`void`	`addLifecycleStrategy(LifecycleStrategy lifecycleStrategy)` Adds the given lifecycle strategy to be used.
`void`	`addLogListener(LogListener listener)` Adds a `LogListener`.
`void`	`addRegisterEndpointCallback(EndpointStrategy strategy)` Registers a `callback` to allow you to do custom logic when an `Endpoint` is about to be registered to the `EndpointRegistry`.
`void`	`addRestConfiguration(RestConfiguration restConfiguration)` Sets a custom `RestConfiguration`
`void`	`addRestDefinitions(Collection<RestDefinition> restDefinitions)` Adds a collection of rest definitions to the context
`void`	`addRouteDefinition(RouteDefinition routeDefinition)` Add a route definition to the context Important: Each route in the same `CamelContext` must have an unique route id.
`void`	`addRouteDefinitions(Collection<RouteDefinition> routeDefinitions)` Adds a collection of route definitions to the context Important: Each route in the same `CamelContext` must have an unique route id.
`void`	`addRoutePolicyFactory(RoutePolicyFactory routePolicyFactory)` Adds the given route policy factory
`void`	`addRoutes(RoutesBuilder builder)` Adds a collection of routes to this CamelContext using the given builder to build them.
`void`	`addService(Object object)` Adds a service to this CamelContext, which allows this CamelContext to control the lifecycle, ensuring the service is stopped when the CamelContext stops.
`void`	`addService(Object object, boolean stopOnShutdown)` Adds a service to this CamelContext.
`void`	`addService(Object object, boolean stopOnShutdown, boolean forceStart)` Adds a service to this CamelContext.
`void`	`addServiceCallConfiguration(String serviceName, ServiceCallConfigurationDefinition configuration)` Adds the service call configuration
`void`	`addStartupListener(StartupListener listener)` Adds the given listener to be invoked when `CamelContext` have just been started.
`protected Endpoint`	`convertBeanToEndpoint(String uri, Object bean)` Strategy method for attempting to convert the bean from a `Registry` to an endpoint using some kind of transformation or wrapper
`protected AsyncProcessorAwaitManager`	`createAsyncProcessorAwaitManager()`
`protected CamelContextNameStrategy`	`createCamelContextNameStrategy()`
`protected ClassResolver`	`createClassResolver()`
`protected ComponentResolver`	`createComponentResolver()` Lazily create a default implementation
`ConsumerTemplate`	`createConsumerTemplate()` Creates a new `ConsumerTemplate` which is started and therefore ready to use right away.
`ConsumerTemplate`	`createConsumerTemplate(int maximumCacheSize)` Creates a new `ConsumerTemplate` which is started and therefore ready to use right away.
`DataFormat`	`createDataFormat(String name)` Creates the given data format given its name.
`protected DataFormatResolver`	`createDataFormatResolver()`
`protected UuidGenerator`	`createDefaultUuidGenerator()`
`protected Endpoint`	`createEndpoint(String uri)` A pluggable strategy to allow an endpoint to be created without requiring a component to be its factory, such as for looking up the URI inside some `Registry`
`protected EndpointRegistry<EndpointKey>`	`createEndpointRegistry(Map<EndpointKey,Endpoint> endpoints)`
`protected ExecutorServiceManager`	`createExecutorServiceManager()`
`protected FactoryFinderResolver`	`createFactoryFinderResolver()`
`FluentProducerTemplate`	`createFluentProducerTemplate()` Creates a new `FluentProducerTemplate` which is started and therefore ready to use right away.
`FluentProducerTemplate`	`createFluentProducerTemplate(int maximumCacheSize)` Creates a new `FluentProducerTemplate` which is started and therefore ready to use right away.
`protected HeadersMapFactory`	`createHeadersMapFactory()`
`protected HealthCheckRegistry`	`createHealthCheckRegistry()`
`protected InflightRepository`	`createInflightRepository()`
`protected Injector`	`createInjector()` Lazily create a default implementation
`protected LanguageResolver`	`createLanguageResolver()`
`protected ManagementMBeanAssembler`	`createManagementMBeanAssembler()` Lazily create a default implementation
`protected ManagementNameStrategy`	`createManagementNameStrategy()`
`protected ManagementStrategy`	`createManagementStrategy()`
`protected MessageHistoryFactory`	`createMessageHistoryFactory()`
`protected ModelJAXBContextFactory`	`createModelJAXBContextFactory()`
`protected NodeIdFactory`	`createNodeIdFactory()`
`protected PackageScanClassResolver`	`createPackageScanClassResolver()`
`protected ServicePool<Endpoint,PollingConsumer>`	`createPollingConsumerServicePool()`
`protected ProcessorFactory`	`createProcessorFactory()`
`protected ServicePool<Endpoint,Producer>`	`createProducerServicePool()`
`ProducerTemplate`	`createProducerTemplate()` Creates a new `ProducerTemplate` which is started and therefore ready to use right away.
`ProducerTemplate`	`createProducerTemplate(int maximumCacheSize)` Creates a new `ProducerTemplate` which is started and therefore ready to use right away.
`protected Registry`	`createRegistry()` Lazily create a default implementation
`protected RouteController`	`createRouteController()`
`String`	`createRouteStaticEndpointJson(String routeId)` Creates a JSON representation of all the static and dynamic configured endpoints defined in the given route(s).
`String`	`createRouteStaticEndpointJson(String routeId, boolean includeDynamic)` Creates a JSON representation of all the static (and possible dynamic) configured endpoints defined in the given route(s).
`protected RuntimeCamelCatalog`	`createRuntimeCamelCatalog()`
`protected ShutdownStrategy`	`createShutdownStrategy()`
`protected TransformerRegistry<TransformerKey>`	`createTransformerRegistry(List<TransformerDefinition> transformers)`
`protected TypeConverter`	`createTypeConverter()` Lazily create a default implementation
`protected UnitOfWorkFactory`	`createUnitOfWorkFactory()`
`protected ValidatorRegistry<ValidatorKey>`	`createValidatorRegistry(List<ValidatorDefinition> validators)`
`void`	`deferStartService(Object object, boolean stopOnShutdown)` Defers starting the service until `CamelContext` is (almost started) or started and has initialized all its prior services and routes.
`void`	`disableJMX()` Disables using JMX as `ManagementStrategy`.
`protected void`	`doResume()` Implementations override this method to support customized suspend/resume.
`protected void`	`doStart()` Implementations override this method to support customized start/stop.
`protected void`	`doStartCamel()`
`protected void`	`doStartOrResumeRoutes(Map<String,RouteService> routeServices, boolean checkClash, boolean startConsumer, boolean resumeConsumer, boolean addingRoutes)` Starts or resumes the routes
`protected void`	`doStop()` Implementations override this method to support customized start/stop.
`protected void`	`doSuspend()` Implementations override this method to support customized suspend/resume.
`String`	`explainComponentJson(String componentName, boolean includeAllOptions)` Returns a JSON schema representation of the component parameters (not endpoint parameters) for the given component by its id.
`String`	`explainDataFormatJson(String dataFormatName, DataFormat dataFormat, boolean includeAllOptions)` Returns a JSON schema representation of the component parameters (not endpoint parameters) for the given component by its id.
`String`	`explainEipJson(String nameOrId, boolean includeAllOptions)` Returns a JSON schema representation of the EIP parameters for the given EIP by its id.
`String`	`explainEndpointJson(String uri, boolean includeAllOptions)` Returns a JSON schema representation of the endpoint parameters for the given endpoint uri.
`Map<String,Properties>`	`findComponents()` Find information about all the Camel components available in the classpath and `Registry`.
`Map<String,Properties>`	`findEips()` Find information about all the EIPs from camel-core.
`protected void`	`forceLazyInitialization()` Force some lazy initialization to occur upfront before we start any components and create routes
`protected void`	`forceStopLazyInitialization()` Force clear lazy initialization so they can be re-created on restart
`ClassLoader`	`getApplicationContextClassLoader()` Gets the application CamelContext class loader which may be helpful for running camel in other containers
`AsyncProcessorAwaitManager`	`getAsyncProcessorAwaitManager()` Gets the `AsyncProcessor` await manager.
`ClassResolver`	`getClassResolver()` Returns the class resolver to be used for loading/lookup of classes.
`Component`	`getComponent(String name)` Gets a component from the CamelContext by name.
`Component`	`getComponent(String name, boolean autoCreateComponents)` Gets a component from the CamelContext by name.
`Component`	`getComponent(String name, boolean autoCreateComponents, boolean autoStart)` Gets a component from the CamelContext by name.
`<T extends Component> T`	`getComponent(String name, Class<T> componentType)` Gets a component from the CamelContext by name and specifying the expected type of component.
`String`	`getComponentDocumentation(String componentName)` Returns the HTML documentation for the given Camel component
`List<String>`	`getComponentNames()` Gets a readonly list of names of the components currently registered
`String`	`getComponentParameterJsonSchema(String componentName)` Returns the JSON schema representation of the component and endpoint parameters for the given component name.
`ComponentResolver`	`getComponentResolver()`
`String`	`getDataFormatParameterJsonSchema(String dataFormatName)` Returns the JSON schema representation of the `DataFormat` parameters for the given data format name.
`DataFormatResolver`	`getDataFormatResolver()` Gets the current data format resolver
`Map<String,DataFormatDefinition>`	`getDataFormats()` Gets the data formats that can be referenced in the routes.
`Debugger`	`getDebugger()` Gets the current `Debugger`
`InterceptStrategy`	`getDefaultBacklogDebugger()` Gets the default backlog debugger
`InterceptStrategy`	`getDefaultBacklogTracer()` Gets the default backlog tracer
`FactoryFinder`	`getDefaultFactoryFinder()` Gets the default FactoryFinder which will be used for the loading the factory class from META-INF
`InterceptStrategy`	`getDefaultTracer()` Gets the default tracer
`Long`	`getDelayer()` Gets the delay value
`String`	`getEipParameterJsonSchema(String eipName)` Returns the JSON schema representation of the EIP parameters for the given EIP name.
`Endpoint`	`getEndpoint(String uri)` Resolves the given name to an `Endpoint` of the specified type.
`<T extends Endpoint> T`	`getEndpoint(String name, Class<T> endpointType)` Resolves the given name to an `Endpoint` of the specified type.
`protected EndpointKey`	`getEndpointKey(String uri)` Gets the endpoint key to use for lookup or whe adding endpoints to the `DefaultEndpointRegistry`
`protected EndpointKey`	`getEndpointKey(String uri, Endpoint endpoint)` Gets the endpoint key to use for lookup or whe adding endpoints to the `DefaultEndpointRegistry`
`protected EndpointKey`	`getEndpointKeyPreNormalized(String uri)` Gets the endpoint key to use for lookup or whe adding endpoints to the `DefaultEndpointRegistry`
`Map<String,Endpoint>`	`getEndpointMap()` Returns a new `Map` containing all of the endpoints from the `EndpointRegistry`
`EndpointRegistry<EndpointKey>`	`getEndpointRegistry()` Gets the `EndpointRegistry`
`Collection<Endpoint>`	`getEndpoints()` Returns a new `Collection` of all of the endpoints from the `EndpointRegistry`
`ErrorHandlerBuilder`	`getErrorHandlerBuilder()` Gets the default error handler builder which is inherited by the routes
`ScheduledExecutorService`	`getErrorHandlerExecutorService()` Gets the default shared thread pool for error handlers which leverages this for asynchronous redelivery tasks.
`ExecutorServiceManager`	`getExecutorServiceManager()` Gets the current `ExecutorServiceManager`
`ExecutorServiceStrategy`	`getExecutorServiceStrategy()` Deprecated.
`FactoryFinder`	`getFactoryFinder(String path)` Gets the FactoryFinder which will be used for the loading the factory class from META-INF in the given path
`FactoryFinderResolver`	`getFactoryFinderResolver()`
`String`	`getGlobalOption(String key)` Gets the global option value that can be referenced in the camel context Important: This has nothing to do with property placeholders, and is just a plain set of key/value pairs which are used to configure global options on CamelContext, such as a maximum debug logging length etc.
`Map<String,String>`	`getGlobalOptions()` Gets global options that can be referenced in the camel context.
`HeadersMapFactory`	`getHeadersMapFactory()` Gets the `HeadersMapFactory` to use.
`HealthCheckRegistry`	`getHealthCheckRegistry()` Returns an optional `HealthCheckRegistry`, by default no registry is present and it must be explicit activated.
`HystrixConfigurationDefinition`	`getHystrixConfiguration(String id)` Gets the Hystrix configuration by the given name.
`InflightRepository`	`getInflightRepository()` Gets the inflight repository
`Injector`	`getInjector()` Returns the injector used to instantiate objects by type
`List<InterceptStrategy>`	`getInterceptStrategies()` Gets the interceptor strategies
`List<String>`	`getLanguageNames()` Gets a readonly list with the names of the languages currently registered.
`String`	`getLanguageParameterJsonSchema(String languageName)` Returns the JSON schema representation of the `Language` parameters for the given language name.
`LanguageResolver`	`getLanguageResolver()`
`List<LifecycleStrategy>`	`getLifecycleStrategies()` Returns the lifecycle strategies used to handle lifecycle notifications
`Set<LogListener>`	`getLogListeners()` Gets a list of `LogListener`.
`ManagedCamelContextMBean`	`getManagedCamelContext()` Gets the managed Camel CamelContext client api
`<T extends ManagedProcessorMBean> T`	`getManagedProcessor(String id, Class<T> type)` Gets the managed processor client api from any of the routes which with the given id
`<T extends ManagedRouteMBean> T`	`getManagedRoute(String routeId, Class<T> type)` Gets the managed route client api with the given route id
`ManagementMBeanAssembler`	`getManagementMBeanAssembler()` Returns the management mbean assembler
`String`	`getManagementName()` Gets the name this `CamelContext` was registered in JMX.
`ManagementNameStrategy`	`getManagementNameStrategy()` Gets the current management name strategy
`ManagementStrategy`	`getManagementStrategy()` Gets the management strategy
`MessageHistoryFactory`	`getMessageHistoryFactory()` Gets the current `MessageHistoryFactory`
`ModelJAXBContextFactory`	`getModelJAXBContextFactory()` Returns the JAXB Context factory used to create Models.
`String`	`getName()` Gets the name (id) of the this CamelContext.
`CamelContextNameStrategy`	`getNameStrategy()` Gets the current name strategy
`NodeIdFactory`	`getNodeIdFactory()` Gets the node id factory
`PackageScanClassResolver`	`getPackageScanClassResolver()` Returns the package scanning class resolver
`ServicePool<Endpoint,PollingConsumer>`	`getPollingConsumerServicePool()` Gets the service pool for `Producer` pooling.
`Processor`	`getProcessor(String id)` Gets the processor from any of the routes which with the given id
`<T extends Processor> T`	`getProcessor(String id, Class<T> type)` Gets the processor from any of the routes which with the given id
`ProcessorDefinition`	`getProcessorDefinition(String id)` Gets the processor definition from any of the routes which with the given id
`<T extends ProcessorDefinition> T`	`getProcessorDefinition(String id, Class<T> type)` Gets the processor definition from any of the routes which with the given id
`ProcessorFactory`	`getProcessorFactory()` Gets the current `ProcessorFactory`
`ServicePool<Endpoint,Producer>`	`getProducerServicePool()` Gets the service pool for `Producer` pooling.
`Map<String,String>`	`getProperties()` Deprecated.
`protected PropertiesComponent`	`getPropertiesComponent()` Gets the properties component in use.
`String`	`getProperty(String key)` Deprecated.
`String`	`getPropertyPrefixToken()` Returns the configured property placeholder prefix token if and only if the CamelContext has property placeholder abilities, otherwise returns `null`.
`String`	`getPropertySuffixToken()` Returns the configured property placeholder suffix token if and only if the CamelContext has property placeholder abilities, otherwise returns `null`.
`Registry`	`getRegistry()` Returns the registry used to lookup components by name and type such as the Spring ApplicationContext, JNDI or the OSGi Service Registry
`<T> T`	`getRegistry(Class<T> type)` Returns the registry used to lookup components by name and as the given type
`ReloadStrategy`	`getReloadStrategy()` Returns the `ReloadStrategy` if in use.
`RestConfiguration`	`getRestConfiguration()` Gets the default REST configuration
`RestConfiguration`	`getRestConfiguration(String component, boolean defaultIfNotExist)` Gets the REST configuration for the given component
`Collection<RestConfiguration>`	`getRestConfigurations()` Gets all the RestConfiguration's
`List<RestDefinition>`	`getRestDefinitions()` Returns a list of the current REST definitions
`RestRegistry`	`getRestRegistry()` Gets the `RestRegistry` to use
`Route`	`getRoute(String id)` Gets the route with the given id
`RouteController`	`getRouteController()` NOTE: experimental api
`RouteDefinition`	`getRouteDefinition(String id)` Gets the route definition with the given id
`List<RouteDefinition>`	`getRouteDefinitions()` Returns a list of the current route definitions
`List<RoutePolicyFactory>`	`getRoutePolicyFactories()` Gets the route policy factories
`List<Route>`	`getRoutes()` Returns the current routes in this CamelContext
`protected Map<String,RouteService>`	`getRouteServices()`
`List<RouteStartupOrder>`	`getRouteStartupOrder()` Returns the order in which the route inputs was started.
`ServiceStatus`	`getRouteStatus(String key)` Returns the current status of the given route
`RuntimeCamelCatalog`	`getRuntimeCamelCatalog()` Gets the associated `RuntimeCamelCatalog` for this CamelContext.
`RuntimeEndpointRegistry`	`getRuntimeEndpointRegistry()` Gets the `RuntimeEndpointRegistry` to use, or `null` if none is in use.
`ServiceCallConfigurationDefinition`	`getServiceCallConfiguration(String serviceName)` Gets the service call configuration by the given name.
`ShutdownRoute`	`getShutdownRoute()` Gets the option to use when shutting down the route.
`ShutdownRunningTask`	`getShutdownRunningTask()` Gets the ShutdownRunningTask option in use when shutting down a route.
`ShutdownStrategy`	`getShutdownStrategy()` Gets the current shutdown strategy
`SSLContextParameters`	`getSSLContextParameters()` Gets the global SSL context parameters if configured.
`StreamCachingStrategy`	`getStreamCachingStrategy()` Gets the `StreamCachingStrategy` to use.
`TransformerRegistry<TransformerKey>`	`getTransformerRegistry()` Gets the `TransformerRegistry`
`List<TransformerDefinition>`	`getTransformers()` Gets the transformers that can be referenced in the routes.
`TypeConverter`	`getTypeConverter()` Returns the type converter used to coerce types from one type to another
`TypeConverterRegistry`	`getTypeConverterRegistry()` Returns the type converter registry where type converters can be added or looked up
`UnitOfWorkFactory`	`getUnitOfWorkFactory()` Gets the `UnitOfWorkFactory` to use.
`String`	`getUptime()` Gets the uptime in a human readable format
`long`	`getUptimeMillis()` Gets the uptime in milli seconds
`UuidGenerator`	`getUuidGenerator()` Gets the current `UuidGenerator`
`ValidatorRegistry<ValidatorKey>`	`getValidatorRegistry()` Gets the `ValidatorRegistry`
`List<ValidatorDefinition>`	`getValidators()` Gets the validators that can be referenced in the routes.
`Component`	`hasComponent(String componentName)` Is the given component already registered?
`Endpoint`	`hasEndpoint(String uri)` Is the given endpoint already registered in the `EndpointRegistry`
`<T> T`	`hasService(Class<T> type)` Has the given service type already been added to this CamelContext?
`boolean`	`hasService(Object object)` Has the given service already been added to this CamelContext?
`<T> Set<T>`	`hasServices(Class<T> type)` Has the given service type already been added to this CamelContext?
`Boolean`	`isAllowUseOriginalMessage()` Gets whether access to the original message from Camel's error handler, or from `UnitOfWork.getOriginalInMessage()` is allowed.
`boolean`	`isAutoCreateComponents()`
`Boolean`	`isAutoStartup()` Gets whether the object should automatically start when Camel starts.
`Boolean`	`isHandleFault()` Returns whether fault handling enabled
`Boolean`	`isLazyLoadTypeConverters()` Deprecated.
`Boolean`	`isLoadTypeConverters()` Sets whether to load custom type converters by scanning classpath.
`Boolean`	`isLogExhaustedMessageBody()` Returns whether to log exhausted message body with message history.
`Boolean`	`isLogMask()` Gets whether security mask for Logging is enabled or not.
`Boolean`	`isMessageHistory()` Returns whether message history is enabled
`boolean`	`isSetupRoutes()` Indicates whether current thread is setting up route(s) as part of starting Camel from spring/blueprint.
`boolean`	`isStartingRoutes()` Indicates whether current thread is starting route(s).
`Boolean`	`isStreamCaching()` Returns whether stream cache is enabled
`Boolean`	`isTracing()` Returns whether tracing enabled
`Boolean`	`isTypeConverterStatisticsEnabled()` Whether or not type converter statistics is enabled.
`Boolean`	`isUseBreadcrumb()` Whether or not breadcrumb is enabled.
`Boolean`	`isUseDataType()` Whether to enable using data type on Camel messages.
`Boolean`	`isUseMDCLogging()` Whether or not MDC logging is being enabled.
`boolean`	`isVetoStarted()` If CamelContext during the start procedure was vetoed, and therefore causing Camel to not start.
`RestsDefinition`	`loadRestsDefinition(InputStream is)` Loads a collection of rest definitions from the given `InputStream`.
`RoutesDefinition`	`loadRoutesDefinition(InputStream is)` Loads a collection of route definitions from the given `InputStream`.
`protected void`	`logRouteState(Route route, String state)`
`protected Component`	`lookupPropertiesComponent()` Deprecated. use `CamelContextHelper.lookupPropertiesComponent(org.apache.camel.CamelContext, boolean)`
`protected static String`	`normalizeEndpointUri(String uri)` Normalize uri so we can do endpoint hits with minor mistakes and parameters is not in the same order.
`Component`	`removeComponent(String componentName)` Removes a previously added component.
`void`	`removeEndpoint(Endpoint endpoint)` Removes the endpoint from the `EndpointRegistry`.
`Collection<Endpoint>`	`removeEndpoints(String uri)` Removes all endpoints with the given URI from the `EndpointRegistry`.
`boolean`	`removeRoute(String routeId)` Removes the given route (the route must be stopped before it can be removed).
`void`	`removeRouteDefinition(RouteDefinition routeDefinition)` Removes a route definition from the context - stopping any previously running routes if any of them are actively running
`protected boolean`	`removeRouteDefinition(String key)` Removes the route definition with the given key.
`void`	`removeRouteDefinitions(Collection<RouteDefinition> routeDefinitions)` Removes a collection of route definitions from the context - stopping any previously running routes if any of them are actively running
`boolean`	`removeService(Object object)` Removes a service from this CamelContext.
`Component`	`resolveComponent(String name)`
`String`	`resolveComponentDefaultName(String javaType)` Resolves a component's default name from its java type.
`DataFormat`	`resolveDataFormat(String name)` Resolve a data format given its name
`DataFormatDefinition`	`resolveDataFormatDefinition(String name)` Resolve a data format definition given its name
`Language`	`resolveLanguage(String language)` Resolves a language for creating expressions
`String`	`resolvePropertyPlaceholders(String text)` Parses the given text and resolve any property placeholders - using {{key}}.
`Transformer`	`resolveTransformer(DataType from, DataType to)` Resolve a transformer given from/to data type.
`Transformer`	`resolveTransformer(String scheme)` Resolve a transformer given a scheme
`Validator`	`resolveValidator(DataType type)` Resolve a validator given from/to data type.
`void`	`resume()` Important: You should override the lifecycle methods that start with `do`, eg `ServiceSupport.doStart()`, `ServiceSupport.doStop()`, etc.
`void`	`resumeRoute(String routeId)` Resumes the given route if it has been previously suspended If the route does not support suspension the route will be started instead
`protected void`	`resumeRouteService(RouteService routeService)` Resumes the given route service
`protected boolean`	`routeSupportsSuspension(String routeId)`
`protected void`	`safelyStartRouteServices(boolean forceAutoStart, boolean checkClash, boolean startConsumer, boolean resumeConsumer, boolean addingRoutes, RouteService... routeServices)`
`protected void`	`safelyStartRouteServices(boolean checkClash, boolean startConsumer, boolean resumeConsumer, boolean addingRoutes, Collection<RouteService> routeServices)` Starts the routes services in a proper manner which ensures the routes will be started in correct order, check for clash and that the routes will also be shutdown in correct order as well.
`void`	`setAllowUseOriginalMessage(Boolean allowUseOriginalMessage)` Sets whether to allow access to the original message from Camel's error handler, or from `UnitOfWork.getOriginalInMessage()`.
`void`	`setApplicationContextClassLoader(ClassLoader classLoader)` Sets the application CamelContext class loader
`void`	`setAsyncProcessorAwaitManager(AsyncProcessorAwaitManager asyncProcessorAwaitManager)` Sets a custom `AsyncProcessor` await manager.
`void`	`setAutoCreateComponents(boolean autoCreateComponents)`
`void`	`setAutoStartup(Boolean autoStartup)` Sets whether the object should automatically start when Camel starts.
`void`	`setClassResolver(ClassResolver classResolver)` Sets the class resolver to be use
`void`	`setComponentResolver(ComponentResolver componentResolver)`
`static void`	`setContextCounter(int value)` Reset context counter to a preset value.
`void`	`setDataFormatResolver(DataFormatResolver dataFormatResolver)` Sets a custom data format resolver
`void`	`setDataFormats(Map<String,DataFormatDefinition> dataFormats)` Sets the data formats that can be referenced in the routes.
`void`	`setDebugger(Debugger debugger)` Sets a custom `Debugger`
`void`	`setDefaultBacklogDebugger(InterceptStrategy defaultBacklogDebugger)` Sets a custom backlog debugger to be used as the default backlog debugger.
`void`	`setDefaultBacklogTracer(InterceptStrategy backlogTracer)` Sets a custom backlog tracer to be used as the default backlog tracer.
`void`	`setDefaultTracer(InterceptStrategy tracer)` Sets a custom tracer to be used as the default tracer.
`void`	`setDelayer(Long delay)` Sets a delay value in millis that a message is delayed at every step it takes in the route path, slowing the process down to better observe what is occurring Is disabled by default
`void`	`setErrorHandlerBuilder(ErrorHandlerFactory errorHandlerBuilder)` Sets the default error handler builder which is inherited by the routes
`void`	`setExecutorServiceManager(ExecutorServiceManager executorServiceManager)` Sets a custom `ExecutorServiceManager`
`void`	`setFactoryFinderResolver(FactoryFinderResolver resolver)` Sets the factory finder resolver to use.
`void`	`setGlobalOptions(Map<String,String> globalOptions)` Sets global options that can be referenced in the camel context Important: This has nothing to do with property placeholders, and is just a plain set of key/value pairs which are used to configure global options on CamelContext, such as a maximum debug logging length etc.
`void`	`setHandleFault(Boolean handleFault)` Sets whether fault handling is enabled or not (default is disabled).
`void`	`setHeadersMapFactory(HeadersMapFactory headersMapFactory)` Sets a custom `HeadersMapFactory` to be used.
`void`	`setHealthCheckRegistry(HealthCheckRegistry healthCheckRegistry)` Sets a `HealthCheckRegistry`.
`void`	`setHystrixConfiguration(HystrixConfigurationDefinition configuration)` Sets the default Hystrix configuration
`void`	`setHystrixConfigurations(List<HystrixConfigurationDefinition> configurations)` Sets the Hystrix configurations
`void`	`setInflightRepository(InflightRepository repository)` Sets a custom inflight repository to use
`void`	`setInjector(Injector injector)`
`void`	`setInterceptStrategies(List<InterceptStrategy> interceptStrategies)`
`void`	`setJndiContext(Context jndiContext)` Sets the registry to the given JNDI context
`void`	`setLanguageResolver(LanguageResolver languageResolver)`
`void`	`setLazyLoadTypeConverters(Boolean lazyLoadTypeConverters)` Deprecated.
`void`	`setLifecycleStrategies(List<LifecycleStrategy> lifecycleStrategies)`
`void`	`setLoadTypeConverters(Boolean loadTypeConverters)` Sets whether to load custom type converters by scanning classpath.
`void`	`setLogExhaustedMessageBody(Boolean logExhaustedMessageBody)` Sets whether to log exhausted message body with message history.
`void`	`setLogMask(Boolean logMask)` Sets whether security mask for Logging is enabled or not (default is disabled).
`void`	`setManagementMBeanAssembler(ManagementMBeanAssembler managementMBeanAssembler)`
`void`	`setManagementName(String managementName)`
`void`	`setManagementNameStrategy(ManagementNameStrategy managementNameStrategy)` Sets a custom management name strategy
`void`	`setManagementStrategy(ManagementStrategy managementStrategy)` Sets the management strategy to use
`void`	`setMessageHistory(Boolean messageHistory)` Sets whether message history is enabled or not (default is enabled).
`void`	`setMessageHistoryFactory(MessageHistoryFactory messageHistoryFactory)` Sets a custom `MessageHistoryFactory`
`void`	`setModelJAXBContextFactory(ModelJAXBContextFactory modelJAXBContextFactory)` Sets a custom JAXB Context factory to be used
`void`	`setName(String name)` Sets the name of the this context.
`void`	`setNameStrategy(CamelContextNameStrategy nameStrategy)` Sets a custom name strategy
`void`	`setNodeIdFactory(NodeIdFactory idFactory)` Uses a custom node id factory when generating auto assigned ids to the nodes in the route definitions
`void`	`setPackageScanClassResolver(PackageScanClassResolver packageScanClassResolver)` Sets the package scanning class resolver to use
`void`	`setPollingConsumerServicePool(ServicePool<Endpoint,PollingConsumer> pollingConsumerServicePool)` Sets a pluggable service pool to use for `PollingConsumer` pooling.
`void`	`setProcessorFactory(ProcessorFactory processorFactory)` Sets a custom `ProcessorFactory`
`void`	`setProducerServicePool(ServicePool<Endpoint,Producer> producerServicePool)` Sets a pluggable service pool to use for `Producer` pooling.
`void`	`setProperties(Map<String,String> properties)` Deprecated.
`void`	`setRegistry(Registry registry)`
`void`	`setReloadStrategy(ReloadStrategy reloadStrategy)` Sets a custom `ReloadStrategy` to be used
`void`	`setRestConfiguration(RestConfiguration restConfiguration)` Sets a custom `RestConfiguration`
`void`	`setRestRegistry(RestRegistry restRegistry)` Sets a custom `RestRegistry` to use.
`void`	`setRouteController(RouteController routeController)` NOTE: experimental api
`void`	`setRoutePolicyFactories(List<RoutePolicyFactory> routePolicyFactories)`
`void`	`setRoutes(List<Route> routes)` Deprecated.
`void`	`setRuntimeEndpointRegistry(RuntimeEndpointRegistry runtimeEndpointRegistry)` Sets a custom `RuntimeEndpointRegistry` to use.
`void`	`setServiceCallConfiguration(ServiceCallConfigurationDefinition configuration)` Sets the default service call configuration
`void`	`setServiceCallConfigurations(List<ServiceCallConfigurationDefinition> configurations)` Sets the service call configurations
`void`	`setShutdownRoute(ShutdownRoute shutdownRoute)` Sets the ShutdownRoute option for routes.
`void`	`setShutdownRunningTask(ShutdownRunningTask shutdownRunningTask)` Sets the ShutdownRunningTask option to use when shutting down a route.
`void`	`setShutdownStrategy(ShutdownStrategy shutdownStrategy)` Sets a custom shutdown strategy
`void`	`setSSLContextParameters(SSLContextParameters sslContextParameters)` Sets the global SSL context parameters.
`void`	`setStreamCaching(Boolean cache)` Sets whether stream caching is enabled or not (default is disabled).
`void`	`setStreamCachingStrategy(StreamCachingStrategy streamCachingStrategy)` Sets a custom `StreamCachingStrategy` to use.
`void`	`setTracing(Boolean tracing)` Sets whether tracing is enabled or not (default is disabled).
`void`	`setTransformers(List<TransformerDefinition> transformers)` Sets the transformers that can be referenced in the routes.
`void`	`setTypeConverter(TypeConverter typeConverter)`
`void`	`setTypeConverterRegistry(TypeConverterRegistry typeConverterRegistry)`
`void`	`setTypeConverterStatisticsEnabled(Boolean typeConverterStatisticsEnabled)` Sets whether or not type converter statistics is enabled.
`void`	`setUnitOfWorkFactory(UnitOfWorkFactory unitOfWorkFactory)` Sets a custom `UnitOfWorkFactory` to use.
`void`	`setupRoutes(boolean done)` Method to signal to `CamelContext` that the process to initialize setup routes is in progress.
`void`	`setUseBreadcrumb(Boolean useBreadcrumb)` Set whether breadcrumb is enabled.
`void`	`setUseDataType(Boolean useDataType)` Whether to enable using data type on Camel messages.
`void`	`setUseMDCLogging(Boolean useMDCLogging)` Set whether MDC is enabled.
`void`	`setUuidGenerator(UuidGenerator uuidGenerator)` Sets a custom `UuidGenerator` (should only be set once)
`void`	`setValidators(List<ValidatorDefinition> validators)` Sets the validators that can be referenced in the routes.
`protected boolean`	`shouldStartRoutes()` Should we start newly added routes?
`void`	`shutdown()` Important: You should override the lifecycle methods that start with `do`, eg `ServiceSupport.doStart()`, `ServiceSupport.doStop()`, etc.
`void`	`shutdownRoute(String routeId)` Shutdown and removes the given route using `ShutdownStrategy`.
`void`	`shutdownRoute(String routeId, long timeout, TimeUnit timeUnit)` Shutdown and removes the given route using `ShutdownStrategy` with a specified timeout.
`protected void`	`shutdownRouteService(RouteService routeService)`
`void`	`start()` Important: You should override the lifecycle methods that start with `do`, eg `ServiceSupport.doStart()`, `ServiceSupport.doStop()`, etc.
`void`	`startAllRoutes()` Starts all the routes which currently is not started.
`void`	`startRoute(RouteDefinition route)` Starts the given route if it has been previously stopped
`void`	`startRoute(String routeId)` Starts the given route if it has been previously stopped
`protected void`	`startRouteDefinitions(Collection<RouteDefinition> list)`
`protected void`	`startRouteService(RouteService routeService, boolean addingRoutes)` Starts the given route service
`void`	`stop()` Important: You should override the lifecycle methods that start with `do`, eg `ServiceSupport.doStart()`, `ServiceSupport.doStop()`, etc.
`void`	`stopRoute(RouteDefinition route)` Stops the given route.
`void`	`stopRoute(String routeId)` Stops the given route using `ShutdownStrategy`.
`void`	`stopRoute(String routeId, long timeout, TimeUnit timeUnit)` Stops the given route using `ShutdownStrategy` with a specified timeout.
`boolean`	`stopRoute(String routeId, long timeout, TimeUnit timeUnit, boolean abortAfterTimeout)` Stops the given route using `ShutdownStrategy` with a specified timeout and optional abortAfterTimeout mode.
`protected void`	`stopRouteService(RouteService routeService)`
`protected void`	`stopRouteService(RouteService routeService, boolean removingRoutes)`
`void`	`suspend()` Important: You should override the lifecycle methods that start with `do`, eg `ServiceSupport.doStart()`, `ServiceSupport.doStop()`, etc.
`void`	`suspendRoute(String routeId)` Suspends the given route using `ShutdownStrategy`.
`void`	`suspendRoute(String routeId, long timeout, TimeUnit timeUnit)` Suspends the given route using `ShutdownStrategy` with a specified timeout.
`protected void`	`suspendRouteService(RouteService routeService)`
`String`	`toString()`

Methods inherited from class org.apache.camel.support.ServiceSupport
doShutdown, getStatus, getVersion, isRunAllowed, isStarted, isStarting, isStopped, isStopping, isStoppingOrStopped, isSuspended, isSuspending, isSuspendingOrSuspended

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.apache.camel.CamelContext
getStatus, getVersion

Methods inherited from interface org.apache.camel.SuspendableService
isSuspended

- Constructor Detail
  - DefaultCamelContext
```
public DefaultCamelContext()
```
    Creates the CamelContext using JndiRegistry as registry, but will silently fallback and use SimpleRegistry if JNDI cannot be used.
    Use one of the other constructors to force use an explicit registry / JNDI.
  - DefaultCamelContext
```
public DefaultCamelContext(Context jndiContext)
```
    Creates the CamelContext using the given JNDI context as the registry
    
    Parameters:
    
    jndiContext - the JNDI context
  - DefaultCamelContext
```
public DefaultCamelContext(Registry registry)
```
    Creates the CamelContext using the given registry
    
    Parameters:
    
    registry - the registry
- Method Detail
  - adapt
```
public <T extends CamelContext> T adapt(Class<T> type)
```
    Description copied from interface: CamelContext
    
    Adapts this CamelContext to the specialized type.
    For example to adapt to ModelCamelContext, or SpringCamelContext, or CdiCamelContext, etc.
    
    Specified by:
    
    adapt in interface CamelContext
    
    Parameters:
    
    type - the type to adapt to
    
    Returns:
    
    this CamelContext adapted to the given type
  - isVetoStarted
```
public boolean isVetoStarted()
```
    Description copied from interface: CamelContext
    
    If CamelContext during the start procedure was vetoed, and therefore causing Camel to not start.
    
    Specified by:
    
    isVetoStarted in interface CamelContext
  - getName
```
public String getName()
```
    Description copied from interface: CamelContext
    
    Gets the name (id) of the this CamelContext.
    
    Specified by:
    
    getName in interface CamelContext
    
    Returns:
    
    the name
  - setName
```
public void setName(String name)
```
    Sets the name of the this context.
    
    Parameters:
    
    name - the name
  - getNameStrategy
```
public CamelContextNameStrategy getNameStrategy()
```
    Description copied from interface: CamelContext
    
    Gets the current name strategy
    
    Specified by:
    
    getNameStrategy in interface CamelContext
    
    Returns:
    
    name strategy
  - setNameStrategy
```
public void setNameStrategy(CamelContextNameStrategy nameStrategy)
```
    Description copied from interface: CamelContext
    
    Sets a custom name strategy
    
    Specified by:
    
    setNameStrategy in interface CamelContext
    
    Parameters:
    
    nameStrategy - name strategy
  - getManagementNameStrategy
```
public ManagementNameStrategy getManagementNameStrategy()
```
    Description copied from interface: CamelContext
    
    Gets the current management name strategy
    
    Specified by:
    
    getManagementNameStrategy in interface CamelContext
    
    Returns:
    
    management name strategy
  - setManagementNameStrategy
```
public void setManagementNameStrategy(ManagementNameStrategy managementNameStrategy)
```
    Description copied from interface: CamelContext
    
    Sets a custom management name strategy
    
    Specified by:
    
    setManagementNameStrategy in interface CamelContext
    
    Parameters:
    
    managementNameStrategy - name strategy
  - getManagementName
```
public String getManagementName()
```
    Description copied from interface: CamelContext
    
    Gets the name this CamelContext was registered in JMX.
    The reason that a CamelContext can have a different name in JMX is the fact to remedy for name clash in JMX when having multiple CamelContexts in the same JVM. Camel will automatic reassign and use a free name to avoid failing to start.
    
    Specified by:
    
    getManagementName in interface CamelContext
    
    Returns:
    
    the management name
  - setManagementName
```
public void setManagementName(String managementName)
```
  - hasComponent
```
public Component hasComponent(String componentName)
```
    Description copied from interface: CamelContext
    
    Is the given component already registered?
    
    Specified by:
    
    hasComponent in interface CamelContext
    
    Parameters:
    
    componentName - the name of the component
    
    Returns:
    
    the registered Component or null if not registered
  - addComponent
```
public void addComponent(String componentName,
                         Component component)
```
    Description copied from interface: CamelContext
    
    Adds a component to the context.
    
    Specified by:
    
    addComponent in interface CamelContext
    
    Parameters:
    
    componentName - the name the component is registered as
    
    component - the component
  - getComponent
```
public Component getComponent(String name)
```
    Description copied from interface: CamelContext
    
    Gets a component from the CamelContext by name.
    Notice the returned component will be auto-started. If you do not intend to do that then use CamelContext.getComponent(String, boolean, boolean).
    
    Specified by:
    
    getComponent in interface CamelContext
    
    Parameters:
    
    name - the name of the component
    
    Returns:
    
    the component
  - getComponent
```
public Component getComponent(String name,
                              boolean autoCreateComponents)
```
    Description copied from interface: CamelContext
    
    Gets a component from the CamelContext by name.
    Notice the returned component will be auto-started. If you do not intend to do that then use CamelContext.getComponent(String, boolean, boolean).
    
    Specified by:
    
    getComponent in interface CamelContext
    
    Parameters:
    
    name - the name of the component
    
    autoCreateComponents - whether or not the component should be lazily created if it does not already exist
    
    Returns:
    
    the component
  - getComponent
```
public Component getComponent(String name,
                              boolean autoCreateComponents,
                              boolean autoStart)
```
    Description copied from interface: CamelContext
    
    Gets a component from the CamelContext by name.
    
    Specified by:
    
    getComponent in interface CamelContext
    
    Parameters:
    
    name - the name of the component
    
    autoCreateComponents - whether or not the component should be lazily created if it does not already exist
    
    autoStart - whether to auto start the component if CamelContext is already started.
    
    Returns:
    
    the component
  - getComponent
```
public <T extends Component> T getComponent(String name,
                                            Class<T> componentType)
```
    Description copied from interface: CamelContext
    
    Gets a component from the CamelContext by name and specifying the expected type of component.
    
    Specified by:
    
    getComponent in interface CamelContext
    
    Parameters:
    
    name - the name to lookup
    
    componentType - the expected type
    
    Returns:
    
    the component
  - resolveComponent
```
public Component resolveComponent(String name)
```
  - removeComponent
```
public Component removeComponent(String componentName)
```
    Description copied from interface: CamelContext
    
    Removes a previously added component.
    The component being removed will be stopped first.
    
    Specified by:
    
    removeComponent in interface CamelContext
    
    Parameters:
    
    componentName - the component name to remove
    
    Returns:
    
    the previously added component or null if it had not been previously added.
  - getEndpointRegistry
```
public EndpointRegistry<EndpointKey> getEndpointRegistry()
```
    Description copied from interface: CamelContext
    
    Gets the EndpointRegistry
    
    Specified by:
    
    getEndpointRegistry in interface CamelContext
  - getEndpoints
```
public Collection<Endpoint> getEndpoints()
```
    Description copied from interface: CamelContext
    
    Returns a new Collection of all of the endpoints from the EndpointRegistry
    
    Specified by:
    
    getEndpoints in interface CamelContext
    
    Returns:
    
    all endpoints
  - getEndpointMap
```
public Map<String,Endpoint> getEndpointMap()
```
    Description copied from interface: CamelContext
    
    Returns a new Map containing all of the endpoints from the EndpointRegistry
    
    Specified by:
    
    getEndpointMap in interface CamelContext
    
    Returns:
    
    map of endpoints
  - hasEndpoint
```
public Endpoint hasEndpoint(String uri)
```
    Description copied from interface: CamelContext
    
    Is the given endpoint already registered in the EndpointRegistry
    
    Specified by:
    
    hasEndpoint in interface CamelContext
    
    Parameters:
    
    uri - the URI of the endpoint
    
    Returns:
    
    the registered endpoint or null if not registered
  - addEndpoint
```
public Endpoint addEndpoint(String uri,
                            Endpoint endpoint)
                     throws Exception
```
    Description copied from interface: CamelContext
    
    Adds the endpoint to the EndpointRegistry using the given URI.
    
    Specified by:
    
    addEndpoint in interface CamelContext
    
    Parameters:
    
    uri - the URI to be used to resolve this endpoint
    
    endpoint - the endpoint to be added to the registry
    
    Returns:
    
    the old endpoint that was previously registered or null if none was registered
    
    Throws:
    
    Exception - if the new endpoint could not be started or the old endpoint could not be stopped
  - removeEndpoint
```
public void removeEndpoint(Endpoint endpoint)
                    throws Exception
```
    Description copied from interface: CamelContext
    
    Removes the endpoint from the EndpointRegistry.
    The endpoint being removed will be stopped first.
    
    Specified by:
    
    removeEndpoint in interface CamelContext
    
    Parameters:
    
    endpoint - the endpoint
    
    Throws:
    
    Exception - if the endpoint could not be stopped
  - removeEndpoints
```
public Collection<Endpoint> removeEndpoints(String uri)
                                     throws Exception
```
    Description copied from interface: CamelContext
    
    Removes all endpoints with the given URI from the EndpointRegistry.
    The endpoints being removed will be stopped first.
    
    Specified by:
    
    removeEndpoints in interface CamelContext
    
    Parameters:
    
    uri - an uri or pattern to match
    
    Returns:
    
    a collection of endpoints removed which could be empty if there are no endpoints found for the given pattern
    
    Throws:
    
    Exception - if at least one endpoint could not be stopped
    
    See Also:
    
    for pattern
  - getEndpoint
```
public Endpoint getEndpoint(String uri)
```
    Description copied from interface: CamelContext
    
    Resolves the given name to an Endpoint of the specified type. If the name has a singleton endpoint registered, then the singleton is returned. Otherwise, a new Endpoint is created and registered in the EndpointRegistry.
    
    Specified by:
    
    getEndpoint in interface CamelContext
    
    Parameters:
    
    uri - the URI of the endpoint
    
    Returns:
    
    the endpoint
  - getEndpoint
```
public <T extends Endpoint> T getEndpoint(String name,
                                          Class<T> endpointType)
```
    Description copied from interface: CamelContext
    
    Resolves the given name to an Endpoint of the specified type. If the name has a singleton endpoint registered, then the singleton is returned. Otherwise, a new Endpoint is created and registered in the EndpointRegistry.
    
    Specified by:
    
    getEndpoint in interface CamelContext
    
    Parameters:
    
    name - the name of the endpoint
    
    endpointType - the expected type
    
    Returns:
    
    the endpoint
  - addRegisterEndpointCallback
```
public void addRegisterEndpointCallback(EndpointStrategy strategy)
```
    Description copied from interface: CamelContext
    
    Registers a callback to allow you to do custom logic when an Endpoint is about to be registered to the EndpointRegistry.
    When a callback is added it will be executed on the already registered endpoints allowing you to catch-up
    
    Specified by:
    
    addRegisterEndpointCallback in interface CamelContext
    
    Parameters:
    
    strategy - callback to be invoked
  - addEndpointToRegistry
```
protected Endpoint addEndpointToRegistry(String uri,
                                         Endpoint endpoint)
```
    Strategy to add the given endpoint to the internal endpoint registry
    
    Parameters:
    
    uri - uri of the endpoint
    
    endpoint - the endpoint to add
    
    Returns:
    
    the added endpoint
  - normalizeEndpointUri
```
protected static String normalizeEndpointUri(String uri)
```
    Normalize uri so we can do endpoint hits with minor mistakes and parameters is not in the same order.
    
    Parameters:
    
    uri - the uri
    
    Returns:
    
    normalized uri
    
    Throws:
    
    ResolveEndpointFailedException - if uri cannot be normalized
  - getEndpointKey
```
protected EndpointKey getEndpointKey(String uri)
```
    Gets the endpoint key to use for lookup or whe adding endpoints to the DefaultEndpointRegistry
    
    Parameters:
    
    uri - the endpoint uri
    
    Returns:
    
    the key
  - getEndpointKeyPreNormalized
```
protected EndpointKey getEndpointKeyPreNormalized(String uri)
```
    Gets the endpoint key to use for lookup or whe adding endpoints to the DefaultEndpointRegistry
    
    Parameters:
    
    uri - the endpoint uri which is pre normalized
    
    Returns:
    
    the key
  - getEndpointKey
```
protected EndpointKey getEndpointKey(String uri,
                                     Endpoint endpoint)
```
    Gets the endpoint key to use for lookup or whe adding endpoints to the DefaultEndpointRegistry
    
    Parameters:
    
    uri - the endpoint uri
    
    endpoint - the endpoint
    
    Returns:
    
    the key
  - setRouteController
```
public void setRouteController(RouteController routeController)
```
    Description copied from interface: CamelContext
    
    NOTE: experimental api
    
    Specified by:
    
    setRouteController in interface CamelContext
    
    Parameters:
    
    routeController - the route controller
  - getRouteController
```
public RouteController getRouteController()
```
    Description copied from interface: CamelContext
    
    NOTE: experimental api
    
    Specified by:
    
    getRouteController in interface CamelContext
    
    Returns:
    
    the route controller or null if not set.
  - getRouteStartupOrder
```
public List<RouteStartupOrder> getRouteStartupOrder()
```
    Description copied from interface: CamelContext
    
    Returns the order in which the route inputs was started.
    The order may not be according to the startupOrder defined on the route. For example a route could be started manually later, or new routes added at runtime.
    
    Specified by:
    
    getRouteStartupOrder in interface CamelContext
    
    Returns:
    
    a list in the order how routes was started
  - getRoutes
```
public List<Route> getRoutes()
```
    Description copied from interface: CamelContext
    
    Returns the current routes in this CamelContext
    
    Specified by:
    
    getRoutes in interface CamelContext
    
    Returns:
    
    the current routes
  - getRoute
```
public Route getRoute(String id)
```
    Description copied from interface: CamelContext
    
    Gets the route with the given id
    
    Specified by:
    
    getRoute in interface CamelContext
    
    Parameters:
    
    id - id of the route
    
    Returns:
    
    the route or null if not found
  - getProcessor
```
public Processor getProcessor(String id)
```
    Description copied from interface: CamelContext
    
    Gets the processor from any of the routes which with the given id
    
    Specified by:
    
    getProcessor in interface CamelContext
    
    Parameters:
    
    id - id of the processor
    
    Returns:
    
    the processor or null if not found
  - getProcessor
```
public <T extends Processor> T getProcessor(String id,
                                            Class<T> type)
```
    Description copied from interface: CamelContext
    
    Gets the processor from any of the routes which with the given id
    
    Specified by:
    
    getProcessor in interface CamelContext
    
    Parameters:
    
    id - id of the processor
    
    type - the processor type
    
    Returns:
    
    the processor or null if not found
  - getManagedProcessor
```
public <T extends ManagedProcessorMBean> T getManagedProcessor(String id,
                                                               Class<T> type)
```
    Description copied from interface: CamelContext
    
    Gets the managed processor client api from any of the routes which with the given id
    
    Specified by:
    
    getManagedProcessor in interface CamelContext
    
    Parameters:
    
    id - id of the processor
    
    type - the managed processor type from the org.apache.camel.api.management.mbean package.
    
    Returns:
    
    the processor or null if not found
  - getManagedRoute
```
public <T extends ManagedRouteMBean> T getManagedRoute(String routeId,
                                                       Class<T> type)
```
    Description copied from interface: CamelContext
    
    Gets the managed route client api with the given route id
    
    Specified by:
    
    getManagedRoute in interface CamelContext
    
    Parameters:
    
    routeId - id of the route
    
    type - the managed route type from the org.apache.camel.api.management.mbean package.
    
    Returns:
    
    the route or null if not found
  - getManagedCamelContext
```
public ManagedCamelContextMBean getManagedCamelContext()
```
    Description copied from interface: CamelContext
    
    Gets the managed Camel CamelContext client api
    
    Specified by:
    
    getManagedCamelContext in interface CamelContext
  - getProcessorDefinition
```
public ProcessorDefinition getProcessorDefinition(String id)
```
    Description copied from interface: CamelContext
    
    Gets the processor definition from any of the routes which with the given id
    
    Specified by:
    
    getProcessorDefinition in interface CamelContext
    
    Parameters:
    
    id - id of the processor definition
    
    Returns:
    
    the processor definition or null if not found
  - getProcessorDefinition
```
public <T extends ProcessorDefinition> T getProcessorDefinition(String id,
                                                                Class<T> type)
```
    Description copied from interface: CamelContext
    
    Gets the processor definition from any of the routes which with the given id
    
    Specified by:
    
    getProcessorDefinition in interface CamelContext
    
    Parameters:
    
    id - id of the processor definition
    
    type - the processor definition type
    
    Returns:
    
    the processor definition or null if not found
  - setRoutes
```
@Deprecated
public void setRoutes(List<Route> routes)
```
    Deprecated.
  - addRoutes
```
public void addRoutes(RoutesBuilder builder)
               throws Exception
```
    Description copied from interface: CamelContext
    
    Adds a collection of routes to this CamelContext using the given builder to build them.
    Important: The added routes will only be started, if CamelContext is already started. You may want to check the state of CamelContext before adding the routes, using the CamelContext.getStatus() method.
    Important: Each route in the same CamelContext must have an unique route id. If you use the API from CamelContext or ModelCamelContext to add routes, then any new routes which has a route id that matches an old route, then the old route is replaced by the new route.
    
    Specified by:
    
    addRoutes in interface CamelContext
    
    Parameters:
    
    builder - the builder which will create the routes and add them to this CamelContext
    
    Throws:
    
    Exception - if the routes could not be created for whatever reason
  - loadRoutesDefinition
```
public RoutesDefinition loadRoutesDefinition(InputStream is)
                                      throws Exception
```
    Description copied from interface: ModelCamelContext
    
    Loads a collection of route definitions from the given InputStream.
    
    Specified by:
    
    loadRoutesDefinition in interface CamelContext
    
    Specified by:
    
    loadRoutesDefinition in interface ModelCamelContext
    
    Parameters:
    
    is - input stream with the route(s) definition to add
    
    Returns:
    
    the route definitions
    
    Throws:
    
    Exception - if the route definitions could not be loaded for whatever reason
  - loadRestsDefinition
```
public RestsDefinition loadRestsDefinition(InputStream is)
                                    throws Exception
```
    Description copied from interface: ModelCamelContext
    
    Loads a collection of rest definitions from the given InputStream.
    
    Specified by:
    
    loadRestsDefinition in interface CamelContext
    
    Specified by:
    
    loadRestsDefinition in interface ModelCamelContext
    
    Parameters:
    
    is - input stream with the rest(s) definition to add
    
    Returns:
    
    the rest definitions
    
    Throws:
    
    Exception - if the rest definitions could not be loaded for whatever reason
  - addRouteDefinitions
```
public void addRouteDefinitions(Collection<RouteDefinition> routeDefinitions)
                         throws Exception
```
    Description copied from interface: ModelCamelContext
    
    Adds a collection of route definitions to the context
    Important: Each route in the same CamelContext must have an unique route id. If you use the API from CamelContext or ModelCamelContext to add routes, then any new routes which has a route id that matches an old route, then the old route is replaced by the new route.
    
    Specified by:
    
    addRouteDefinitions in interface CamelContext
    
    Specified by:
    
    addRouteDefinitions in interface ModelCamelContext
    
    Parameters:
    
    routeDefinitions - the route(s) definition to add
    
    Throws:
    
    Exception - if the route definitions could not be created for whatever reason
  - addRouteDefinition
```
public void addRouteDefinition(RouteDefinition routeDefinition)
                        throws Exception
```
    Description copied from interface: ModelCamelContext
    
    Add a route definition to the context
    Important: Each route in the same CamelContext must have an unique route id. If you use the API from CamelContext or ModelCamelContext to add routes, then any new routes which has a route id that matches an old route, then the old route is replaced by the new route.
    
    Specified by:
    
    addRouteDefinition in interface CamelContext
    
    Specified by:
    
    addRouteDefinition in interface ModelCamelContext
    
    Parameters:
    
    routeDefinition - the route definition to add
    
    Throws:
    
    Exception - if the route definition could not be created for whatever reason
  - removeRouteDefinition
```
protected boolean removeRouteDefinition(String key)
```
    Removes the route definition with the given key.
    
    Returns:
    
    true if one or more routes was removed
  - removeRouteDefinitions
```
public void removeRouteDefinitions(Collection<RouteDefinition> routeDefinitions)
                            throws Exception
```
    Description copied from interface: ModelCamelContext
    
    Removes a collection of route definitions from the context - stopping any previously running routes if any of them are actively running
    
    Specified by:
    
    removeRouteDefinitions in interface CamelContext
    
    Specified by:
    
    removeRouteDefinitions in interface ModelCamelContext
    
    Parameters:
    
    routeDefinitions - route(s) definitions to remove
    
    Throws:
    
    Exception - if the route definitions could not be removed for whatever reason
  - removeRouteDefinition
```
public void removeRouteDefinition(RouteDefinition routeDefinition)
                           throws Exception
```
    Description copied from interface: ModelCamelContext
    
    Removes a route definition from the context - stopping any previously running routes if any of them are actively running
    
    Specified by:
    
    removeRouteDefinition in interface CamelContext
    
    Specified by:
    
    removeRouteDefinition in interface ModelCamelContext
    
    Parameters:
    
    routeDefinition - route definition to remove
    
    Throws:
    
    Exception - if the route definition could not be removed for whatever reason
  - getRouteStatus
```
public ServiceStatus getRouteStatus(String key)
```
    Description copied from interface: CamelContext
    
    Returns the current status of the given route
    
    Specified by:
    
    getRouteStatus in interface CamelContext
    
    Parameters:
    
    key - the route id
    
    Returns:
    
    the status for the route
  - startRoute
```
public void startRoute(RouteDefinition route)
                throws Exception
```
    Description copied from interface: ModelCamelContext
    
    Starts the given route if it has been previously stopped
    
    Specified by:
    
    startRoute in interface CamelContext
    
    Specified by:
    
    startRoute in interface ModelCamelContext
    
    Parameters:
    
    route - the route to start
    
    Throws:
    
    Exception - is thrown if the route could not be started for whatever reason
  - isStartingRoutes
```
public boolean isStartingRoutes()
```
    Description copied from interface: CamelContext
    
    Indicates whether current thread is starting route(s).
    This can be useful to know by LifecycleStrategy or the likes, in case they need to react differently.
    
    Specified by:
    
    isStartingRoutes in interface CamelContext
    
    Returns:
    
    true if current thread is starting route(s), or false if not.
  - isSetupRoutes
```
public boolean isSetupRoutes()
```
    Description copied from interface: CamelContext
    
    Indicates whether current thread is setting up route(s) as part of starting Camel from spring/blueprint.
    This can be useful to know by LifecycleStrategy or the likes, in case they need to react differently.
    As the startup procedure of CamelContext is slightly different when using plain Java versus Spring or Blueprint, then we need to know when Spring/Blueprint is setting up the routes, which can happen after the CamelContext itself is in started state, due the asynchronous event nature of especially Blueprint.
    
    Specified by:
    
    isSetupRoutes in interface CamelContext
    
    Returns:
    
    true if current thread is setting up route(s), or false if not.
  - stopRoute
```
public void stopRoute(RouteDefinition route)
               throws Exception
```
    Description copied from interface: ModelCamelContext
    
    Stops the given route.
    
    Specified by:
    
    stopRoute in interface CamelContext
    
    Specified by:
    
    stopRoute in interface ModelCamelContext
    
    Parameters:
    
    route - the route to stop
    
    Throws:
    
    Exception - is thrown if the route could not be stopped for whatever reason
  - startAllRoutes
```
public void startAllRoutes()
                    throws Exception
```
    Description copied from interface: CamelContext
    
    Starts all the routes which currently is not started.
    
    Specified by:
    
    startAllRoutes in interface CamelContext
    
    Throws:
    
    Exception - is thrown if a route could not be started for whatever reason
  - startRoute
```
public void startRoute(String routeId)
                throws Exception
```
    Description copied from interface: CamelContext
    
    Starts the given route if it has been previously stopped
    
    Specified by:
    
    startRoute in interface CamelContext
    
    Parameters:
    
    routeId - the route id
    
    Throws:
    
    Exception - is thrown if the route could not be started for whatever reason
  - resumeRoute
```
public void resumeRoute(String routeId)
                 throws Exception
```
    Description copied from interface: CamelContext
    
    Resumes the given route if it has been previously suspended
    If the route does not support suspension the route will be started instead
    
    Specified by:
    
    resumeRoute in interface CamelContext
    
    Parameters:
    
    routeId - the route id
    
    Throws:
    
    Exception - is thrown if the route could not be resumed for whatever reason
  - stopRoute
```
public boolean stopRoute(String routeId,
                         long timeout,
                         TimeUnit timeUnit,
                         boolean abortAfterTimeout)
                  throws Exception
```
    Description copied from interface: CamelContext
    
    Stops the given route using ShutdownStrategy with a specified timeout and optional abortAfterTimeout mode.
    
    Specified by:
    
    stopRoute in interface CamelContext
    
    Parameters:
    
    routeId - the route id
    
    timeout - timeout
    
    timeUnit - the unit to use
    
    abortAfterTimeout - should abort shutdown after timeout
    
    Returns:
    
    true if the route is stopped before the timeout
    
    Throws:
    
    Exception - is thrown if the route could not be stopped for whatever reason
    
    See Also:
    
    CamelContext.suspendRoute(String, long, java.util.concurrent.TimeUnit)
  - stopRoute
```
public void stopRoute(String routeId)
               throws Exception
```
    Description copied from interface: CamelContext
    
    Stops the given route using ShutdownStrategy.
    
    Specified by:
    
    stopRoute in interface CamelContext
    
    Parameters:
    
    routeId - the route id
    
    Throws:
    
    Exception - is thrown if the route could not be stopped for whatever reason
    
    See Also:
    
    CamelContext.suspendRoute(String)
  - stopRoute
```
public void stopRoute(String routeId,
                      long timeout,
                      TimeUnit timeUnit)
               throws Exception
```
    Description copied from interface: CamelContext
    
    Stops the given route using ShutdownStrategy with a specified timeout.
    
    Specified by:
    
    stopRoute in interface CamelContext
    
    Parameters:
    
    routeId - the route id
    
    timeout - timeout
    
    timeUnit - the unit to use
    
    Throws:
    
    Exception - is thrown if the route could not be stopped for whatever reason
    
    See Also:
    
    CamelContext.suspendRoute(String, long, java.util.concurrent.TimeUnit)
  - shutdownRoute
```
public void shutdownRoute(String routeId)
                   throws Exception
```
    Description copied from interface: CamelContext
    
    Shutdown and removes the given route using ShutdownStrategy.
    
    Specified by:
    
    shutdownRoute in interface CamelContext
    
    Parameters:
    
    routeId - the route id
    
    Throws:
    
    Exception - is thrown if the route could not be shutdown for whatever reason
  - shutdownRoute
```
public void shutdownRoute(String routeId,
                          long timeout,
                          TimeUnit timeUnit)
                   throws Exception
```
    Description copied from interface: CamelContext
    
    Shutdown and removes the given route using ShutdownStrategy with a specified timeout.
    
    Specified by:
    
    shutdownRoute in interface CamelContext
    
    Parameters:
    
    routeId - the route id
    
    timeout - timeout
    
    timeUnit - the unit to use
    
    Throws:
    
    Exception - is thrown if the route could not be shutdown for whatever reason
  - removeRoute
```
public boolean removeRoute(String routeId)
                    throws Exception
```
    Description copied from interface: CamelContext
    
    Removes the given route (the route must be stopped before it can be removed).
    A route which is removed will be unregistered from JMX, have its services stopped/shutdown and the route definition etc. will also be removed. All the resources related to the route will be stopped and cleared.
    Important: When removing a route, the Endpoints which are in the static cache of EndpointRegistry and are only used by the route (not used by other routes) will also be removed. But Endpoints which may have been created as part of routing messages by the route, and those endpoints are enlisted in the dynamic cache of EndpointRegistry are not removed. To remove those dynamic kind of endpoints, use the CamelContext.removeEndpoints(String) method. If not removing those endpoints, they will be kept in the dynamic cache of EndpointRegistry, but my eventually be removed (evicted) when they have not been in use for a longer period of time; and the dynamic cache upper limit is hit, and it evicts the least used endpoints.
    End users can use this method to remove unwanted routes or temporary routes which no longer is in demand.
    
    Specified by:
    
    removeRoute in interface CamelContext
    
    Parameters:
    
    routeId - the route id
    
    Returns:
    
    true if the route was removed, false if the route could not be removed because its not stopped
    
    Throws:
    
    Exception - is thrown if the route could not be shutdown for whatever reason
  - suspendRoute
```
public void suspendRoute(String routeId)
                  throws Exception
```
    Description copied from interface: CamelContext
    
    Suspends the given route using ShutdownStrategy.
    Suspending a route is more gently than stopping, as the route consumers will be suspended (if they support) otherwise the consumers will be stopped.
    By suspending the route services will be kept running (if possible) and therefore its faster to resume the route.
    If the route does not support suspension the route will be stopped instead
    
    Specified by:
    
    suspendRoute in interface CamelContext
    
    Parameters:
    
    routeId - the route id
    
    Throws:
    
    Exception - is thrown if the route could not be suspended for whatever reason
  - suspendRoute
```
public void suspendRoute(String routeId,
                         long timeout,
                         TimeUnit timeUnit)
                  throws Exception
```
    Description copied from interface: CamelContext
    
    Suspends the given route using ShutdownStrategy with a specified timeout.
    Suspending a route is more gently than stopping, as the route consumers will be suspended (if they support) otherwise the consumers will be stopped.
    By suspending the route services will be kept running (if possible) and therefore its faster to resume the route.
    If the route does not support suspension the route will be stopped instead
    
    Specified by:
    
    suspendRoute in interface CamelContext
    
    Parameters:
    
    routeId - the route id
    
    timeout - timeout
    
    timeUnit - the unit to use
    
    Throws:
    
    Exception - is thrown if the route could not be suspended for whatever reason
  - addService
```
public void addService(Object object)
                throws Exception
```
    Description copied from interface: CamelContext
    
    Adds a service to this CamelContext, which allows this CamelContext to control the lifecycle, ensuring the service is stopped when the CamelContext stops.
    The service will also have CamelContext injected if its CamelContextAware. The service will also be enlisted in JMX for management (if JMX is enabled). The service will be started, if its not already started.
    
    Specified by:
    
    addService in interface CamelContext
    
    Parameters:
    
    object - the service
    
    Throws:
    
    Exception - can be thrown when starting the service
  - addService
```
public void addService(Object object,
                       boolean stopOnShutdown)
                throws Exception
```
    Description copied from interface: CamelContext
    
    Adds a service to this CamelContext.
    The service will also have CamelContext injected if its CamelContextAware. The service will also be enlisted in JMX for management (if JMX is enabled). The service will be started, if its not already started.
    If the option closeOnShutdown is true then this CamelContext will control the lifecycle, ensuring the service is stopped when the CamelContext stops. If the option closeOnShutdown is false then this CamelContext will not stop the service when the CamelContext stops.
    
    Specified by:
    
    addService in interface CamelContext
    
    Parameters:
    
    object - the service
    
    stopOnShutdown - whether to stop the service when this CamelContext shutdown.
    
    Throws:
    
    Exception - can be thrown when starting the service
  - addService
```
public void addService(Object object,
                       boolean stopOnShutdown,
                       boolean forceStart)
                throws Exception
```
    Description copied from interface: CamelContext
    
    Adds a service to this CamelContext.
    The service will also have CamelContext injected if its CamelContextAware. The service will also be enlisted in JMX for management (if JMX is enabled). The service will be started, if its not already started.
    If the option closeOnShutdown is true then this CamelContext will control the lifecycle, ensuring the service is stopped when the CamelContext stops. If the option closeOnShutdown is false then this CamelContext will not stop the service when the CamelContext stops.
    
    Specified by:
    
    addService in interface CamelContext
    
    Parameters:
    
    object - the service
    
    stopOnShutdown - whether to stop the service when this CamelContext shutdown.
    
    forceStart - whether to force starting the service right now, as otherwise the service may be deferred being started to later using CamelContext.deferStartService(Object, boolean)
    
    Throws:
    
    Exception - can be thrown when starting the service
  - removeService
```
public boolean removeService(Object object)
                      throws Exception
```
    Description copied from interface: CamelContext
    
    Removes a service from this CamelContext.
    The service is assumed to have been previously added using CamelContext.addService(Object) method. This method will not change the service lifecycle.
    
    Specified by:
    
    removeService in interface CamelContext
    
    Parameters:
    
    object - the service
    
    Returns:
    
    true if the service was removed, false if no service existed
    
    Throws:
    
    Exception - can be thrown if error removing the service
  - hasService
```
public boolean hasService(Object object)
```
    Description copied from interface: CamelContext
    
    Has the given service already been added to this CamelContext?
    
    Specified by:
    
    hasService in interface CamelContext
    
    Parameters:
    
    object - the service
    
    Returns:
    
    true if already added, false if not.
  - hasService
```
public <T> T hasService(Class<T> type)
```
    Description copied from interface: CamelContext
    
    Has the given service type already been added to this CamelContext?
    
    Specified by:
    
    hasService in interface CamelContext
    
    Parameters:
    
    type - the class type
    
    Returns:
    
    the service instance or null if not already added.
  - hasServices
```
public <T> Set<T> hasServices(Class<T> type)
```
    Description copied from interface: CamelContext
    
    Has the given service type already been added to this CamelContext?
    
    Specified by:
    
    hasServices in interface CamelContext
    
    Parameters:
    
    type - the class type
    
    Returns:
    
    the services instance or empty set.
  - deferStartService
```
public void deferStartService(Object object,
                              boolean stopOnShutdown)
                       throws Exception
```
    Description copied from interface: CamelContext
    
    Defers starting the service until CamelContext is (almost started) or started and has initialized all its prior services and routes.
    If CamelContext is already started then the service is started immediately.
    
    Specified by:
    
    deferStartService in interface CamelContext
    
    Parameters:
    
    object - the service
    
    stopOnShutdown - whether to stop the service when this CamelContext shutdown. Setting this to true will keep a reference to the service in this CamelContext until the CamelContext is stopped. So do not use it for short lived services.
    
    Throws:
    
    Exception - can be thrown when starting the service, which is only attempted if CamelContext has already been started when calling this method.
  - addStartupListener
```
public void addStartupListener(StartupListener listener)
                        throws Exception
```
    Description copied from interface: CamelContext
    
    Adds the given listener to be invoked when CamelContext have just been started.
    This allows listeners to do any custom work after the routes and other services have been started and are running.
    Important: The listener will always be invoked, also if the CamelContext has already been started, see the StartupListener.onCamelContextStarted(CamelContext, boolean) method.
    
    Specified by:
    
    addStartupListener in interface CamelContext
    
    Parameters:
    
    listener - the listener
    
    Throws:
    
    Exception - can be thrown if CamelContext is already started and the listener is invoked and cause an exception to be thrown
  - resolveComponentDefaultName
```
public String resolveComponentDefaultName(String javaType)
```
    Description copied from interface: CamelContext
    
    Resolves a component's default name from its java type.
    A component may be used with a non default name such as activemq, wmq for the JMS component. This method can resolve the default component name by its java type.
    
    Specified by:
    
    resolveComponentDefaultName in interface CamelContext
    
    Parameters:
    
    javaType - the FQN name of the java type
    
    Returns:
    
    the default component name.
  - findComponents
```
public Map<String,Properties> findComponents()
                                      throws LoadPropertiesException,
                                             IOException
```
    Description copied from interface: CamelContext
    
    Find information about all the Camel components available in the classpath and Registry.
    
    Specified by:
    
    findComponents in interface CamelContext
    
    Returns:
    
    a map with the component name, and value with component details.
    
    Throws:
    
    LoadPropertiesException - is thrown if error during classpath discovery of the components
    
    IOException - is thrown if error during classpath discovery of the components
  - findEips
```
public Map<String,Properties> findEips()
                                throws LoadPropertiesException,
                                       IOException
```
    Description copied from interface: CamelContext
    
    Find information about all the EIPs from camel-core.
    
    Specified by:
    
    findEips in interface CamelContext
    
    Returns:
    
    a map with node id, and value with EIP details.
    
    Throws:
    
    LoadPropertiesException - is thrown if error during classpath discovery of the EIPs
    
    IOException - is thrown if error during classpath discovery of the EIPs
  - getComponentDocumentation
```
public String getComponentDocumentation(String componentName)
                                 throws IOException
```
    Description copied from interface: CamelContext
    
    Returns the HTML documentation for the given Camel component
    
    Specified by:
    
    getComponentDocumentation in interface CamelContext
    
    Returns:
    
    the HTML or null if the component is not built with HTML document included.
    
    Throws:
    
    IOException
  - getComponentParameterJsonSchema
```
public String getComponentParameterJsonSchema(String componentName)
                                       throws IOException
```
    Description copied from interface: CamelContext
    
    Returns the JSON schema representation of the component and endpoint parameters for the given component name.
    
    Specified by:
    
    getComponentParameterJsonSchema in interface CamelContext
    
    Returns:
    
    the json or null if the component is not built with JSon schema support
    
    Throws:
    
    IOException
  - getDataFormatParameterJsonSchema
```
public String getDataFormatParameterJsonSchema(String dataFormatName)
                                        throws IOException
```
    Description copied from interface: CamelContext
    
    Returns the JSON schema representation of the DataFormat parameters for the given data format name.
    
    Specified by:
    
    getDataFormatParameterJsonSchema in interface CamelContext
    
    Returns:
    
    the json or null if the data format does not exist
    
    Throws:
    
    IOException
  - getLanguageParameterJsonSchema
```
public String getLanguageParameterJsonSchema(String languageName)
                                      throws IOException
```
    Description copied from interface: CamelContext
    
    Returns the JSON schema representation of the Language parameters for the given language name.
    
    Specified by:
    
    getLanguageParameterJsonSchema in interface CamelContext
    
    Returns:
    
    the json or null if the language does not exist
    
    Throws:
    
    IOException
  - getEipParameterJsonSchema
```
public String getEipParameterJsonSchema(String eipName)
                                 throws IOException
```
    Description copied from interface: CamelContext
    
    Returns the JSON schema representation of the EIP parameters for the given EIP name.
    
    Specified by:
    
    getEipParameterJsonSchema in interface CamelContext
    
    Returns:
    
    the json or null if the EIP does not exist
    
    Throws:
    
    IOException
  - explainEipJson
```
public String explainEipJson(String nameOrId,
                             boolean includeAllOptions)
```
    Description copied from interface: CamelContext
    
    Returns a JSON schema representation of the EIP parameters for the given EIP by its id.
    
    Specified by:
    
    explainEipJson in interface CamelContext
    
    Parameters:
    
    nameOrId - the name of the EIP (NamedNode.getShortName() or a node id to refer to a specific node from the routes.
    
    includeAllOptions - whether to include non configured options also (eg default options)
    
    Returns:
    
    the json or null if the eipName or the id was not found
  - explainDataFormatJson
```
public String explainDataFormatJson(String dataFormatName,
                                    DataFormat dataFormat,
                                    boolean includeAllOptions)
```
    Description copied from interface: CamelContext
    
    Returns a JSON schema representation of the component parameters (not endpoint parameters) for the given component by its id.
    
    Specified by:
    
    explainDataFormatJson in interface CamelContext
    
    dataFormat - the data format instance.
    
    includeAllOptions - whether to include non configured options also (eg default options)
    
    Returns:
    
    the json
  - explainComponentJson
```
public String explainComponentJson(String componentName,
                                   boolean includeAllOptions)
```
    Description copied from interface: CamelContext
    
    Returns a JSON schema representation of the component parameters (not endpoint parameters) for the given component by its id.
    
    Specified by:
    
    explainComponentJson in interface CamelContext
    
    Parameters:
    
    componentName - the name of the component.
    
    includeAllOptions - whether to include non configured options also (eg default options)
    
    Returns:
    
    the json or null if the component was not found
  - explainEndpointJson
```
public String explainEndpointJson(String uri,
                                  boolean includeAllOptions)
```
    Description copied from interface: CamelContext
    
    Returns a JSON schema representation of the endpoint parameters for the given endpoint uri.
    
    Specified by:
    
    explainEndpointJson in interface CamelContext
    
    Parameters:
    
    uri - the endpoint uri
    
    includeAllOptions - whether to include non configured options also (eg default options)
    
    Returns:
    
    the json or null if uri parameters is invalid, or the component is not built with JSon schema support
  - createRouteStaticEndpointJson
```
public String createRouteStaticEndpointJson(String routeId)
```
    Description copied from interface: CamelContext
    
    Creates a JSON representation of all the static and dynamic configured endpoints defined in the given route(s).
    
    Specified by:
    
    createRouteStaticEndpointJson in interface CamelContext
    
    Parameters:
    
    routeId - for a particular route, or null for all routes
    
    Returns:
    
    a JSON string
  - createRouteStaticEndpointJson
```
public String createRouteStaticEndpointJson(String routeId,
                                            boolean includeDynamic)
```
    Description copied from interface: CamelContext
    
    Creates a JSON representation of all the static (and possible dynamic) configured endpoints defined in the given route(s).
    
    Specified by:
    
    createRouteStaticEndpointJson in interface CamelContext
    
    Parameters:
    
    routeId - for a particular route, or null for all routes
    
    includeDynamic - whether to include dynamic endpoints
    
    Returns:
    
    a JSON string
  - resolveLanguage
```
public Language resolveLanguage(String language)
```
    Description copied from interface: CamelContext
    
    Resolves a language for creating expressions
    
    Specified by:
    
    resolveLanguage in interface CamelContext
    
    Parameters:
    
    language - name of the language
    
    Returns:
    
    the resolved language
  - getPropertyPrefixToken
```
public String getPropertyPrefixToken()
```
    Description copied from interface: CamelContext
    
    Returns the configured property placeholder prefix token if and only if the CamelContext has property placeholder abilities, otherwise returns null.
    
    Specified by:
    
    getPropertyPrefixToken in interface CamelContext
    
    Returns:
    
    the prefix token or null
  - getPropertySuffixToken
```
public String getPropertySuffixToken()
```
    Description copied from interface: CamelContext
    
    Returns the configured property placeholder suffix token if and only if the CamelContext has property placeholder abilities, otherwise returns null.
    
    Specified by:
    
    getPropertySuffixToken in interface CamelContext
    
    Returns:
    
    the suffix token or null
  - resolvePropertyPlaceholders
```
public String resolvePropertyPlaceholders(String text)
                                   throws Exception
```
    Description copied from interface: CamelContext
    
    Parses the given text and resolve any property placeholders - using {{key}}.
    
    Specified by:
    
    resolvePropertyPlaceholders in interface CamelContext
    
    Parameters:
    
    text - the text such as an endpoint uri or the likes
    
    Returns:
    
    the text with resolved property placeholders
    
    Throws:
    
    Exception - is thrown if property placeholders was used and there was an error resolving them
  - getTypeConverter
```
public TypeConverter getTypeConverter()
```
    Description copied from interface: CamelContext
    
    Returns the type converter used to coerce types from one type to another
    
    Specified by:
    
    getTypeConverter in interface CamelContext
    
    Returns:
    
    the converter
  - setTypeConverter
```
public void setTypeConverter(TypeConverter typeConverter)
```
  - getTypeConverterRegistry
```
public TypeConverterRegistry getTypeConverterRegistry()
```
    Description copied from interface: CamelContext
    
    Returns the type converter registry where type converters can be added or looked up
    
    Specified by:
    
    getTypeConverterRegistry in interface CamelContext
    
    Returns:
    
    the type converter registry
  - setTypeConverterRegistry
```
public void setTypeConverterRegistry(TypeConverterRegistry typeConverterRegistry)
```
  - getInjector
```
public Injector getInjector()
```
    Description copied from interface: CamelContext
    
    Returns the injector used to instantiate objects by type
    
    Specified by:
    
    getInjector in interface CamelContext
    
    Returns:
    
    the injector
  - setInjector
```
public void setInjector(Injector injector)
```
  - getManagementMBeanAssembler
```
public ManagementMBeanAssembler getManagementMBeanAssembler()
```
    Description copied from interface: CamelContext
    
    Returns the management mbean assembler
    
    Specified by:
    
    getManagementMBeanAssembler in interface CamelContext
    
    Returns:
    
    the mbean assembler
  - setManagementMBeanAssembler
```
public void setManagementMBeanAssembler(ManagementMBeanAssembler managementMBeanAssembler)
```
  - getComponentResolver
```
public ComponentResolver getComponentResolver()
```
  - setComponentResolver
```
public void setComponentResolver(ComponentResolver componentResolver)
```
  - getLanguageResolver
```
public LanguageResolver getLanguageResolver()
```
  - setLanguageResolver
```
public void setLanguageResolver(LanguageResolver languageResolver)
```
  - isAutoCreateComponents
```
public boolean isAutoCreateComponents()
```
  - setAutoCreateComponents
```
public void setAutoCreateComponents(boolean autoCreateComponents)
```
  - getRegistry
```
public Registry getRegistry()
```
    Description copied from interface: CamelContext
    
    Returns the registry used to lookup components by name and type such as the Spring ApplicationContext, JNDI or the OSGi Service Registry
    
    Specified by:
    
    getRegistry in interface CamelContext
    
    Returns:
    
    the registry
  - getRegistry
```
public <T> T getRegistry(Class<T> type)
```
    Description copied from interface: CamelContext
    
    Returns the registry used to lookup components by name and as the given type
    
    Specified by:
    
    getRegistry in interface CamelContext
    
    Parameters:
    
    type - the registry type such as JndiRegistry
    
    Returns:
    
    the registry, or null if the given type was not found as a registry implementation
  - setJndiContext
```
public void setJndiContext(Context jndiContext)
```
    Sets the registry to the given JNDI context
    
    Parameters:
    
    jndiContext - is the JNDI context to use as the registry
    
    See Also:
    
    setRegistry(org.apache.camel.spi.Registry)
  - setRegistry
```
public void setRegistry(Registry registry)
```
  - getLifecycleStrategies
```
public List<LifecycleStrategy> getLifecycleStrategies()
```
    Description copied from interface: CamelContext
    
    Returns the lifecycle strategies used to handle lifecycle notifications
    
    Specified by:
    
    getLifecycleStrategies in interface CamelContext
    
    Returns:
    
    the lifecycle strategies
  - setLifecycleStrategies
```
public void setLifecycleStrategies(List<LifecycleStrategy> lifecycleStrategies)
```
  - addLifecycleStrategy
```
public void addLifecycleStrategy(LifecycleStrategy lifecycleStrategy)
```
    Description copied from interface: CamelContext
    
    Adds the given lifecycle strategy to be used.
    
    Specified by:
    
    addLifecycleStrategy in interface CamelContext
    
    Parameters:
    
    lifecycleStrategy - the strategy
  - setupRoutes
```
public void setupRoutes(boolean done)
```
    Description copied from interface: CamelContext
    
    Method to signal to CamelContext that the process to initialize setup routes is in progress.
    
    Specified by:
    
    setupRoutes in interface CamelContext
    
    Parameters:
    
    done - false to start the process, call again with true to signal its done.
    
    See Also:
    
    CamelContext.isSetupRoutes()
  - getRouteDefinitions
```
public List<RouteDefinition> getRouteDefinitions()
```
    Description copied from interface: ModelCamelContext
    
    Returns a list of the current route definitions
    
    Specified by:
    
    getRouteDefinitions in interface CamelContext
    
    Specified by:
    
    getRouteDefinitions in interface ModelCamelContext
    
    Returns:
    
    list of the current route definitions
  - getRouteDefinition
```
public RouteDefinition getRouteDefinition(String id)
```
    Description copied from interface: ModelCamelContext
    
    Gets the route definition with the given id
    
    Specified by:
    
    getRouteDefinition in interface CamelContext
    
    Specified by:
    
    getRouteDefinition in interface ModelCamelContext
    
    Parameters:
    
    id - id of the route
    
    Returns:
    
    the route definition or null if not found
  - getRestDefinitions
```
public List<RestDefinition> getRestDefinitions()
```
    Description copied from interface: ModelCamelContext
    
    Returns a list of the current REST definitions
    
    Specified by:
    
    getRestDefinitions in interface CamelContext
    
    Specified by:
    
    getRestDefinitions in interface ModelCamelContext
    
    Returns:
    
    list of the current REST definitions
  - addRestDefinitions
```
public void addRestDefinitions(Collection<RestDefinition> restDefinitions)
                        throws Exception
```
    Description copied from interface: ModelCamelContext
    
    Adds a collection of rest definitions to the context
    
    Specified by:
    
    addRestDefinitions in interface CamelContext
    
    Specified by:
    
    addRestDefinitions in interface ModelCamelContext
    
    Parameters:
    
    restDefinitions - the rest(s) definition to add
    
    Throws:
    
    Exception - if the rest definitions could not be created for whatever reason
  - getRestConfiguration
```
public RestConfiguration getRestConfiguration()
```
    Description copied from interface: CamelContext
    
    Gets the default REST configuration
    
    Specified by:
    
    getRestConfiguration in interface CamelContext
    
    Returns:
    
    the configuration, or null if none has been configured.
  - setRestConfiguration
```
public void setRestConfiguration(RestConfiguration restConfiguration)
```
    Description copied from interface: CamelContext
    
    Sets a custom RestConfiguration
    
    Specified by:
    
    setRestConfiguration in interface CamelContext
    
    Parameters:
    
    restConfiguration - the REST configuration
  - getRestConfigurations
```
public Collection<RestConfiguration> getRestConfigurations()
```
    Description copied from interface: CamelContext
    
    Gets all the RestConfiguration's
    
    Specified by:
    
    getRestConfigurations in interface CamelContext
  - addRestConfiguration
```
public void addRestConfiguration(RestConfiguration restConfiguration)
```
    Description copied from interface: CamelContext
    
    Sets a custom RestConfiguration
    
    Specified by:
    
    addRestConfiguration in interface CamelContext
    
    Parameters:
    
    restConfiguration - the REST configuration
  - getRestConfiguration
```
public RestConfiguration getRestConfiguration(String component,
                                              boolean defaultIfNotExist)
```
    Description copied from interface: CamelContext
    
    Gets the REST configuration for the given component
    
    Specified by:
    
    getRestConfiguration in interface CamelContext
    
    Parameters:
    
    component - the component name to get the configuration
    
    defaultIfNotExist - determine if the default configuration is returned if there isn't a specific configuration for the given component
    
    Returns:
    
    the configuration, or null if none has been configured.
  - getServiceCallConfiguration
```
public ServiceCallConfigurationDefinition getServiceCallConfiguration(String serviceName)
```
    Description copied from interface: CamelContext
    
    Gets the service call configuration by the given name. If no name is given the default configuration is returned, see setServiceCallConfiguration
    
    Specified by:
    
    getServiceCallConfiguration in interface CamelContext
    
    Parameters:
    
    serviceName - name of service, or null to return the default configuration
    
    Returns:
    
    the configuration, or null if no configuration has been registered
  - setServiceCallConfiguration
```
public void setServiceCallConfiguration(ServiceCallConfigurationDefinition configuration)
```
    Description copied from interface: CamelContext
    
    Sets the default service call configuration
    
    Specified by:
    
    setServiceCallConfiguration in interface CamelContext
    
    Parameters:
    
    configuration - the configuration
  - setServiceCallConfigurations
```
public void setServiceCallConfigurations(List<ServiceCallConfigurationDefinition> configurations)
```
    Description copied from interface: CamelContext
    
    Sets the service call configurations
    
    Specified by:
    
    setServiceCallConfigurations in interface CamelContext
    
    Parameters:
    
    configurations - the configuration list
  - addServiceCallConfiguration
```
public void addServiceCallConfiguration(String serviceName,
                                        ServiceCallConfigurationDefinition configuration)
```
    Description copied from interface: CamelContext
    
    Adds the service call configuration
    
    Specified by:
    
    addServiceCallConfiguration in interface CamelContext
    
    Parameters:
    
    serviceName - name of the service
    
    configuration - the configuration
  - getHystrixConfiguration
```
public HystrixConfigurationDefinition getHystrixConfiguration(String id)
```
    Description copied from interface: CamelContext
    
    Gets the Hystrix configuration by the given name. If no name is given the default configuration is returned, see setHystrixConfiguration
    
    Specified by:
    
    getHystrixConfiguration in interface CamelContext
    
    Parameters:
    
    id - id of the configuration, or null to return the default configuration
    
    Returns:
    
    the configuration, or null if no configuration has been registered
  - setHystrixConfiguration
```
public void setHystrixConfiguration(HystrixConfigurationDefinition configuration)
```
    Description copied from interface: CamelContext
    
    Sets the default Hystrix configuration
    
    Specified by:
    
    setHystrixConfiguration in interface CamelContext
    
    Parameters:
    
    configuration - the configuration
  - setHystrixConfigurations
```
public void setHystrixConfigurations(List<HystrixConfigurationDefinition> configurations)
```
    Description copied from interface: CamelContext
    
    Sets the Hystrix configurations
    
    Specified by:
    
    setHystrixConfigurations in interface CamelContext
    
    Parameters:
    
    configurations - the configuration list
  - addHystrixConfiguration
```
public void addHystrixConfiguration(String id,
                                    HystrixConfigurationDefinition configuration)
```
    Description copied from interface: CamelContext
    
    Adds the Hystrix configuration
    
    Specified by:
    
    addHystrixConfiguration in interface CamelContext
    
    Parameters:
    
    id - name of the configuration
    
    configuration - the configuration
  - getInterceptStrategies
```
public List<InterceptStrategy> getInterceptStrategies()
```
    Description copied from interface: CamelContext
    
    Gets the interceptor strategies
    
    Specified by:
    
    getInterceptStrategies in interface CamelContext
    
    Returns:
    
    the list of current interceptor strategies
  - setInterceptStrategies
```
public void setInterceptStrategies(List<InterceptStrategy> interceptStrategies)
```
  - addInterceptStrategy
```
public void addInterceptStrategy(InterceptStrategy interceptStrategy)
```
    Description copied from interface: CamelContext
    
    Adds the given interceptor strategy
    
    Specified by:
    
    addInterceptStrategy in interface CamelContext
    
    Parameters:
    
    interceptStrategy - the strategy
  - getRoutePolicyFactories
```
public List<RoutePolicyFactory> getRoutePolicyFactories()
```
    Description copied from interface: CamelContext
    
    Gets the route policy factories
    
    Specified by:
    
    getRoutePolicyFactories in interface CamelContext
    
    Returns:
    
    the list of current route policy factories
  - setRoutePolicyFactories
```
public void setRoutePolicyFactories(List<RoutePolicyFactory> routePolicyFactories)
```
  - addRoutePolicyFactory
```
public void addRoutePolicyFactory(RoutePolicyFactory routePolicyFactory)
```
    Description copied from interface: CamelContext
    
    Adds the given route policy factory
    
    Specified by:
    
    addRoutePolicyFactory in interface CamelContext
    
    Parameters:
    
    routePolicyFactory - the factory
  - getLogListeners
```
public Set<LogListener> getLogListeners()
```
    Description copied from interface: CamelContext
    
    Gets a list of LogListener.
    
    Specified by:
    
    getLogListeners in interface CamelContext
  - addLogListener
```
public void addLogListener(LogListener listener)
```
    Description copied from interface: CamelContext
    
    Adds a LogListener.
    
    Specified by:
    
    addLogListener in interface CamelContext
  - setStreamCaching
```
public void setStreamCaching(Boolean cache)
```
    Description copied from interface: RuntimeConfiguration
    
    Sets whether stream caching is enabled or not (default is disabled).
    
    Specified by:
    
    setStreamCaching in interface RuntimeConfiguration
    
    Parameters:
    
    cache - whether stream caching is enabled or not
  - isStreamCaching
```
public Boolean isStreamCaching()
```
    Description copied from interface: RuntimeConfiguration
    
    Returns whether stream cache is enabled
    
    Specified by:
    
    isStreamCaching in interface RuntimeConfiguration
    
    Returns:
    
    true if stream cache is enabled
  - setTracing
```
public void setTracing(Boolean tracing)
```
    Description copied from interface: RuntimeConfiguration
    
    Sets whether tracing is enabled or not (default is disabled).
    
    Specified by:
    
    setTracing in interface RuntimeConfiguration
    
    Parameters:
    
    tracing - whether to enable tracing.
  - isTracing
```
public Boolean isTracing()
```
    Description copied from interface: RuntimeConfiguration
    
    Returns whether tracing enabled
    
    Specified by:
    
    isTracing in interface RuntimeConfiguration
    
    Returns:
    
    true if tracing is enabled
  - isMessageHistory
```
public Boolean isMessageHistory()
```
    Description copied from interface: RuntimeConfiguration
    
    Returns whether message history is enabled
    
    Specified by:
    
    isMessageHistory in interface RuntimeConfiguration
    
    Returns:
    
    true if message history is enabled
  - setMessageHistory
```
public void setMessageHistory(Boolean messageHistory)
```
    Description copied from interface: RuntimeConfiguration
    
    Sets whether message history is enabled or not (default is enabled).
    
    Specified by:
    
    setMessageHistory in interface RuntimeConfiguration
    
    Parameters:
    
    messageHistory - whether message history is enabled
  - setLogMask
```
public void setLogMask(Boolean logMask)
```
    Description copied from interface: RuntimeConfiguration
    
    Sets whether security mask for Logging is enabled or not (default is disabled).
    
    Specified by:
    
    setLogMask in interface RuntimeConfiguration
    
    Parameters:
    
    logMask - true if mask is enabled
  - isLogMask
```
public Boolean isLogMask()
```
    Description copied from interface: RuntimeConfiguration
    
    Gets whether security mask for Logging is enabled or not.
    
    Specified by:
    
    isLogMask in interface RuntimeConfiguration
    
    Returns:
    
    true if mask is enabled
  - isLogExhaustedMessageBody
```
public Boolean isLogExhaustedMessageBody()
```
    Description copied from interface: RuntimeConfiguration
    
    Returns whether to log exhausted message body with message history.
    
    Specified by:
    
    isLogExhaustedMessageBody in interface RuntimeConfiguration
    
    Returns:
    
    true if logging of message body is enabled
  - setLogExhaustedMessageBody
```
public void setLogExhaustedMessageBody(Boolean logExhaustedMessageBody)
```
    Description copied from interface: RuntimeConfiguration
    
    Sets whether to log exhausted message body with message history.
    
    Specified by:
    
    setLogExhaustedMessageBody in interface RuntimeConfiguration
    
    Parameters:
    
    logExhaustedMessageBody - whether message body should be logged
  - isHandleFault
```
public Boolean isHandleFault()
```
    Description copied from interface: RuntimeConfiguration
    
    Returns whether fault handling enabled
    
    Specified by:
    
    isHandleFault in interface RuntimeConfiguration
    
    Returns:
    
    true if fault handling is enabled
  - setHandleFault
```
public void setHandleFault(Boolean handleFault)
```
    Description copied from interface: RuntimeConfiguration
    
    Sets whether fault handling is enabled or not (default is disabled).
    
    Specified by:
    
    setHandleFault in interface RuntimeConfiguration
    
    Parameters:
    
    handleFault - whether to enable fault handling.
  - getDelayer
```
public Long getDelayer()
```
    Description copied from interface: RuntimeConfiguration
    
    Gets the delay value
    
    Specified by:
    
    getDelayer in interface RuntimeConfiguration
    
    Returns:
    
    delay in millis, or null if disabled
  - setDelayer
```
public void setDelayer(Long delay)
```
    Description copied from interface: RuntimeConfiguration
    
    Sets a delay value in millis that a message is delayed at every step it takes in the route path, slowing the process down to better observe what is occurring
    Is disabled by default
    
    Specified by:
    
    setDelayer in interface RuntimeConfiguration
    
    Parameters:
    
    delay - delay in millis
  - createProducerTemplate
```
public ProducerTemplate createProducerTemplate()
```
    Description copied from interface: CamelContext
    
    Creates a new ProducerTemplate which is started and therefore ready to use right away.
    See this FAQ before use: Why does Camel use too many threads with ProducerTemplate?
    Important: Make sure to call Service.stop() when you are done using the template, to clean up any resources.
    Will use cache size defined in Camel property with key Exchange.MAXIMUM_CACHE_POOL_SIZE. If no key was defined then it will fallback to a default size of 1000. You can also use the ProducerTemplate.setMaximumCacheSize(int) method to use a custom value before starting the template.
    
    Specified by:
    
    createProducerTemplate in interface CamelContext
    
    Returns:
    
    the template
  - createProducerTemplate
```
public ProducerTemplate createProducerTemplate(int maximumCacheSize)
```
    Description copied from interface: CamelContext
    
    Creates a new ProducerTemplate which is started and therefore ready to use right away.
    See this FAQ before use: Why does Camel use too many threads with ProducerTemplate?
    Important: Make sure to call Service.stop() when you are done using the template, to clean up any resources.
    
    Specified by:
    
    createProducerTemplate in interface CamelContext
    
    Parameters:
    
    maximumCacheSize - the maximum cache size
    
    Returns:
    
    the template
  - createFluentProducerTemplate
```
public FluentProducerTemplate createFluentProducerTemplate()
```
    Description copied from interface: CamelContext
    
    Creates a new FluentProducerTemplate which is started and therefore ready to use right away.
    See this FAQ before use: Why does Camel use too many threads with ProducerTemplate?
    Important: Make sure to call Service.stop() when you are done using the template, to clean up any resources.
    Will use cache size defined in Camel property with key Exchange.MAXIMUM_CACHE_POOL_SIZE. If no key was defined then it will fallback to a default size of 1000. You can also use the FluentProducerTemplate.setMaximumCacheSize(int) method to use a custom value before starting the template.
    
    Specified by:
    
    createFluentProducerTemplate in interface CamelContext
    
    Returns:
    
    the template
  - createFluentProducerTemplate
```
public FluentProducerTemplate createFluentProducerTemplate(int maximumCacheSize)
```
    Description copied from interface: CamelContext
    
    Creates a new FluentProducerTemplate which is started and therefore ready to use right away.
    See this FAQ before use: Why does Camel use too many threads with ProducerTemplate?
    Important: Make sure to call Service.stop() when you are done using the template, to clean up any resources.
    
    Specified by:
    
    createFluentProducerTemplate in interface CamelContext
    
    Parameters:
    
    maximumCacheSize - the maximum cache size
    
    Returns:
    
    the template
  - createConsumerTemplate
```
public ConsumerTemplate createConsumerTemplate()
```
    Description copied from interface: CamelContext
    
    Creates a new ConsumerTemplate which is started and therefore ready to use right away.
    See this FAQ before use: Why does Camel use too many threads with ProducerTemplate? as it also applies for ConsumerTemplate.
    Important: Make sure to call Service.stop() when you are done using the template, to clean up any resources.
    Will use cache size defined in Camel property with key Exchange.MAXIMUM_CACHE_POOL_SIZE. If no key was defined then it will fallback to a default size of 1000. You can also use the ConsumerTemplate.setMaximumCacheSize(int) method to use a custom value before starting the template.
    
    Specified by:
    
    createConsumerTemplate in interface CamelContext
    
    Returns:
    
    the template
  - createConsumerTemplate
```
public ConsumerTemplate createConsumerTemplate(int maximumCacheSize)
```
    Description copied from interface: CamelContext
    
    Creates a new ConsumerTemplate which is started and therefore ready to use right away.
    See this FAQ before use: Why does Camel use too many threads with ProducerTemplate? as it also applies for ConsumerTemplate.
    Important: Make sure to call Service.stop() when you are done using the template, to clean up any resources.
    
    Specified by:
    
    createConsumerTemplate in interface CamelContext
    
    Parameters:
    
    maximumCacheSize - the maximum cache size
    
    Returns:
    
    the template
  - getErrorHandlerBuilder
```
public ErrorHandlerBuilder getErrorHandlerBuilder()
```
    Description copied from interface: CamelContext
    
    Gets the default error handler builder which is inherited by the routes
    
    Specified by:
    
    getErrorHandlerBuilder in interface CamelContext
    
    Returns:
    
    the builder
  - setErrorHandlerBuilder
```
public void setErrorHandlerBuilder(ErrorHandlerFactory errorHandlerBuilder)
```
    Description copied from interface: CamelContext
    
    Sets the default error handler builder which is inherited by the routes
    
    Specified by:
    
    setErrorHandlerBuilder in interface CamelContext
    
    Parameters:
    
    errorHandlerBuilder - the builder
  - getErrorHandlerExecutorService
```
public ScheduledExecutorService getErrorHandlerExecutorService()
```
    Description copied from interface: CamelContext
    
    Gets the default shared thread pool for error handlers which leverages this for asynchronous redelivery tasks.
    
    Specified by:
    
    getErrorHandlerExecutorService in interface CamelContext
  - setProducerServicePool
```
public void setProducerServicePool(ServicePool<Endpoint,Producer> producerServicePool)
```
    Description copied from interface: CamelContext
    
    Sets a pluggable service pool to use for Producer pooling.
    
    Specified by:
    
    setProducerServicePool in interface CamelContext
    
    Parameters:
    
    producerServicePool - the pool
  - getProducerServicePool
```
public ServicePool<Endpoint,Producer> getProducerServicePool()
```
    Description copied from interface: CamelContext
    
    Gets the service pool for Producer pooling.
    
    Specified by:
    
    getProducerServicePool in interface CamelContext
    
    Returns:
    
    the service pool
  - getPollingConsumerServicePool
```
public ServicePool<Endpoint,PollingConsumer> getPollingConsumerServicePool()
```
    Description copied from interface: CamelContext
    
    Gets the service pool for Producer pooling.
    
    Specified by:
    
    getPollingConsumerServicePool in interface CamelContext
    
    Returns:
    
    the service pool
  - setPollingConsumerServicePool
```
public void setPollingConsumerServicePool(ServicePool<Endpoint,PollingConsumer> pollingConsumerServicePool)
```
    Description copied from interface: CamelContext
    
    Sets a pluggable service pool to use for PollingConsumer pooling.
    
    Specified by:
    
    setPollingConsumerServicePool in interface CamelContext
    
    Parameters:
    
    pollingConsumerServicePool - the pool
  - getUnitOfWorkFactory
```
public UnitOfWorkFactory getUnitOfWorkFactory()
```
    Description copied from interface: CamelContext
    
    Gets the UnitOfWorkFactory to use.
    
    Specified by:
    
    getUnitOfWorkFactory in interface CamelContext
  - setUnitOfWorkFactory
```
public void setUnitOfWorkFactory(UnitOfWorkFactory unitOfWorkFactory)
```
    Description copied from interface: CamelContext
    
    Sets a custom UnitOfWorkFactory to use.
    
    Specified by:
    
    setUnitOfWorkFactory in interface CamelContext
  - getRuntimeEndpointRegistry
```
public RuntimeEndpointRegistry getRuntimeEndpointRegistry()
```
    Description copied from interface: CamelContext
    
    Gets the RuntimeEndpointRegistry to use, or null if none is in use.
    
    Specified by:
    
    getRuntimeEndpointRegistry in interface CamelContext
  - setRuntimeEndpointRegistry
```
public void setRuntimeEndpointRegistry(RuntimeEndpointRegistry runtimeEndpointRegistry)
```
    Description copied from interface: CamelContext
    
    Sets a custom RuntimeEndpointRegistry to use.
    
    Specified by:
    
    setRuntimeEndpointRegistry in interface CamelContext
  - getUptime
```
public String getUptime()
```
    Description copied from interface: CamelContext
    
    Gets the uptime in a human readable format
    
    Specified by:
    
    getUptime in interface CamelContext
    
    Returns:
    
    the uptime in days/hours/minutes
  - getUptimeMillis
```
public long getUptimeMillis()
```
    Description copied from interface: CamelContext
    
    Gets the uptime in milli seconds
    
    Specified by:
    
    getUptimeMillis in interface CamelContext
    
    Returns:
    
    the uptime in millis seconds
  - doSuspend
```
protected void doSuspend()
                  throws Exception
```
    Description copied from class: ServiceSupport
    
    Implementations override this method to support customized suspend/resume.
    
    Overrides:
    
    doSuspend in class ServiceSupport
    
    Throws:
    
    Exception
  - doResume
```
protected void doResume()
                 throws Exception
```
    Description copied from class: ServiceSupport
    
    Implementations override this method to support customized suspend/resume.
    
    Overrides:
    
    doResume in class ServiceSupport
    
    Throws:
    
    Exception
  - start
```
public void start()
           throws Exception
```
    Description copied from class: ServiceSupport
    
    Important: You should override the lifecycle methods that start with do, eg ServiceSupport.doStart(), ServiceSupport.doStop(), etc. where you implement your logic. The methods ServiceSupport.start(), ServiceSupport.stop() should NOT be overriden as they are used internally to keep track of the state of this service and properly invoke the operation in a safe manner.
    
    Specified by:
    
    start in interface CamelContext
    
    Specified by:
    
    start in interface Service
    
    Overrides:
    
    start in class ServiceSupport
    
    Throws:
    
    Exception - is thrown if starting failed
  - stop
```
public void stop()
          throws Exception
```
    Description copied from class: ServiceSupport
    
    Important: You should override the lifecycle methods that start with do, eg ServiceSupport.doStart(), ServiceSupport.doStop(), etc. where you implement your logic. The methods ServiceSupport.start(), ServiceSupport.stop() should NOT be overriden as they are used internally to keep track of the state of this service and properly invoke the operation in a safe manner.
    
    Specified by:
    
    stop in interface CamelContext
    
    Specified by:
    
    stop in interface Service
    
    Overrides:
    
    stop in class ServiceSupport
    
    Throws:
    
    Exception - is thrown if stopping failed
  - suspend
```
public void suspend()
             throws Exception
```
    Description copied from class: ServiceSupport
    
    Important: You should override the lifecycle methods that start with do, eg ServiceSupport.doStart(), ServiceSupport.doStop(), etc. where you implement your logic. The methods ServiceSupport.start(), ServiceSupport.stop() should NOT be overriden as they are used internally to keep track of the state of this service and properly invoke the operation in a safe manner.
    
    Specified by:
    
    suspend in interface SuspendableService
    
    Overrides:
    
    suspend in class ServiceSupport
    
    Throws:
    
    Exception - is thrown if suspending failed
  - resume
```
public void resume()
            throws Exception
```
    Description copied from class: ServiceSupport
    
    Important: You should override the lifecycle methods that start with do, eg ServiceSupport.doStart(), ServiceSupport.doStop(), etc. where you implement your logic. The methods ServiceSupport.start(), ServiceSupport.stop() should NOT be overriden as they are used internally to keep track of the state of this service and properly invoke the operation in a safe manner.
    
    Specified by:
    
    resume in interface SuspendableService
    
    Overrides:
    
    resume in class ServiceSupport
    
    Throws:
    
    Exception - is thrown if resuming failed
  - shutdown
```
public void shutdown()
              throws Exception
```
    Description copied from class: ServiceSupport
    
    Important: You should override the lifecycle methods that start with do, eg ServiceSupport.doStart(), ServiceSupport.doStop(), etc. where you implement your logic. The methods ServiceSupport.start(), ServiceSupport.stop() should NOT be overriden as they are used internally to keep track of the state of this service and properly invoke the operation in a safe manner.
    
    Specified by:
    
    shutdown in interface ShutdownableService
    
    Overrides:
    
    shutdown in class ServiceSupport
    
    Throws:
    
    Exception - thrown if shutting down failed
  - doStart
```
protected void doStart()
                throws Exception
```
    Description copied from class: ServiceSupport
    
    Implementations override this method to support customized start/stop.
    Important: See ServiceSupport.doStop() for more details.
    
    Specified by:
    
    doStart in class ServiceSupport
    
    Throws:
    
    Exception
    
    See Also:
    
    ServiceSupport.doStop()
  - doStartCamel
```
protected void doStartCamel()
                     throws Exception
```
    Throws:
    
    Exception
  - doStop
```
protected void doStop()
               throws Exception
```
    Description copied from class: ServiceSupport
    
    Implementations override this method to support customized start/stop.
    Important: Camel will invoke this ServiceSupport.doStop() method when the service is being stopped. This method will also be invoked if the service is still in uninitialized state (eg has not been started). The method is always called to allow the service to do custom logic when the service is being stopped, such as when CamelContext is shutting down.
    
    Specified by:
    
    doStop in class ServiceSupport
    
    Throws:
    
    Exception
    
    See Also:
    
    ServiceSupport.doStart()
  - doStartOrResumeRoutes
```
protected void doStartOrResumeRoutes(Map<String,RouteService> routeServices,
                                     boolean checkClash,
                                     boolean startConsumer,
                                     boolean resumeConsumer,
                                     boolean addingRoutes)
                              throws Exception
```
    Starts or resumes the routes
    
    Parameters:
    
    routeServices - the routes to start (will only start a route if its not already started)
    
    checkClash - whether to check for startup ordering clash
    
    startConsumer - whether the route consumer should be started. Can be used to warmup the route without starting the consumer.
    
    resumeConsumer - whether the route consumer should be resumed.
    
    addingRoutes - whether we are adding new routes
    
    Throws:
    
    Exception - is thrown if error starting routes
  - routeSupportsSuspension
```
protected boolean routeSupportsSuspension(String routeId)
```
  - startRouteDefinitions
```
protected void startRouteDefinitions(Collection<RouteDefinition> list)
                              throws Exception
```
    Throws:
    
    Exception
  - startRouteService
```
protected void startRouteService(RouteService routeService,
                                 boolean addingRoutes)
                          throws Exception
```
    Starts the given route service
    
    Throws:
    
    Exception
  - resumeRouteService
```
protected void resumeRouteService(RouteService routeService)
                           throws Exception
```
    Resumes the given route service
    
    Throws:
    
    Exception
  - stopRouteService
```
protected void stopRouteService(RouteService routeService,
                                boolean removingRoutes)
                         throws Exception
```
    Throws:
    
    Exception
  - logRouteState
```
protected void logRouteState(Route route,
                             String state)
```
  - stopRouteService
```
protected void stopRouteService(RouteService routeService)
                         throws Exception
```
    Throws:
    
    Exception
  - shutdownRouteService
```
protected void shutdownRouteService(RouteService routeService)
                             throws Exception
```
    Throws:
    
    Exception
  - suspendRouteService
```
protected void suspendRouteService(RouteService routeService)
                            throws Exception
```
    Throws:
    
    Exception
  - safelyStartRouteServices
```
protected void safelyStartRouteServices(boolean checkClash,
                                        boolean startConsumer,
                                        boolean resumeConsumer,
                                        boolean addingRoutes,
                                        Collection<RouteService> routeServices)
                                 throws Exception
```
    Starts the routes services in a proper manner which ensures the routes will be started in correct order, check for clash and that the routes will also be shutdown in correct order as well.
    This method must be used to start routes in a safe manner.
    
    Parameters:
    
    checkClash - whether to check for startup order clash
    
    startConsumer - whether the route consumer should be started. Can be used to warmup the route without starting the consumer.
    
    resumeConsumer - whether the route consumer should be resumed.
    
    addingRoutes - whether we are adding new routes
    
    routeServices - the routes
    
    Throws:
    
    Exception - is thrown if error starting the routes
  - safelyStartRouteServices
```
protected void safelyStartRouteServices(boolean forceAutoStart,
                                        boolean checkClash,
                                        boolean startConsumer,
                                        boolean resumeConsumer,
                                        boolean addingRoutes,
                                        RouteService... routeServices)
                                 throws Exception
```
    Throws:
    
    Exception
    
    See Also:
    
    safelyStartRouteServices(boolean,boolean,boolean,boolean,java.util.Collection)
  - forceLazyInitialization
```
protected void forceLazyInitialization()
```
    Force some lazy initialization to occur upfront before we start any components and create routes
  - forceStopLazyInitialization
```
protected void forceStopLazyInitialization()
```
    Force clear lazy initialization so they can be re-created on restart
  - createTypeConverter
```
protected TypeConverter createTypeConverter()
```
    Lazily create a default implementation
  - createInjector
```
protected Injector createInjector()
```
    Lazily create a default implementation
  - createManagementMBeanAssembler
```
protected ManagementMBeanAssembler createManagementMBeanAssembler()
```
    Lazily create a default implementation
  - createComponentResolver
```
protected ComponentResolver createComponentResolver()
```
    Lazily create a default implementation
  - createRegistry
```
protected Registry createRegistry()
```
    Lazily create a default implementation
  - createEndpoint
```
protected Endpoint createEndpoint(String uri)
```
    A pluggable strategy to allow an endpoint to be created without requiring a component to be its factory, such as for looking up the URI inside some Registry
    
    Parameters:
    
    uri - the uri for the endpoint to be created
    
    Returns:
    
    the newly created endpoint or null if it could not be resolved
  - convertBeanToEndpoint
```
protected Endpoint convertBeanToEndpoint(String uri,
                                         Object bean)
```
    Strategy method for attempting to convert the bean from a Registry to an endpoint using some kind of transformation or wrapper
    
    Parameters:
    
    uri - the uri for the endpoint (and name in the registry)
    
    bean - the bean to be converted to an endpoint, which will be not null
    
    Returns:
    
    a new endpoint
  - shouldStartRoutes
```
protected boolean shouldStartRoutes()
```
    Should we start newly added routes?
  - getPropertiesComponent
```
protected PropertiesComponent getPropertiesComponent()
```
    Gets the properties component in use. Returns null if no properties component is in use.
  - setDataFormats
```
public void setDataFormats(Map<String,DataFormatDefinition> dataFormats)
```
    Description copied from interface: ModelCamelContext
    
    Sets the data formats that can be referenced in the routes.
    
    Specified by:
    
    setDataFormats in interface CamelContext
    
    Specified by:
    
    setDataFormats in interface ModelCamelContext
    
    Parameters:
    
    dataFormats - the data formats
  - getDataFormats
```
public Map<String,DataFormatDefinition> getDataFormats()
```
    Description copied from interface: ModelCamelContext
    
    Gets the data formats that can be referenced in the routes.
    
    Specified by:
    
    getDataFormats in interface CamelContext
    
    Specified by:
    
    getDataFormats in interface ModelCamelContext
    
    Returns:
    
    the data formats available
  - getProperties
```
@Deprecated
public Map<String,String> getProperties()
```
    Deprecated.
    
    Specified by:
    
    getProperties in interface CamelContext
  - getGlobalOptions
```
public Map<String,String> getGlobalOptions()
```
    Description copied from interface: CamelContext
    
    Gets global options that can be referenced in the camel context.
    Important: This has nothing to do with property placeholders, and is just a plain set of key/value pairs which are used to configure global options on CamelContext, such as a maximum debug logging length etc. For property placeholders use CamelContext.resolvePropertyPlaceholders(String) method and see more details at the property placeholder documentation.
    
    Specified by:
    
    getGlobalOptions in interface CamelContext
    
    Returns:
    
    global options for this context
  - setProperties
```
@Deprecated
public void setProperties(Map<String,String> properties)
```
    Deprecated.
    
    Specified by:
    
    setProperties in interface CamelContext
  - setGlobalOptions
```
public void setGlobalOptions(Map<String,String> globalOptions)
```
    Description copied from interface: CamelContext
    
    Sets global options that can be referenced in the camel context
    Important: This has nothing to do with property placeholders, and is just a plain set of key/value pairs which are used to configure global options on CamelContext, such as a maximum debug logging length etc. For property placeholders use CamelContext.resolvePropertyPlaceholders(String) method and see more details at the property placeholder documentation.
    
    Specified by:
    
    setGlobalOptions in interface CamelContext
    
    Parameters:
    
    globalOptions - global options that can be referenced in the camel context
  - getDefaultFactoryFinder
```
public FactoryFinder getDefaultFactoryFinder()
```
    Description copied from interface: CamelContext
    
    Gets the default FactoryFinder which will be used for the loading the factory class from META-INF
    
    Specified by:
    
    getDefaultFactoryFinder in interface CamelContext
    
    Returns:
    
    the default factory finder
  - getFactoryFinderResolver
```
public FactoryFinderResolver getFactoryFinderResolver()
```
  - setFactoryFinderResolver
```
public void setFactoryFinderResolver(FactoryFinderResolver resolver)
```
    Description copied from interface: CamelContext
    
    Sets the factory finder resolver to use.
    
    Specified by:
    
    setFactoryFinderResolver in interface CamelContext
    
    Parameters:
    
    resolver - the factory finder resolver
  - getFactoryFinder
```
public FactoryFinder getFactoryFinder(String path)
                               throws NoFactoryAvailableException
```
    Description copied from interface: CamelContext
    
    Gets the FactoryFinder which will be used for the loading the factory class from META-INF in the given path
    
    Specified by:
    
    getFactoryFinder in interface CamelContext
    
    Parameters:
    
    path - the META-INF path
    
    Returns:
    
    the factory finder
    
    Throws:
    
    NoFactoryAvailableException - is thrown if a factory could not be found
  - getClassResolver
```
public ClassResolver getClassResolver()
```
    Description copied from interface: CamelContext
    
    Returns the class resolver to be used for loading/lookup of classes.
    
    Specified by:
    
    getClassResolver in interface CamelContext
    
    Returns:
    
    the resolver
  - setClassResolver
```
public void setClassResolver(ClassResolver classResolver)
```
    Description copied from interface: CamelContext
    
    Sets the class resolver to be use
    
    Specified by:
    
    setClassResolver in interface CamelContext
    
    Parameters:
    
    classResolver - the resolver
  - getPackageScanClassResolver
```
public PackageScanClassResolver getPackageScanClassResolver()
```
    Description copied from interface: CamelContext
    
    Returns the package scanning class resolver
    
    Specified by:
    
    getPackageScanClassResolver in interface CamelContext
    
    Returns:
    
    the resolver
  - setPackageScanClassResolver
```
public void setPackageScanClassResolver(PackageScanClassResolver packageScanClassResolver)
```
    Description copied from interface: CamelContext
    
    Sets the package scanning class resolver to use
    
    Specified by:
    
    setPackageScanClassResolver in interface CamelContext
    
    Parameters:
    
    packageScanClassResolver - the resolver
  - getComponentNames
```
public List<String> getComponentNames()
```
    Description copied from interface: CamelContext
    
    Gets a readonly list of names of the components currently registered
    
    Specified by:
    
    getComponentNames in interface CamelContext
    
    Returns:
    
    a readonly list with the names of the components
  - getLanguageNames
```
public List<String> getLanguageNames()
```
    Description copied from interface: CamelContext
    
    Gets a readonly list with the names of the languages currently registered.
    
    Specified by:
    
    getLanguageNames in interface CamelContext
    
    Returns:
    
    a readonly list with the names of the languages
  - getModelJAXBContextFactory
```
public ModelJAXBContextFactory getModelJAXBContextFactory()
```
    Description copied from interface: CamelContext
    
    Returns the JAXB Context factory used to create Models.
    
    Specified by:
    
    getModelJAXBContextFactory in interface CamelContext
    
    Returns:
    
    the JAXB Context factory used to create Models.
  - setModelJAXBContextFactory
```
public void setModelJAXBContextFactory(ModelJAXBContextFactory modelJAXBContextFactory)
```
    Description copied from interface: CamelContext
    
    Sets a custom JAXB Context factory to be used
    
    Specified by:
    
    setModelJAXBContextFactory in interface CamelContext
    
    Parameters:
    
    modelJAXBContextFactory - a JAXB Context factory
  - getNodeIdFactory
```
public NodeIdFactory getNodeIdFactory()
```
    Description copied from interface: CamelContext
    
    Gets the node id factory
    
    Specified by:
    
    getNodeIdFactory in interface CamelContext
    
    Returns:
    
    the node id factory
  - setNodeIdFactory
```
public void setNodeIdFactory(NodeIdFactory idFactory)
```
    Description copied from interface: CamelContext
    
    Uses a custom node id factory when generating auto assigned ids to the nodes in the route definitions
    
    Specified by:
    
    setNodeIdFactory in interface CamelContext
    
    Parameters:
    
    idFactory - custom factory to use
  - getManagementStrategy
```
public ManagementStrategy getManagementStrategy()
```
    Description copied from interface: CamelContext
    
    Gets the management strategy
    
    Specified by:
    
    getManagementStrategy in interface CamelContext
    
    Returns:
    
    the management strategy
  - setManagementStrategy
```
public void setManagementStrategy(ManagementStrategy managementStrategy)
```
    Description copied from interface: CamelContext
    
    Sets the management strategy to use
    
    Specified by:
    
    setManagementStrategy in interface CamelContext
    
    Parameters:
    
    managementStrategy - the management strategy
  - getDefaultTracer
```
public InterceptStrategy getDefaultTracer()
```
    Description copied from interface: CamelContext
    
    Gets the default tracer
    
    Specified by:
    
    getDefaultTracer in interface CamelContext
    
    Returns:
    
    the default tracer
  - setDefaultTracer
```
public void setDefaultTracer(InterceptStrategy tracer)
```
    Description copied from interface: CamelContext
    
    Sets a custom tracer to be used as the default tracer.
    Note: This must be set before any routes are created, changing the default tracer for existing routes is not supported.
    
    Specified by:
    
    setDefaultTracer in interface CamelContext
    
    Parameters:
    
    tracer - the custom tracer to use as default tracer
  - getDefaultBacklogTracer
```
public InterceptStrategy getDefaultBacklogTracer()
```
    Description copied from interface: CamelContext
    
    Gets the default backlog tracer
    
    Specified by:
    
    getDefaultBacklogTracer in interface CamelContext
    
    Returns:
    
    the default backlog tracer
  - setDefaultBacklogTracer
```
public void setDefaultBacklogTracer(InterceptStrategy backlogTracer)
```
    Description copied from interface: CamelContext
    
    Sets a custom backlog tracer to be used as the default backlog tracer.
    Note: This must be set before any routes are created, changing the default backlog tracer for existing routes is not supported.
    
    Specified by:
    
    setDefaultBacklogTracer in interface CamelContext
    
    Parameters:
    
    backlogTracer - the custom tracer to use as default backlog tracer
  - getDefaultBacklogDebugger
```
public InterceptStrategy getDefaultBacklogDebugger()
```
    Description copied from interface: CamelContext
    
    Gets the default backlog debugger
    
    Specified by:
    
    getDefaultBacklogDebugger in interface CamelContext
    
    Returns:
    
    the default backlog debugger
  - setDefaultBacklogDebugger
```
public void setDefaultBacklogDebugger(InterceptStrategy defaultBacklogDebugger)
```
    Description copied from interface: CamelContext
    
    Sets a custom backlog debugger to be used as the default backlog debugger.
    Note: This must be set before any routes are created, changing the default backlog debugger for existing routes is not supported.
    
    Specified by:
    
    setDefaultBacklogDebugger in interface CamelContext
    
    Parameters:
    
    defaultBacklogDebugger - the custom debugger to use as default backlog debugger
  - disableJMX
```
public void disableJMX()
```
    Description copied from interface: CamelContext
    
    Disables using JMX as ManagementStrategy.
    Important: This method must be called before the CamelContext is started.
    
    Specified by:
    
    disableJMX in interface CamelContext
  - getInflightRepository
```
public InflightRepository getInflightRepository()
```
    Description copied from interface: CamelContext
    
    Gets the inflight repository
    
    Specified by:
    
    getInflightRepository in interface CamelContext
    
    Returns:
    
    the repository
  - setInflightRepository
```
public void setInflightRepository(InflightRepository repository)
```
    Description copied from interface: CamelContext
    
    Sets a custom inflight repository to use
    
    Specified by:
    
    setInflightRepository in interface CamelContext
    
    Parameters:
    
    repository - the repository
  - getAsyncProcessorAwaitManager
```
public AsyncProcessorAwaitManager getAsyncProcessorAwaitManager()
```
    Description copied from interface: CamelContext
    
    Gets the AsyncProcessor await manager.
    
    Specified by:
    
    getAsyncProcessorAwaitManager in interface CamelContext
    
    Returns:
    
    the manager
  - setAsyncProcessorAwaitManager
```
public void setAsyncProcessorAwaitManager(AsyncProcessorAwaitManager asyncProcessorAwaitManager)
```
    Description copied from interface: CamelContext
    
    Sets a custom AsyncProcessor await manager.
    
    Specified by:
    
    setAsyncProcessorAwaitManager in interface CamelContext
    
    Parameters:
    
    asyncProcessorAwaitManager - the manager
  - setAutoStartup
```
public void setAutoStartup(Boolean autoStartup)
```
    Description copied from interface: RuntimeConfiguration
    
    Sets whether the object should automatically start when Camel starts.
    Important: Currently only routes can be disabled, as CamelContexts are always started.
    Note: When setting auto startup false on CamelContext then that takes precedence and no routes is started. You would need to start CamelContext explicit using the CamelContext.start() method, to start the context, and then you would need to start the routes manually using CamelContext.startRoute(String).
    Default is true to always start up.
    
    Specified by:
    
    setAutoStartup in interface RuntimeConfiguration
    
    Parameters:
    
    autoStartup - whether to start up automatically.
  - isAutoStartup
```
public Boolean isAutoStartup()
```
    Description copied from interface: RuntimeConfiguration
    
    Gets whether the object should automatically start when Camel starts.
    Important: Currently only routes can be disabled, as CamelContexts are always started.
    Default is true to always start up.
    
    Specified by:
    
    isAutoStartup in interface RuntimeConfiguration
    
    Returns:
    
    true if object should automatically start
  - isLazyLoadTypeConverters
```
@Deprecated
public Boolean isLazyLoadTypeConverters()
```
    Deprecated.
    
    Description copied from interface: CamelContext
    
    Whether or not type converters should be loaded lazy
    
    Specified by:
    
    isLazyLoadTypeConverters in interface CamelContext
    
    Returns:
    
    true to load lazy, false to load on startup
  - setLazyLoadTypeConverters
```
@Deprecated
public void setLazyLoadTypeConverters(Boolean lazyLoadTypeConverters)
```
    Deprecated.
    
    Description copied from interface: CamelContext
    
    Sets whether type converters should be loaded lazy
    
    Specified by:
    
    setLazyLoadTypeConverters in interface CamelContext
    
    Parameters:
    
    lazyLoadTypeConverters - true to load lazy, false to load on startup
  - isLoadTypeConverters
```
public Boolean isLoadTypeConverters()
```
    Description copied from interface: CamelContext
    
    Sets whether to load custom type converters by scanning classpath. This can be turned off if you are only using Camel components that does not provide type converters which is needed at runtime. In such situations setting this option to false, can speedup starting Camel.
    
    Specified by:
    
    isLoadTypeConverters in interface CamelContext
  - setLoadTypeConverters
```
public void setLoadTypeConverters(Boolean loadTypeConverters)
```
    Description copied from interface: CamelContext
    
    Sets whether to load custom type converters by scanning classpath. This can be turned off if you are only using Camel components that does not provide type converters which is needed at runtime. In such situations setting this option to false, can speedup starting Camel.
    
    Specified by:
    
    setLoadTypeConverters in interface CamelContext
    
    Parameters:
    
    loadTypeConverters - whether to load custom type converters.
  - isTypeConverterStatisticsEnabled
```
public Boolean isTypeConverterStatisticsEnabled()
```
    Description copied from interface: CamelContext
    
    Whether or not type converter statistics is enabled.
    By default the type converter utilization statistics is disabled. Notice: If enabled then there is a slight performance impact under very heavy load.
    
    Specified by:
    
    isTypeConverterStatisticsEnabled in interface CamelContext
    
    Returns:
    
    true if enabled, false if disabled (default).
  - setTypeConverterStatisticsEnabled
```
public void setTypeConverterStatisticsEnabled(Boolean typeConverterStatisticsEnabled)
```
    Description copied from interface: CamelContext
    
    Sets whether or not type converter statistics is enabled.
    By default the type converter utilization statistics is disabled. Notice: If enabled then there is a slight performance impact under very heavy load.
    You can enable/disable the statistics at runtime using the org.apache.camel.spi.TypeConverterRegistry#getStatistics()#setTypeConverterStatisticsEnabled(Boolean) method, or from JMX on the ManagedTypeConverterRegistryMBean mbean.
    
    Specified by:
    
    setTypeConverterStatisticsEnabled in interface CamelContext
    
    Parameters:
    
    typeConverterStatisticsEnabled - true to enable, false to disable
  - isUseMDCLogging
```
public Boolean isUseMDCLogging()
```
    Description copied from interface: CamelContext
    
    Whether or not MDC logging is being enabled.
    
    Specified by:
    
    isUseMDCLogging in interface CamelContext
    
    Returns:
    
    true if MDC logging is enabled
  - setUseMDCLogging
```
public void setUseMDCLogging(Boolean useMDCLogging)
```
    Description copied from interface: CamelContext
    
    Set whether MDC is enabled.
    
    Specified by:
    
    setUseMDCLogging in interface CamelContext
    
    Parameters:
    
    useMDCLogging - true to enable MDC logging, false to disable
  - isUseDataType
```
public Boolean isUseDataType()
```
    Description copied from interface: CamelContext
    
    Whether to enable using data type on Camel messages.
    Data type are automatic turned on if one ore more routes has been explicit configured with input and output types. Otherwise data type is default off.
    
    Specified by:
    
    isUseDataType in interface CamelContext
    
    Returns:
    
    true if data type is enabled
  - setUseDataType
```
public void setUseDataType(Boolean useDataType)
```
    Description copied from interface: CamelContext
    
    Whether to enable using data type on Camel messages.
    Data type are automatic turned on if one ore more routes has been explicit configured with input and output types. Otherwise data type is default off.
    
    Specified by:
    
    setUseDataType in interface CamelContext
    
    Parameters:
    
    useDataType - true to enable data type on Camel messages.
  - isUseBreadcrumb
```
public Boolean isUseBreadcrumb()
```
    Description copied from interface: CamelContext
    
    Whether or not breadcrumb is enabled.
    
    Specified by:
    
    isUseBreadcrumb in interface CamelContext
    
    Returns:
    
    true if breadcrumb is enabled
  - setUseBreadcrumb
```
public void setUseBreadcrumb(Boolean useBreadcrumb)
```
    Description copied from interface: CamelContext
    
    Set whether breadcrumb is enabled.
    
    Specified by:
    
    setUseBreadcrumb in interface CamelContext
    
    Parameters:
    
    useBreadcrumb - true to enable breadcrumb, false to disable
  - getApplicationContextClassLoader
```
public ClassLoader getApplicationContextClassLoader()
```
    Description copied from interface: CamelContext
    
    Gets the application CamelContext class loader which may be helpful for running camel in other containers
    
    Specified by:
    
    getApplicationContextClassLoader in interface CamelContext
    
    Returns:
    
    the application CamelContext class loader
  - setApplicationContextClassLoader
```
public void setApplicationContextClassLoader(ClassLoader classLoader)
```
    Description copied from interface: CamelContext
    
    Sets the application CamelContext class loader
    
    Specified by:
    
    setApplicationContextClassLoader in interface CamelContext
    
    Parameters:
    
    classLoader - the class loader
  - getDataFormatResolver
```
public DataFormatResolver getDataFormatResolver()
```
    Description copied from interface: CamelContext
    
    Gets the current data format resolver
    
    Specified by:
    
    getDataFormatResolver in interface CamelContext
    
    Returns:
    
    the resolver
  - setDataFormatResolver
```
public void setDataFormatResolver(DataFormatResolver dataFormatResolver)
```
    Description copied from interface: CamelContext
    
    Sets a custom data format resolver
    
    Specified by:
    
    setDataFormatResolver in interface CamelContext
    
    Parameters:
    
    dataFormatResolver - the resolver
  - resolveDataFormat
```
public DataFormat resolveDataFormat(String name)
```
    Description copied from interface: CamelContext
    
    Resolve a data format given its name
    
    Specified by:
    
    resolveDataFormat in interface CamelContext
    
    Parameters:
    
    name - the data format name or a reference to it in the Registry
    
    Returns:
    
    the resolved data format, or null if not found
  - createDataFormat
```
public DataFormat createDataFormat(String name)
```
    Description copied from interface: CamelContext
    
    Creates the given data format given its name.
    
    Specified by:
    
    createDataFormat in interface CamelContext
    
    Parameters:
    
    name - the data format name or a reference to a data format factory in the Registry
    
    Returns:
    
    the resolved data format, or null if not found
  - resolveDataFormatDefinition
```
public DataFormatDefinition resolveDataFormatDefinition(String name)
```
    Description copied from interface: ModelCamelContext
    
    Resolve a data format definition given its name
    
    Specified by:
    
    resolveDataFormatDefinition in interface CamelContext
    
    Specified by:
    
    resolveDataFormatDefinition in interface ModelCamelContext
    
    Parameters:
    
    name - the data format definition name or a reference to it in the Registry
    
    Returns:
    
    the resolved data format definition, or null if not found
  - lookupPropertiesComponent
```
@Deprecated
protected Component lookupPropertiesComponent()
```
    Deprecated. use CamelContextHelper.lookupPropertiesComponent(org.apache.camel.CamelContext, boolean)
  - getShutdownStrategy
```
public ShutdownStrategy getShutdownStrategy()
```
    Description copied from interface: CamelContext
    
    Gets the current shutdown strategy
    
    Specified by:
    
    getShutdownStrategy in interface CamelContext
    
    Returns:
    
    the strategy
  - setShutdownStrategy
```
public void setShutdownStrategy(ShutdownStrategy shutdownStrategy)
```
    Description copied from interface: CamelContext
    
    Sets a custom shutdown strategy
    
    Specified by:
    
    setShutdownStrategy in interface CamelContext
    
    Parameters:
    
    shutdownStrategy - the custom strategy
  - getShutdownRoute
```
public ShutdownRoute getShutdownRoute()
```
    Description copied from interface: RuntimeConfiguration
    
    Gets the option to use when shutting down the route.
    
    Specified by:
    
    getShutdownRoute in interface RuntimeConfiguration
    
    Returns:
    
    the option
  - setShutdownRoute
```
public void setShutdownRoute(ShutdownRoute shutdownRoute)
```
    Description copied from interface: RuntimeConfiguration
    
    Sets the ShutdownRoute option for routes.
    
    Specified by:
    
    setShutdownRoute in interface RuntimeConfiguration
    
    Parameters:
    
    shutdownRoute - the option to use.
  - getShutdownRunningTask
```
public ShutdownRunningTask getShutdownRunningTask()
```
    Description copied from interface: RuntimeConfiguration
    
    Gets the ShutdownRunningTask option in use when shutting down a route.
    
    Specified by:
    
    getShutdownRunningTask in interface RuntimeConfiguration
    
    Returns:
    
    the option
  - setShutdownRunningTask
```
public void setShutdownRunningTask(ShutdownRunningTask shutdownRunningTask)
```
    Description copied from interface: RuntimeConfiguration
    
    Sets the ShutdownRunningTask option to use when shutting down a route.
    
    Specified by:
    
    setShutdownRunningTask in interface RuntimeConfiguration
    
    Parameters:
    
    shutdownRunningTask - the option to use.
  - setAllowUseOriginalMessage
```
public void setAllowUseOriginalMessage(Boolean allowUseOriginalMessage)
```
    Description copied from interface: RuntimeConfiguration
    
    Sets whether to allow access to the original message from Camel's error handler, or from UnitOfWork.getOriginalInMessage().
    Turning this off can optimize performance, as defensive copy of the original message is not needed.
    
    Specified by:
    
    setAllowUseOriginalMessage in interface RuntimeConfiguration
    
    Parameters:
    
    allowUseOriginalMessage - the option to use.
  - isAllowUseOriginalMessage
```
public Boolean isAllowUseOriginalMessage()
```
    Description copied from interface: RuntimeConfiguration
    
    Gets whether access to the original message from Camel's error handler, or from UnitOfWork.getOriginalInMessage() is allowed.
    
    Specified by:
    
    isAllowUseOriginalMessage in interface RuntimeConfiguration
    
    Returns:
    
    the option
  - getExecutorServiceManager
```
public ExecutorServiceManager getExecutorServiceManager()
```
    Description copied from interface: CamelContext
    
    Gets the current ExecutorServiceManager
    
    Specified by:
    
    getExecutorServiceManager in interface CamelContext
    
    Returns:
    
    the manager
  - getExecutorServiceStrategy
```
@Deprecated
public ExecutorServiceStrategy getExecutorServiceStrategy()
```
    Deprecated.
    
    Description copied from interface: CamelContext
    
    Gets the current ExecutorServiceStrategy
    
    Specified by:
    
    getExecutorServiceStrategy in interface CamelContext
    
    Returns:
    
    the manager
  - setExecutorServiceManager
```
public void setExecutorServiceManager(ExecutorServiceManager executorServiceManager)
```
    Description copied from interface: CamelContext
    
    Sets a custom ExecutorServiceManager
    
    Specified by:
    
    setExecutorServiceManager in interface CamelContext
    
    Parameters:
    
    executorServiceManager - the custom manager
  - getProcessorFactory
```
public ProcessorFactory getProcessorFactory()
```
    Description copied from interface: CamelContext
    
    Gets the current ProcessorFactory
    
    Specified by:
    
    getProcessorFactory in interface CamelContext
    
    Returns:
    
    the factory, can be null if no custom factory has been set
  - setProcessorFactory
```
public void setProcessorFactory(ProcessorFactory processorFactory)
```
    Description copied from interface: CamelContext
    
    Sets a custom ProcessorFactory
    
    Specified by:
    
    setProcessorFactory in interface CamelContext
    
    Parameters:
    
    processorFactory - the custom factory
  - getMessageHistoryFactory
```
public MessageHistoryFactory getMessageHistoryFactory()
```
    Description copied from interface: CamelContext
    
    Gets the current MessageHistoryFactory
    
    Specified by:
    
    getMessageHistoryFactory in interface CamelContext
    
    Returns:
    
    the factory
  - setMessageHistoryFactory
```
public void setMessageHistoryFactory(MessageHistoryFactory messageHistoryFactory)
```
    Description copied from interface: CamelContext
    
    Sets a custom MessageHistoryFactory
    
    Specified by:
    
    setMessageHistoryFactory in interface CamelContext
    
    Parameters:
    
    messageHistoryFactory - the custom factory
  - getDebugger
```
public Debugger getDebugger()
```
    Description copied from interface: CamelContext
    
    Gets the current Debugger
    
    Specified by:
    
    getDebugger in interface CamelContext
    
    Returns:
    
    the debugger
  - setDebugger
```
public void setDebugger(Debugger debugger)
```
    Description copied from interface: CamelContext
    
    Sets a custom Debugger
    
    Specified by:
    
    setDebugger in interface CamelContext
    
    Parameters:
    
    debugger - the debugger
  - getUuidGenerator
```
public UuidGenerator getUuidGenerator()
```
    Description copied from interface: CamelContext
    
    Gets the current UuidGenerator
    
    Specified by:
    
    getUuidGenerator in interface CamelContext
    
    Returns:
    
    the uuidGenerator
  - setUuidGenerator
```
public void setUuidGenerator(UuidGenerator uuidGenerator)
```
    Description copied from interface: CamelContext
    
    Sets a custom UuidGenerator (should only be set once)
    
    Specified by:
    
    setUuidGenerator in interface CamelContext
    
    Parameters:
    
    uuidGenerator - the UUID Generator
  - getStreamCachingStrategy
```
public StreamCachingStrategy getStreamCachingStrategy()
```
    Description copied from interface: CamelContext
    
    Gets the StreamCachingStrategy to use.
    
    Specified by:
    
    getStreamCachingStrategy in interface CamelContext
  - setStreamCachingStrategy
```
public void setStreamCachingStrategy(StreamCachingStrategy streamCachingStrategy)
```
    Description copied from interface: CamelContext
    
    Sets a custom StreamCachingStrategy to use.
    
    Specified by:
    
    setStreamCachingStrategy in interface CamelContext
  - getRestRegistry
```
public RestRegistry getRestRegistry()
```
    Description copied from interface: CamelContext
    
    Gets the RestRegistry to use
    
    Specified by:
    
    getRestRegistry in interface CamelContext
  - setRestRegistry
```
public void setRestRegistry(RestRegistry restRegistry)
```
    Description copied from interface: CamelContext
    
    Sets a custom RestRegistry to use.
    
    Specified by:
    
    setRestRegistry in interface CamelContext
  - getProperty
```
@Deprecated
public String getProperty(String key)
```
    Deprecated.
    
    Specified by:
    
    getProperty in interface CamelContext
  - getGlobalOption
```
public String getGlobalOption(String key)
```
    Description copied from interface: CamelContext
    
    Gets the global option value that can be referenced in the camel context
    Important: This has nothing to do with property placeholders, and is just a plain set of key/value pairs which are used to configure global options on CamelContext, such as a maximum debug logging length etc. For property placeholders use CamelContext.resolvePropertyPlaceholders(String) method and see more details at the property placeholder documentation.
    
    Specified by:
    
    getGlobalOption in interface CamelContext
    
    Returns:
    
    the string value of the global option
  - getReloadStrategy
```
public ReloadStrategy getReloadStrategy()
```
    Description copied from interface: CamelContext
    
    Returns the ReloadStrategy if in use.
    
    Specified by:
    
    getReloadStrategy in interface CamelContext
    
    Returns:
    
    the strategy, or null if none has been configured.
  - setReloadStrategy
```
public void setReloadStrategy(ReloadStrategy reloadStrategy)
```
    Description copied from interface: CamelContext
    
    Sets a custom ReloadStrategy to be used
    
    Specified by:
    
    setReloadStrategy in interface CamelContext
  - setTransformers
```
public void setTransformers(List<TransformerDefinition> transformers)
```
    Description copied from interface: CamelContext
    
    Sets the transformers that can be referenced in the routes.
    
    Specified by:
    
    setTransformers in interface CamelContext
    
    Parameters:
    
    transformers - the transformers
  - getTransformers
```
public List<TransformerDefinition> getTransformers()
```
    Description copied from interface: CamelContext
    
    Gets the transformers that can be referenced in the routes.
    
    Specified by:
    
    getTransformers in interface CamelContext
    
    Returns:
    
    the transformers available
  - resolveTransformer
```
public Transformer resolveTransformer(String scheme)
```
    Description copied from interface: CamelContext
    
    Resolve a transformer given a scheme
    
    Specified by:
    
    resolveTransformer in interface CamelContext
    
    Parameters:
    
    scheme - data model name.
    
    Returns:
    
    the resolved transformer, or null if not found
  - resolveTransformer
```
public Transformer resolveTransformer(DataType from,
                                      DataType to)
```
    Description copied from interface: CamelContext
    
    Resolve a transformer given from/to data type.
    
    Specified by:
    
    resolveTransformer in interface CamelContext
    
    Parameters:
    
    from - from data type
    
    to - to data type
    
    Returns:
    
    the resolved transformer, or null if not found
  - getTransformerRegistry
```
public TransformerRegistry<TransformerKey> getTransformerRegistry()
```
    Description copied from interface: CamelContext
    
    Gets the TransformerRegistry
    
    Specified by:
    
    getTransformerRegistry in interface CamelContext
    
    Returns:
    
    the TransformerRegistry
  - setValidators
```
public void setValidators(List<ValidatorDefinition> validators)
```
    Description copied from interface: CamelContext
    
    Sets the validators that can be referenced in the routes.
    
    Specified by:
    
    setValidators in interface CamelContext
    
    Parameters:
    
    validators - the validators
  - getValidators
```
public List<ValidatorDefinition> getValidators()
```
    Description copied from interface: CamelContext
    
    Gets the validators that can be referenced in the routes.
    
    Specified by:
    
    getValidators in interface CamelContext
    
    Returns:
    
    the validators available
  - resolveValidator
```
public Validator resolveValidator(DataType type)
```
    Description copied from interface: CamelContext
    
    Resolve a validator given from/to data type.
    
    Specified by:
    
    resolveValidator in interface CamelContext
    
    Parameters:
    
    type - the data type
    
    Returns:
    
    the resolved validator, or null if not found
  - getValidatorRegistry
```
public ValidatorRegistry<ValidatorKey> getValidatorRegistry()
```
    Description copied from interface: CamelContext
    
    Gets the ValidatorRegistry
    
    Specified by:
    
    getValidatorRegistry in interface CamelContext
    
    Returns:
    
    the ValidatorRegistry
  - getRuntimeCamelCatalog
```
public RuntimeCamelCatalog getRuntimeCamelCatalog()
```
    Description copied from interface: CamelContext
    
    Gets the associated RuntimeCamelCatalog for this CamelContext.
    
    Specified by:
    
    getRuntimeCamelCatalog in interface CamelContext
  - setSSLContextParameters
```
public void setSSLContextParameters(SSLContextParameters sslContextParameters)
```
    Description copied from interface: CamelContext
    
    Sets the global SSL context parameters.
    
    Specified by:
    
    setSSLContextParameters in interface CamelContext
  - getSSLContextParameters
```
public SSLContextParameters getSSLContextParameters()
```
    Description copied from interface: CamelContext
    
    Gets the global SSL context parameters if configured.
    
    Specified by:
    
    getSSLContextParameters in interface CamelContext
  - getHeadersMapFactory
```
public HeadersMapFactory getHeadersMapFactory()
```
    Description copied from interface: CamelContext
    
    Gets the HeadersMapFactory to use.
    
    Specified by:
    
    getHeadersMapFactory in interface CamelContext
  - setHeadersMapFactory
```
public void setHeadersMapFactory(HeadersMapFactory headersMapFactory)
```
    Description copied from interface: CamelContext
    
    Sets a custom HeadersMapFactory to be used.
    
    Specified by:
    
    setHeadersMapFactory in interface CamelContext
  - getRouteServices
```
protected Map<String,RouteService> getRouteServices()
```
  - createManagementStrategy
```
protected ManagementStrategy createManagementStrategy()
```
  - setContextCounter
```
public static void setContextCounter(int value)
```
    Reset context counter to a preset value. Mostly used for tests to ensure a predictable getName()
    
    Parameters:
    
    value - new value for the context counter
  - createDefaultUuidGenerator
```
protected UuidGenerator createDefaultUuidGenerator()
```
  - createModelJAXBContextFactory
```
protected ModelJAXBContextFactory createModelJAXBContextFactory()
```
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - getHealthCheckRegistry
```
public HealthCheckRegistry getHealthCheckRegistry()
```
    Description copied from interface: CamelContext
    
    Returns an optional HealthCheckRegistry, by default no registry is present and it must be explicit activated. Components can register/unregister health checks in response to life-cycle events (i.e. start/stop). This registry is not used by the camel context but it is up to the impl to properly use it, i.e. - a RouteController could use the registry to decide to restart a route with failing health checks - spring boot could integrate such checks within its health endpoint or make it available only as separate endpoint.
    
    Specified by:
    
    getHealthCheckRegistry in interface CamelContext
  - setHealthCheckRegistry
```
public void setHealthCheckRegistry(HealthCheckRegistry healthCheckRegistry)
```
    Sets a HealthCheckRegistry.
    
    Specified by:
    
    setHealthCheckRegistry in interface CamelContext
  - createNodeIdFactory
```
protected NodeIdFactory createNodeIdFactory()
```
  - createFactoryFinderResolver
```
protected FactoryFinderResolver createFactoryFinderResolver()
```
  - createClassResolver
```
protected ClassResolver createClassResolver()
```
  - createProcessorFactory
```
protected ProcessorFactory createProcessorFactory()
```
  - createDataFormatResolver
```
protected DataFormatResolver createDataFormatResolver()
```
  - createMessageHistoryFactory
```
protected MessageHistoryFactory createMessageHistoryFactory()
```
  - createInflightRepository
```
protected InflightRepository createInflightRepository()
```
  - createAsyncProcessorAwaitManager
```
protected AsyncProcessorAwaitManager createAsyncProcessorAwaitManager()
```
  - createRouteController
```
protected RouteController createRouteController()
```
  - createHealthCheckRegistry
```
protected HealthCheckRegistry createHealthCheckRegistry()
```
  - createShutdownStrategy
```
protected ShutdownStrategy createShutdownStrategy()
```
  - createPackageScanClassResolver
```
protected PackageScanClassResolver createPackageScanClassResolver()
```
  - createExecutorServiceManager
```
protected ExecutorServiceManager createExecutorServiceManager()
```
  - createProducerServicePool
```
protected ServicePool<Endpoint,Producer> createProducerServicePool()
```
  - createPollingConsumerServicePool
```
protected ServicePool<Endpoint,PollingConsumer> createPollingConsumerServicePool()
```
  - createUnitOfWorkFactory
```
protected UnitOfWorkFactory createUnitOfWorkFactory()
```
  - createRuntimeCamelCatalog
```
protected RuntimeCamelCatalog createRuntimeCamelCatalog()
```
  - createCamelContextNameStrategy
```
protected CamelContextNameStrategy createCamelContextNameStrategy()
```
  - createManagementNameStrategy
```
protected ManagementNameStrategy createManagementNameStrategy()
```
  - createHeadersMapFactory
```
protected HeadersMapFactory createHeadersMapFactory()
```
  - createLanguageResolver
```
protected LanguageResolver createLanguageResolver()
```
  - createEndpointRegistry
```
protected EndpointRegistry<EndpointKey> createEndpointRegistry(Map<EndpointKey,Endpoint> endpoints)
```
  - createValidatorRegistry
```
protected ValidatorRegistry<ValidatorKey> createValidatorRegistry(List<ValidatorDefinition> validators)
                                                           throws Exception
```
    Throws:
    
    Exception
  - createTransformerRegistry
```
protected TransformerRegistry<TransformerKey> createTransformerRegistry(List<TransformerDefinition> transformers)
                                                                 throws Exception
```
    Throws:
    
    Exception

Class DefaultCamelContext

Field Summary

Fields inherited from class org.apache.camel.support.ServiceSupport

Constructor Summary

Method Summary

Methods inherited from class org.apache.camel.support.ServiceSupport

Methods inherited from class java.lang.Object

Methods inherited from interface org.apache.camel.CamelContext

Methods inherited from interface org.apache.camel.SuspendableService

Constructor Detail

DefaultCamelContext

DefaultCamelContext

DefaultCamelContext

Method Detail

adapt

isVetoStarted

getName

setName

getNameStrategy

setNameStrategy

getManagementNameStrategy

setManagementNameStrategy

getManagementName

setManagementName

hasComponent

addComponent

getComponent

getComponent

getComponent

getComponent

resolveComponent

removeComponent

getEndpointRegistry

getEndpoints

getEndpointMap

hasEndpoint

addEndpoint

removeEndpoint

removeEndpoints

getEndpoint

getEndpoint

addRegisterEndpointCallback

addEndpointToRegistry

normalizeEndpointUri

getEndpointKey

getEndpointKeyPreNormalized

getEndpointKey

setRouteController

getRouteController

getRouteStartupOrder

getRoutes

getRoute

getProcessor

getProcessor

getManagedProcessor

getManagedRoute

getManagedCamelContext

getProcessorDefinition

getProcessorDefinition

setRoutes

addRoutes

loadRoutesDefinition

loadRestsDefinition

addRouteDefinitions

addRouteDefinition

removeRouteDefinition

removeRouteDefinitions

removeRouteDefinition

getRouteStatus

startRoute

isStartingRoutes

isSetupRoutes

stopRoute

startAllRoutes

startRoute

resumeRoute

stopRoute

stopRoute

stopRoute

shutdownRoute