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 |
ExtendedCamelContext.createErrorHandler(Route route,
Processor processor)
Internal API for creating error handler.
|
Processor |
Channel.getErrorHandler()
Gets the
ErrorHandler this Channel uses. |
Processor |
Channel.getNextProcessor()
Gets the next
Processor to route to (not wrapped) |
Processor |
Route.getOnException(String onExceptionId) |
Processor |
Channel.getOutput()
Gets the wrapped output that at runtime should be delegated to.
|
Processor |
Route.getProcessor()
Gets the
Processor |
Processor |
Consumer.getProcessor() |
Processor |
DelegateProcessor.getProcessor()
Gets the delegated
Processor . |
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 |
List<Processor> |
Route.getEventDrivenProcessors()
This method retrieves the event driven Processors on this route context.
|
Collection<Processor> |
Route.getOnCompletions() |
Collection<Processor> |
Route.getOnExceptions() |
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 |
ExtendedCamelContext.createErrorHandler(Route route,
Processor processor)
Internal API for creating error handler.
|
void |
Channel.initChannel(Route route,
NamedNode definition,
NamedNode childDefinition,
List<InterceptStrategy> interceptors,
Processor nextProcessor,
NamedRoute routeDefinition,
boolean first)
Initializes the channel.
|
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() . |
void |
Channel.setErrorHandler(Processor errorHandler)
Sets the
ErrorHandler this Channel uses. |
void |
Route.setOnCompletion(String onCompletionId,
Processor processor) |
void |
Route.setOnException(String onExceptionId,
Processor processor) |
void |
Route.setProcessor(Processor processor)
Sets the
Processor |
FluentProducerTemplate |
FluentProducerTemplate.withProcessor(Processor processor)
Set the processor to use for send/request.
|
Modifier and Type | Method and Description |
---|---|
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 |
---|---|
interface |
ErrorHandler
An interface used to represent an error handler
|
interface |
InternalProcessor
Internal
Processor that Camel routing engine used during routing for cross cutting functionality such as:
Execute UnitOfWork
Keeping track which route currently is being routed
Execute RoutePolicy
Gather JMX performance statics
Tracing
Debugging
Message History
Stream Caching
Transformer
... |
static interface |
ManagementInterceptStrategy.InstrumentationProcessor<T> |
interface |
SharedInternalProcessor
A Shared (thread safe) internal
Processor that Camel routing engine used during routing for cross cutting
functionality such as:
Execute UnitOfWork
Keeping track which route currently is being routed
Execute RoutePolicy
Gather JMX performance statics
Tracing
Debugging
Message History
Stream Caching
Transformer
... |
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,
BeanScope scope)
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(Route route,
NamedNode definition,
boolean mandatory)
Creates the child processor.
|
Processor |
ModelReifierFactory.createErrorHandler(Route route,
ErrorHandlerFactory errorHandlerFactory,
Processor processor) |
Processor |
ModelReifierFactory.createErrorHandler(Route route,
Processor 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,
Object[] args)
Creates a processor by the name of the definition.
|
Processor |
ProcessorFactory.createProcessor(Route route,
NamedNode definition)
Creates the processor.
|
Processor |
InterceptSendToEndpoint.getAfter()
The processor (optional) for routing after sending to the original endpoint.
|
Processor |
InterceptSendToEndpoint.getBefore()
The processor for routing in a detour before sending to the original endpoint.
|
Processor |
ErrorHandlerAware.getErrorHandler()
Gets the error handler
|
Processor |
CamelEvent.ExchangeFailureEvent.getFailureHandler() |
Processor |
ErrorHandlerRedeliveryCustomizer.getOutput()
Returns the output processor
|
Processor |
WrapAwareProcessor.getWrapped()
Gets the wrapped
Processor |
Processor |
Policy.wrap(Route route,
Processor processor)
Wraps any applicable interceptors around the given processor.
|
Processor |
InterceptStrategy.wrapProcessorInInterceptors(CamelContext context,
NamedNode definition,
Processor target,
Processor nextTarget)
Give implementor an opportunity to wrap the target processor in a route.
|
Modifier and Type | Method and Description |
---|---|
InternalProcessor |
InternalProcessorFactory.addChildUnitOfWorkProcessorAdvice(CamelContext camelContext,
Processor processor,
Route route,
UnitOfWork parent) |
InternalProcessor |
InternalProcessorFactory.addUnitOfWorkProcessorAdvice(CamelContext camelContext,
Processor processor,
Route route) |
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 work to be executed after the processing
This requires
UnitOfWork.isBeforeAfterProcess() returns true to be enabled. |
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 work to be execute before processing.
|
void |
ErrorHandlerRedeliveryCustomizer.changeOutput(Processor output)
Allows to change the output of the error handler which are used when optimising the JMX instrumentation to use
either an advice or wrapped processor when calling a processor.
|
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
|
Processor |
ModelReifierFactory.createErrorHandler(Route route,
ErrorHandlerFactory errorHandlerFactory,
Processor processor) |
Processor |
ModelReifierFactory.createErrorHandler(Route route,
Processor 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 .. |
Endpoint |
InterceptEndpointFactory.createInterceptSendToEndpoint(CamelContext camelContext,
Endpoint endpoint,
boolean skip,
Processor before,
Processor after)
Creates an endpoint when intercepting sending to an endpoint (detour).
|
ManagementInterceptStrategy.InstrumentationProcessor<?> |
ManagementInterceptStrategy.createProcessor(NamedNode definition,
Processor target) |
AsyncProcessor |
InternalProcessorFactory.createWrapProcessor(Processor processor,
Processor wrapped) |
Object |
ManagementObjectStrategy.getManagedObjectForProcessor(CamelContext context,
Processor processor,
NamedNode definition,
Route route) |
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
|
boolean |
SharedInternalProcessor.process(Exchange exchange,
AsyncCallback originalCallback,
AsyncProcessor processor,
Processor resultProcessor)
Asynchronous API
|
void |
SharedInternalProcessor.process(Exchange exchange,
AsyncProcessor processor,
Processor resultProcessor)
Synchronous API
|
Exchange |
ProducerCache.send(Endpoint endpoint,
Exchange exchange,
Processor resultProcessor)
Sends the exchange to the given endpoint.
|
void |
InterceptSendToEndpoint.setAfter(Processor after)
Sets the processor (optional) for routing after sending to the original endpoint.
|
void |
InterceptSendToEndpoint.setBefore(Processor before)
Sets the processor for routing in a detour before sending to the original endpoint.
|
void |
ErrorHandlerAware.setErrorHandler(Processor errorHandler)
Sets the error handler
|
void |
ManagementInterceptStrategy.InstrumentationProcessor.setProcessor(Processor processor) |
Processor |
Policy.wrap(Route route,
Processor processor)
Wraps any applicable interceptors around the given processor.
|
Processor |
InterceptStrategy.wrapProcessorInInterceptors(CamelContext context,
NamedNode definition,
Processor target,
Processor nextTarget)
Give implementor an opportunity to wrap the target processor in a route.
|
Apache Camel