Package | Description |
---|---|
org.apache.camel |
The core Camel API.
|
org.apache.camel.spi |
Service Provider Interfaces used by the Camel runtime which are plugin strategies.
|
Modifier and Type | Interface and Description |
---|---|
interface |
AsyncProcessor
An asynchronous processor which can process an
Exchange in an asynchronous fashion
and signal completion by invoking the AsyncCallback . |
interface |
AsyncProducer
Asynchronous producer
|
interface |
Channel
Channel acts as a channel between
Processor s in the route graph. |
interface |
DelegateProcessor
Interface to be used for processors that delegate to the real processor
|
interface |
Producer
Provides a channel on which clients can create and invoke message exchanges
on an
Endpoint |
Modifier and Type | Method and Description |
---|---|
<T extends Processor> |
CamelContext.getProcessor(String id,
Class<T> type)
Gets the processor from any of the routes which with the given id
|
Modifier and Type | Method and Description |
---|---|
Processor |
ErrorHandlerFactory.createErrorHandler(RouteContext routeContext,
Processor processor)
Creates the error handler
|
Processor |
Channel.getErrorHandler()
Gets the
org.apache.camel.processor.ErrorHandler this Channel uses. |
Processor |
Channel.getNextProcessor()
Gets the next
Processor to route to (not wrapped) |
Processor |
Channel.getOutput()
Gets the wrapped output that at runtime should be delegated to.
|
Processor |
Route.getProcessor()
Gets the
Processor |
Processor |
DelegateProcessor.getProcessor()
Gets the delegated
Processor . |
Processor |
Consumer.getProcessor() |
Processor |
CamelContext.getProcessor(String id)
Gets the processor from any of the routes which with the given id
|
Modifier and Type | Method and Description |
---|---|
List<Processor> |
Route.filter(String pattern)
Returns a list of all the
Processor s from this route that has id's matching the pattern |
Navigate<Processor> |
Route.navigate()
Returns a navigator to navigate this route by navigating all the
Processor s. |
Modifier and Type | Method and Description |
---|---|
CompletableFuture<Exchange> |
ProducerTemplate.asyncCallback(Endpoint endpoint,
Processor processor,
Synchronization onCompletion)
Sends an asynchronous exchange to the given endpoint using a supplied processor.
|
CompletableFuture<Exchange> |
ProducerTemplate.asyncCallback(String endpointUri,
Processor processor,
Synchronization onCompletion)
Sends an asynchronous exchange to the given endpoint using a supplied processor.
|
CompletableFuture<Exchange> |
ProducerTemplate.asyncSend(Endpoint endpoint,
Processor processor)
Sends an asynchronous exchange to the given endpoint.
|
CompletableFuture<Exchange> |
ProducerTemplate.asyncSend(String endpointUri,
Processor processor)
Sends an asynchronous exchange to the given endpoint.
|
Consumer |
Endpoint.createConsumer(Processor processor)
Creates a new Event
Driven Consumer which consumes messages from the endpoint using the
given processor
|
Processor |
ErrorHandlerFactory.createErrorHandler(RouteContext routeContext,
Processor processor)
Creates the error handler
|
Exchange |
ProducerTemplate.request(Endpoint endpoint,
Processor processor)
Sends an exchange to an endpoint using a supplied processor
Uses an
ExchangePattern.InOut message exchange pattern. |
Exchange |
ProducerTemplate.request(String endpointUri,
Processor processor)
Sends an exchange to an endpoint using a supplied processor
Uses an
ExchangePattern.InOut message exchange pattern. |
Exchange |
ProducerTemplate.send(Endpoint endpoint,
ExchangePattern pattern,
Processor processor)
Sends an exchange to an endpoint using a supplied processor
Notice: that if the processing of the exchange failed with an Exception it is not thrown from this method, but you can access it from the returned exchange using Exchange.getException() . |
Exchange |
ProducerTemplate.send(Endpoint endpoint,
ExchangePattern pattern,
Processor processor,
Processor resultProcessor)
Sends an exchange to an endpoint using a supplied processor
Notice: that if the processing of the exchange failed with an Exception it is not thrown from this method, but you can access it from the returned exchange using Exchange.getException() . |
Exchange |
ProducerTemplate.send(Endpoint endpoint,
Processor processor)
Sends an exchange to an endpoint using a supplied processor
Notice: that if the processing of the exchange failed with an Exception it is not thrown from this method, but you can access it from the returned exchange using Exchange.getException() . |
Exchange |
ProducerTemplate.send(Processor processor)
Sends an exchange to the default endpoint using a supplied processor
Notice: that if the processing of the exchange failed with an Exception it is not thrown from this method, but you can access it from the returned exchange using Exchange.getException() . |
Exchange |
ProducerTemplate.send(String endpointUri,
ExchangePattern pattern,
Processor processor)
Sends an exchange to an endpoint using a supplied processor
Notice: that if the processing of the exchange failed with an Exception it is not thrown from this method, but you can access it from the returned exchange using Exchange.getException() . |
Exchange |
ProducerTemplate.send(String endpointUri,
Processor processor)
Sends an exchange to an endpoint using a supplied processor
Notice: that if the processing of the exchange failed with an Exception it is not thrown from this method, but you can access it from the returned exchange using Exchange.getException() . |
FluentProducerTemplate |
FluentProducerTemplate.withProcessor(Processor processor)
Set the processor to use for send/request.
|
Modifier and Type | Method and Description |
---|---|
AsyncProcessor |
ExtendedCamelContext.createMulticast(Collection<Processor> processors,
ExecutorService executor,
boolean shutdownExecutorService)
Creates a new multicast processor which sends an exchange to all the processors.
|
FluentProducerTemplate |
FluentProducerTemplate.withProcessor(Supplier<Processor> processorSupplier)
Set the processorSupplier which will be invoke to get the processor to be
used for send/request.
|
Modifier and Type | Interface and Description |
---|---|
static interface |
ManagementInterceptStrategy.InstrumentationProcessor<T> |
Modifier and Type | Method and Description |
---|---|
Processor |
RestApiProcessorFactory.createApiProcessor(CamelContext camelContext,
String contextPath,
String contextIdPattern,
boolean contextIdListing,
RestConfiguration configuration,
Map<String,Object> parameters)
Creates a new REST API Processor
, which provides API listing of the REST services
|
Processor |
BeanProcessorFactory.createBeanProcessor(CamelContext camelContext,
Object bean,
Method method)
Creates the bean processor from the existing bean instance
|
Processor |
BeanProcessorFactory.createBeanProcessor(CamelContext camelContext,
Object bean,
String beanType,
Class<?> beanClass,
String ref,
String method,
boolean cacheBean)
Creates the bean processor from a given set of parameters that can refer
to the bean via an existing bean, a reference to a bean, or its class name etc.
|
Processor |
ProcessorFactory.createChildProcessor(RouteContext routeContext,
NamedNode definition,
boolean mandatory)
Creates the child processor.
|
Processor |
SendDynamicAware.createPostProcessor(Exchange exchange,
SendDynamicAware.DynamicAwareEntry entry)
Creates an optional post
Processor that will be executed afterwards
when the message has been sent dynamic. |
Processor |
SendDynamicAware.createPreProcessor(Exchange exchange,
SendDynamicAware.DynamicAwareEntry entry)
|
Processor |
ProcessorFactory.createProcessor(CamelContext camelContext,
String definitionName,
Map<String,Object> args)
Creates a processor by the name of the definition.
|
Processor |
ProcessorFactory.createProcessor(RouteContext routeContext,
NamedNode definition)
Creates the processor.
|
Processor |
InterceptSendToEndpoint.getDetour()
The processor for routing in a detour
|
Processor |
CamelEvent.ExchangeFailureEvent.getFailureHandler() |
Processor |
RouteContext.getOnCompletion(String onCompletionId) |
Processor |
RouteContext.getOnException(String onExceptionId) |
Processor |
Policy.wrap(RouteContext routeContext,
Processor processor)
Wraps any applicable interceptors around the given processor.
|
Processor |
InterceptStrategy.wrapProcessorInInterceptors(CamelContext context,
NamedNode definition,
Processor target,
Processor nextTarget)
This method is invoked by
org.apache.camel.model.ProcessorDefinition#wrapProcessor(RouteContext, Processor)
to give the implementor an opportunity to wrap the target processor
in a route. |
Modifier and Type | Method and Description |
---|---|
void |
RouteContext.addEventDrivenProcessor(Processor processor)
Adds an event driven processor
|
void |
Breakpoint.afterProcess(Exchange exchange,
Processor processor,
NamedNode definition,
long timeTaken)
Callback invoked when the breakpoint was hit and the
Exchange has been processed (after). |
boolean |
Debugger.afterProcess(Exchange exchange,
Processor processor,
NamedNode definition,
long timeTaken)
Callback invoked when an
Exchange has been processed which allows implementators
to notify breakpoints. |
void |
UnitOfWork.afterProcess(Processor processor,
Exchange exchange,
AsyncCallback callback,
boolean doneSync)
Strategy for optional work to be executed after the processing
|
CompletableFuture<Exchange> |
ProducerCache.asyncSendExchange(Endpoint endpoint,
ExchangePattern pattern,
Processor processor,
Processor resultProcessor,
Exchange exchange,
CompletableFuture<Exchange> future)
Asynchronously sends an exchange to an endpoint using a supplied
Processor to populate the exchange |
void |
Breakpoint.beforeProcess(Exchange exchange,
Processor processor,
NamedNode definition)
Callback invoked when the breakpoint was hit and the
Exchange is about to be processed (before). |
boolean |
Debugger.beforeProcess(Exchange exchange,
Processor processor,
NamedNode definition)
Callback invoked when an
Exchange is about to be processed which allows implementators
to notify breakpoints. |
AsyncCallback |
UnitOfWork.beforeProcess(Processor processor,
Exchange exchange,
AsyncCallback callback)
Strategy for optional work to be execute before processing
For example the
org.apache.camel.impl.MDCUnitOfWork leverages this
to ensure MDC is handled correctly during routing exchanges using the
asynchronous routing engine. |
Consumer |
RestApiConsumerFactory.createApiConsumer(CamelContext camelContext,
Processor processor,
String contextPath,
RestConfiguration configuration,
Map<String,Object> parameters)
Creates a new REST API Event
Driven Consumer, which provides API listing of the REST services
|
Consumer |
RestConsumerFactory.createConsumer(CamelContext camelContext,
Processor processor,
String verb,
String basePath,
String uriTemplate,
String consumes,
String produces,
RestConfiguration configuration,
Map<String,Object> parameters)
Creates a new REST Event
Driven Consumer, which consumes messages from the endpoint using the given processor
|
CamelEvent |
EventFactory.createExchangeFailureHandledEvent(Exchange exchange,
Processor failureHandler,
boolean deadLetterChannel,
String deadLetterUri)
Creates an
CamelEvent when an Exchange has failed
but was handled by the Camel error handlers such as an dead letter channel, or a doTry .. |
CamelEvent |
EventFactory.createExchangeFailureHandlingEvent(Exchange exchange,
Processor failureHandler,
boolean deadLetterChannel,
String deadLetterUri)
Creates an
CamelEvent when an Exchange has failed
but is being handled by the Camel error handlers such as an dead letter channel, or a doTry .. |
ManagementInterceptStrategy.InstrumentationProcessor<?> |
ManagementInterceptStrategy.createProcessor(NamedNode definition,
Processor target) |
Object |
ManagementObjectStrategy.getManagedObjectForErrorHandler(CamelContext context,
RouteContext routeContext,
Processor errorHandler,
ErrorHandlerFactory errorHandlerBuilder) |
Object |
ManagementObjectStrategy.getManagedObjectForProcessor(CamelContext context,
Processor processor,
NamedNode definition,
Route route) |
ObjectName |
ManagementObjectNameStrategy.getObjectNameForErrorHandler(RouteContext routeContext,
Processor errorHandler,
ErrorHandlerFactory builder) |
ObjectName |
ManagementObjectNameStrategy.getObjectNameForProcessor(CamelContext context,
Processor processor,
NamedNode definition) |
ObjectName |
ManagementObjectNameStrategy.getObjectNameForStep(CamelContext context,
Processor processor,
NamedNode definition) |
boolean |
Condition.matchProcess(Exchange exchange,
Processor processor,
NamedNode definition)
Does the condition match
|
void |
LifecycleStrategy.onErrorHandlerAdd(RouteContext routeContext,
Processor errorHandler,
ErrorHandlerFactory errorHandlerBuilder)
Notification on adding error handler.
|
void |
LifecycleStrategy.onErrorHandlerRemove(RouteContext routeContext,
Processor errorHandler,
ErrorHandlerFactory errorHandlerBuilder)
Notification on removing error handler.
|
Exchange |
ProducerCache.send(Endpoint endpoint,
Exchange exchange,
Processor resultProcessor)
Sends the exchange to the given endpoint.
|
void |
RouteContext.setOnCompletion(String onCompletionId,
Processor processor) |
void |
RouteContext.setOnException(String onExceptionId,
Processor processor) |
void |
ManagementInterceptStrategy.InstrumentationProcessor.setProcessor(Processor processor) |
Processor |
Policy.wrap(RouteContext routeContext,
Processor processor)
Wraps any applicable interceptors around the given processor.
|
Processor |
InterceptStrategy.wrapProcessorInInterceptors(CamelContext context,
NamedNode definition,
Processor target,
Processor nextTarget)
This method is invoked by
org.apache.camel.model.ProcessorDefinition#wrapProcessor(RouteContext, Processor)
to give the implementor an opportunity to wrap the target processor
in a route. |
Apache Camel