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 |
Route.createErrorHandler(Processor processor) |
Processor |
ExtendedCamelContext.createErrorHandler(Route route,
Processor processor)
Internal API for creating 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 |
Route.getOnCompletion(String onCompletionId) |
Processor |
Route.getOnException(String onExceptionId) |
Processor |
Channel.getOutput()
Gets the wrapped output that at runtime should be delegated to.
|
Processor |
DelegateProcessor.getProcessor()
Gets the delegated
Processor . |
Processor |
Consumer.getProcessor() |
Processor |
Route.getProcessor()
Gets the
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 |
Route.createErrorHandler(Processor processor) |
Processor |
ExtendedCamelContext.createErrorHandler(Route route,
Processor processor)
Internal API for creating 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() . |
void |
Route.setOnCompletion(String onCompletionId,
Processor processor) |
void |
Route.setOnException(String onExceptionId,
Processor processor) |
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,
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 |
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(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 |
CamelEvent.ExchangeFailureEvent.getFailureHandler() |
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 |
---|---|
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 |
Breakpoint.afterProcess(Exchange exchange,
Processor processor,
NamedNode definition,
long timeTaken)
Callback invoked when the breakpoint was hit and the
Exchange has been processed (after). |
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 |
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. |
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). |
AsyncCallback |
UnitOfWork.beforeProcess(Processor processor,
Exchange exchange,
AsyncCallback callback)
Strategy for work to be execute before processing.
|
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,
Route route,
Processor errorHandler,
ErrorHandlerFactory errorHandlerBuilder) |
Object |
ManagementObjectStrategy.getManagedObjectForProcessor(CamelContext context,
Processor processor,
NamedNode definition,
Route route) |
ObjectName |
ManagementObjectNameStrategy.getObjectNameForErrorHandler(Route route,
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(Route route,
Processor errorHandler,
ErrorHandlerFactory errorHandlerBuilder)
Notification on adding error handler.
|
void |
LifecycleStrategy.onErrorHandlerRemove(Route route,
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 |
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