Uses of Interface
org.apache.camel.Processor

Packages that use Processor

Package	Description
org.apache.camel	The core Camel API.
org.apache.camel.spi

Uses of Processor in org.apache.camel

Subinterfaces of Processor in org.apache.camel

Modifier and Type	Interface	Description
interface	AsyncProcessor	An asynchronous processor which can process an Exchange in an asynchronous fashion and signal completion by invoking the AsyncCallback.
interface	AsyncProducer	A Producer that can dispatch an Exchange to an Endpoint without blocking the calling thread.
interface	Channel	Channel acts as a channel between Processors in the route graph.
interface	DelegateProcessor	A Processor that wraps another Processor and delegates Exchange processing to it, following the Decorator pattern.
interface	Producer	A service that sends Exchanges to an Endpoint.

Subinterfaces with type arguments of type Processor in org.apache.camel

Modifier and Type	Interface	Description
interface	Channel	Channel acts as a channel between Processors in the route graph.

Methods in org.apache.camel with type parameters of type Processor

Modifier and Type	Method	Description
<T extends Processor> @Nullable T	CamelContext.getProcessor(String id, Class<T> type)	Gets the processor from any of the routes which with the given id

Methods in org.apache.camel that return Processor

Modifier and Type	Method	Description
Processor	ExtendedCamelContext.createErrorHandler(Route route, Processor processor)	Internal API for creating error handler.
@Nullable Processor	Channel.getErrorHandler()	Gets the ErrorHandler this Channel uses.
Processor	Channel.getNextProcessor()	Gets the next Processor to route to (not wrapped)
@Nullable Processor	Route.getOnException(String onExceptionId)	Gets the on exception processor for the given id.
Processor	Channel.getOutput()	Gets the wrapped output that at runtime should be delegated to.
@Nullable Processor	CamelContext.getProcessor(String id)	Gets the processor from any of the routes which with the given id
Processor	Consumer.getProcessor()	The processor that will process the Exchange that was consumed.
@Nullable Processor	DelegateProcessor.getProcessor()	Gets the delegated Processor.
Processor	Route.getProcessor()	Gets the Processor

Methods in org.apache.camel that return types with arguments of type Processor

Modifier and Type	Method	Description
List<Processor>	Route.filter(String pattern)	Returns a list of all the Processors 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()	Gets the on completion processors.
Collection<Processor>	Route.getOnExceptions()	Gets the on exception processors.
@Nullable Navigate<Processor>	Route.navigate()	Returns a navigator to navigate this route by navigating all the Processors.

Methods in org.apache.camel with parameters of type Processor

Modifier and Type	Method	Description
CompletableFuture<Exchange>	ProducerTemplate.asyncSend(String endpointUri, Processor processor)	Sends an asynchronous exchange to the given endpoint.
CompletableFuture<Exchange>	ProducerTemplate.asyncSend(Endpoint endpoint, 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 Important: Do not do any initialization in the constructor of the Consumer.
Processor	ExtendedCamelContext.createErrorHandler(Route route, Processor processor)	Internal API for creating error handler.
void	Channel.initChannel(Route route, NamedNode definition, @Nullable NamedNode childDefinition, List<InterceptStrategy> interceptors, Processor nextProcessor, @Nullable NamedRoute routeDefinition, boolean first)	Initializes the channel.
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.request(Endpoint endpoint, Processor processor)	Sends an exchange to an endpoint using a supplied processor Uses an ExchangePattern.InOut message exchange pattern.
Exchange	ProducerTemplate.send(String endpointUri, ExchangePattern pattern, Processor processor)	Sends an exchange to an endpoint using a supplied processor
Exchange	ProducerTemplate.send(String endpointUri, Processor processor)	Sends an exchange to an endpoint using a supplied processor
Exchange	ProducerTemplate.send(Endpoint endpoint, ExchangePattern pattern, Processor processor)	Sends an exchange to an endpoint using a supplied processor
Exchange	ProducerTemplate.send(Endpoint endpoint, ExchangePattern pattern, Processor processor, Processor resultProcessor)	Sends an exchange to an endpoint using a supplied processor
Exchange	ProducerTemplate.send(Endpoint endpoint, Processor processor)	Sends an exchange to an endpoint using a supplied processor
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().
void	Channel.setErrorHandler(Processor errorHandler)	Sets the ErrorHandler this Channel uses.
void	Route.setOnCompletion(String onCompletionId, Processor processor)	Sets an on completion processor.
void	Route.setOnException(String onExceptionId, Processor processor)	Sets an on exception processor.
void	Route.setProcessor(Processor processor)	Sets the Processor
FluentProducerTemplate	FluentProducerTemplate.withProcessor(Processor processor)	Set the processor to use for send/request.

Method parameters in org.apache.camel with type arguments of type Processor

Modifier and Type	Method	Description
FluentProducerTemplate	FluentProducerTemplate.withProcessor(Supplier<Processor> processorSupplier)	Set the processorSupplier which will be invoke to get the processor to be used for send/request.

Uses of Processor in org.apache.camel.spi

Subinterfaces of Processor in org.apache.camel.spi

Modifier and Type	Interface	Description
interface	ErrorHandler	Marker interface identifying a Processor as an error-handling wrapper, as described in the Error Handler documentation.
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 ... and more.
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 ... and more.

Methods in org.apache.camel.spi that return Processor

Modifier and Type	Method	Description
Processor	RestApiProcessorFactory.createApiProcessor(CamelContext camelContext, String contextPath, 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, @Nullable Object bean, @Nullable String beanType, @Nullable Class<?> beanClass, @Nullable String ref, @Nullable 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	BeanProcessorFactory.createBeanProcessor(CamelContext camelContext, Object bean, Method method)	Creates the bean processor from the existing bean instance
@Nullable Processor	ProcessorFactory.createChildProcessor(Route route, NamedNode definition, boolean mandatory)	Creates the child processor.
Processor	ModelReifierFactory.createErrorHandler(Route route, ErrorHandlerFactory errorHandlerFactory, Processor processor)	Creates the error handler using the factory for the route processor.
Processor	ModelReifierFactory.createErrorHandler(Route route, Processor processor)	Creates the error handler for the route processor.
@Nullable 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.
@Nullable Processor	SendDynamicAware.createPreProcessor(Exchange exchange, SendDynamicAware.DynamicAwareEntry entry)	Creates the pre Processor that will prepare the Exchange with dynamic details from the given recipient.
@Nullable Processor	ProcessorFactory.createProcessor(CamelContext camelContext, String definitionName, Object[] args)	Creates a processor by the name of the definition.
@Nullable Processor	ProcessorFactory.createProcessor(Route route, NamedNode definition)	Creates the processor.
@Nullable Processor	InterceptSendToEndpoint.getAfter()	The processor (optional) for routing after sending to the original endpoint.
@Nullable Processor	InterceptSendToEndpoint.getBefore()	The processor for routing in a detour before sending to the original endpoint.
@Nullable Processor	ErrorHandlerAware.getErrorHandler()	Gets the error handler
Processor	CamelEvent.ExchangeFailureEvent.getFailureHandler()	Returns the processor that handled the failure.
Processor	ErrorHandlerRedeliveryCustomizer.getOutput()	Returns the output processor
Processor	ProcessorExchangeFactory.getProcessor()	The processor using this factory.
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, @Nullable Processor nextTarget)	Give implementor an opportunity to wrap the target processor in a route.

Methods in org.apache.camel.spi with parameters of type Processor

Modifier and Type	Method	Description
InternalProcessor	InternalProcessorFactory.addUnitOfWorkProcessorAdvice(CamelContext camelContext, Processor processor, Route route)
void	BacklogDebugger.afterProcess(Exchange exchange, Processor processor, NamedNode definition, long timeTaken)	Callback invoked after a breakpoint
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
CompletableFuture<Exchange>	ProducerCache.asyncSendExchange(Endpoint endpoint, ExchangePattern pattern, Processor processor, @Nullable Processor resultProcessor, @Nullable Exchange exchange, @Nullable CompletableFuture<Exchange> future)	Asynchronously sends an exchange to an endpoint using a supplied Processor to populate the exchange
@Nullable org.apache.camel.util.StopWatch	BacklogDebugger.beforeProcess(Exchange exchange, Processor processor, NamedNode definition)	Callback invoked before hitting a breakpoint
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 executed 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, @Nullable String uriTemplate, @Nullable String consumes, @Nullable 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
Consumer	RestOpenApiConsumerFactory.createConsumer(CamelContext camelContext, Processor processor, String contextPath, 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)	Creates the error handler using the factory for the route processor.
Processor	ModelReifierFactory.createErrorHandler(Route route, Processor processor)	Creates the error handler for the route processor.
CamelEvent	EventFactory.createExchangeFailureHandledEvent(Exchange exchange, Processor failureHandler, boolean deadLetterChannel, @Nullable 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 .. doCatch block.
CamelEvent	EventFactory.createExchangeFailureHandlingEvent(Exchange exchange, Processor failureHandler, boolean deadLetterChannel, @Nullable 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 .. doCatch block.
InterceptSendToEndpoint	InterceptEndpointFactory.createInterceptSendToEndpoint(CamelContext camelContext, Endpoint endpoint, boolean skip, @Nullable Predicate onWhen, @Nullable Processor before, @Nullable Processor after)	Creates an endpoint when intercepting sending to an endpoint (detour).
@Nullable 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, boolean before)	Does the condition match
ProcessorExchangeFactory	ProcessorExchangeFactory.newProcessorExchangeFactory(Processor processor)	Creates a new ProcessorExchangeFactory that is private for the given consumer.
boolean	SharedInternalProcessor.process(Exchange exchange, AsyncCallback originalCallback, AsyncProcessor processor, @Nullable Processor resultProcessor)	Asynchronous API
void	SharedInternalProcessor.process(Exchange exchange, AsyncProcessor processor, @Nullable Processor resultProcessor)	Synchronous API
Exchange	ProducerCache.send(Endpoint endpoint, Exchange exchange, @Nullable Processor resultProcessor)	Sends the exchange to the given endpoint.
void	InterceptSendToEndpoint.setAfter(@Nullable Processor after)	Sets the processor (optional) for routing after sending to the original endpoint.
void	InterceptSendToEndpoint.setBefore(@Nullable 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, @Nullable Processor nextTarget)	Give implementor an opportunity to wrap the target processor in a route.