Uses of Interface
org.apache.camel.Processor

Packages that use Processor

org.apache.camel	The JAXB POJOs for the XML Configuration of the routing rules.
org.apache.camel.builder	The Camel Domain Specific Language for creating Routes, Predicates, Expressions and Error Handlers.
org.apache.camel.builder.xml	Support for XPath based Expressions and Predicates as well as an XSLT processor
org.apache.camel.component.bean	The Bean Component which will look up the bean name in the Spring ApplicationContext and use that to dispatch messages to a POJO
org.apache.camel.component.browse	The Browse Component which is a simple in memory component which maintains a list of all message exchanges which can be useful for debugging, tooling or visualistion.
org.apache.camel.component.dataset	A DataSet Endpoint for testing of endpoints using defined DataSets
org.apache.camel.component.direct	The Direct Component which synchronously invokes all the consumers when a producer sends an exchange to the endpoint.
org.apache.camel.component.file	The File Component for working with file systems.
org.apache.camel.component.language	The Language Component to send messages to language endpoints executing the script.
org.apache.camel.component.log	The Log Component uses Jakarta Commons Logging to log message exchanges.
org.apache.camel.component.mock	The Mock Component which is used for testing of routing and mediation rules.
org.apache.camel.component.seda	The SEDA Component for asynchronous SEDA exchanges on a BlockingQueue within a single CamelContext
org.apache.camel.component.timer	The Timer Component extends the POJO component to provide a simple timer
org.apache.camel.converter	A set of helper classes for converting from different types of Java object to be used by the Type Conversion Support
org.apache.camel.impl	Default implementation classes for Camel Core
org.apache.camel.impl.converter	Default implementation classes the Type Conversion Strategies
org.apache.camel.management	Camel management
org.apache.camel.management.event	Camel management events
org.apache.camel.management.mbean	Camel management JMX Mbeans
org.apache.camel.model	The JAXB POJOs for the XML Configuration of the routing rules.
org.apache.camel.model.loadbalancer	The Load Balancer EIP pattern
org.apache.camel.processor	A collection of Processor implementations which are used to implement the Enterprise Integration Patterns
org.apache.camel.processor.aggregate	Helper classes for the Aggregator pattern.
org.apache.camel.processor.idempotent	An implementation of the Idempotent Consumer pattern.
org.apache.camel.processor.interceptor	Helper classes for interceptors.
org.apache.camel.processor.loadbalancer	Various load balancer processors
org.apache.camel.processor.validation	Performs XML validation using JAXP for validating against XSD or RelaxNG
org.apache.camel.spi	Service Provider Interfaces used internally by the Camel runtime which are plugin strategies.
org.apache.camel.util	Utility classes used by the core of Camel.

Uses of Processor in org.apache.camel

Subinterfaces of Processor in org.apache.camel

interface	AsyncProcessor An asynchronous processor which can process an Exchange in an asynchronous fashion and signal completion by invoking the AsyncCallback.
interface	Channel Channel acts as a channel between Processors in the route graph.
interface	Producer Provides a channel on which clients can create and invoke message exchanges on an Endpoint

Methods in org.apache.camel that return Processor

Processor	Channel.getErrorHandler() Gets the 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	RouteNode.getProcessor() Gets the actual processor this node represents.

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

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

Future<Exchange>	ProducerTemplate.asyncCallback(Endpoint endpoint, Processor processor, Synchronization onCompletion) Sends an asynchronous exchange to the given endpoint using a supplied processor.
Future<Exchange>	ProducerTemplate.asyncCallback(String endpointUri, Processor processor, Synchronization onCompletion) Sends an asynchronous exchange to the given endpoint using a supplied processor.
Future<Exchange>	ProducerTemplate.asyncSend(Endpoint endpoint, Processor processor) Sends an asynchronous exchange to the given endpoint.
Future<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
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, 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	Channel.setNextProcessor(Processor next) Sets the processor that the channel should route the Exchange to.
void	Channel.setOutput(Processor output) Sets the wrapped output that at runtime should be delegated to.

Uses of Processor in org.apache.camel.builder

Fields in org.apache.camel.builder declared as Processor

protected Processor	DefaultErrorHandlerBuilder.failureProcessor
protected Processor	DefaultErrorHandlerBuilder.onRedelivery

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

Processor	NoErrorHandlerBuilder.createErrorHandler(RouteContext routeContext, Processor processor)
Processor	LoggingErrorHandlerBuilder.createErrorHandler(RouteContext routeContext, Processor processor)
Processor	ErrorHandlerBuilderRef.createErrorHandler(RouteContext routeContext, Processor processor)
Processor	ErrorHandlerBuilder.createErrorHandler(RouteContext routeContext, Processor processor) Creates the error handler interceptor
Processor	DefaultErrorHandlerBuilder.createErrorHandler(RouteContext routeContext, Processor processor)
Processor	DeadLetterChannelBuilder.createErrorHandler(RouteContext routeContext, Processor processor)
Processor	DefaultErrorHandlerBuilder.getFailureProcessor()
Processor	DeadLetterChannelBuilder.getFailureProcessor()
Processor	DefaultErrorHandlerBuilder.getOnRedelivery()
static Processor	ProcessorBuilder.removeFaultHeader(String name) Deprecated. will be removed in the near future. Instead use ProcessorBuilder.removeHeader(String)
static Processor	ProcessorBuilder.removeHeader(String name) Removes the header on the IN message
static Processor	ProcessorBuilder.removeHeaders(String pattern) Removes the headers on the IN message
static Processor	ProcessorBuilder.removeHeaders(String pattern, String... exceptionPatterns) Removes all headers on the IN message, except for the ones provided in the names parameter
static Processor	ProcessorBuilder.removeProperty(String name) Removes the property on the exchange
static Processor	ProcessorBuilder.setBody(Expression expression) Creates a processor which sets the body of the IN message to the value of the expression
static Processor	ProcessorBuilder.setFaultBody(Expression expression) Creates a processor which sets the body of the FAULT message to the value of the expression
static Processor	ProcessorBuilder.setFaultHeader(String name, Expression expression) Sets the header on the FAULT message
static Processor	ProcessorBuilder.setHeader(String name, Expression expression) Sets the header on the IN message
static Processor	ProcessorBuilder.setOutBody(Expression expression) Creates a processor which sets the body of the OUT message to the value of the expression
static Processor	ProcessorBuilder.setOutHeader(String name, Expression expression) Sets the header on the OUT message
static Processor	ProcessorBuilder.setProperty(String name, Expression expression) Sets the property on the exchange
static Processor	ProcessorBuilder.throwException(Exception ex) Throws an exception

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

Processor	NoErrorHandlerBuilder.createErrorHandler(RouteContext routeContext, Processor processor)
Processor	LoggingErrorHandlerBuilder.createErrorHandler(RouteContext routeContext, Processor processor)
Processor	ErrorHandlerBuilderRef.createErrorHandler(RouteContext routeContext, Processor processor)
Processor	ErrorHandlerBuilder.createErrorHandler(RouteContext routeContext, Processor processor) Creates the error handler interceptor
Processor	DefaultErrorHandlerBuilder.createErrorHandler(RouteContext routeContext, Processor processor)
Processor	DeadLetterChannelBuilder.createErrorHandler(RouteContext routeContext, Processor processor)
DefaultErrorHandlerBuilder	DefaultErrorHandlerBuilder.onRedelivery(Processor processor) Sets a processor that should be processed before a redelivery attempt.
void	DefaultErrorHandlerBuilder.setFailureProcessor(Processor failureProcessor)
void	DefaultErrorHandlerBuilder.setOnRedelivery(Processor onRedelivery)

Uses of Processor in org.apache.camel.builder.xml

Classes in org.apache.camel.builder.xml that implement Processor

class

XsltBuilder Creates a Processor which performs an XSLT transformation of the IN message body.

Uses of Processor in org.apache.camel.component.bean

Classes in org.apache.camel.component.bean that implement Processor

class

BeanProcessor A Processor which converts the inbound exchange to a method invocation on a POJO

Methods in org.apache.camel.component.bean that return Processor

protected Processor	BeanEndpoint.createProcessor()
Processor	RegistryBean.getProcessor()
Processor	ConstantTypeBeanHolder.getProcessor()
Processor	ConstantBeanHolder.getProcessor()
protected Processor	BeanProcessor.getProcessor()
Processor	BeanHolder.getProcessor()

Uses of Processor in org.apache.camel.component.browse

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

Consumer

BrowseEndpoint.createConsumer(Processor processor)

Uses of Processor in org.apache.camel.component.dataset

Methods in org.apache.camel.component.dataset that return Processor

Processor

DataSetSupport.getOutputTransformer()

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

Consumer	DataSetEndpoint.createConsumer(Processor processor)
void	DataSetSupport.setOutputTransformer(Processor outputTransformer)
void	DataSetEndpoint.setReporter(Processor reporter) Sets a custom progress reporter

Constructors in org.apache.camel.component.dataset with parameters of type Processor

DataSetConsumer(DataSetEndpoint endpoint, Processor processor)

Uses of Processor in org.apache.camel.component.direct

Classes in org.apache.camel.component.direct that implement Processor

class

DirectProducer The direct producer.

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

Consumer

DirectEndpoint.createConsumer(Processor processor)

Constructors in org.apache.camel.component.direct with parameters of type Processor

DirectConsumer(Endpoint endpoint, Processor processor)

Uses of Processor in org.apache.camel.component.file

Classes in org.apache.camel.component.file that implement Processor

class

GenericFileProducer<T> Generic file producer

Fields in org.apache.camel.component.file declared as Processor

protected Processor

GenericFileConsumer.customProcessor

Methods in org.apache.camel.component.file that return Processor

Processor

GenericFileConsumer.getCustomProcessor()

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

abstract GenericFileConsumer<T>	GenericFileEndpoint.createConsumer(Processor processor)
FileConsumer	FileEndpoint.createConsumer(Processor processor)
protected void	GenericFileConsumer.customProcessExchange(Exchange exchange, Processor processor) Processes the exchange using a custom processor.
void	GenericFileConsumer.setCustomProcessor(Processor processor) Use a custom processor to process the exchange.

Constructors in org.apache.camel.component.file with parameters of type Processor

FileConsumer(GenericFileEndpoint<File> endpoint, Processor processor, GenericFileOperations<File> operations)

GenericFileConsumer(GenericFileEndpoint<T> endpoint, Processor processor, GenericFileOperations<T> operations)

Uses of Processor in org.apache.camel.component.language

Classes in org.apache.camel.component.language that implement Processor

class

LanguageProducer Language producer.

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

Consumer

LanguageEndpoint.createConsumer(Processor processor)

Uses of Processor in org.apache.camel.component.log

Classes in org.apache.camel.component.log that implement Processor

class

LogProducer Log producer.

Uses of Processor in org.apache.camel.component.mock

Methods in org.apache.camel.component.mock that return Processor

Processor

MockEndpoint.getReporter()

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

Consumer	MockEndpoint.createConsumer(Processor processor)
void	MockEndpoint.setReporter(Processor reporter) Allows a processor to added to the endpoint to report on progress of the test
void	MockEndpoint.whenAnyExchangeReceived(Processor processor) Set the processor that will be invoked when the some message is received.
void	MockEndpoint.whenExchangeReceived(int index, Processor processor) Set the processor that will be invoked when the index message is received.

Uses of Processor in org.apache.camel.component.seda

Classes in org.apache.camel.component.seda that implement Processor

class	CollectionProducer Deprecated. will be removed in a future Camel release
class	SedaProducer

Methods in org.apache.camel.component.seda that return Processor

Processor

SedaConsumer.getProcessor()

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

Consumer

SedaEndpoint.createConsumer(Processor processor)

Constructors in org.apache.camel.component.seda with parameters of type Processor

SedaConsumer(SedaEndpoint endpoint, Processor processor)

Uses of Processor in org.apache.camel.component.timer

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

Consumer

TimerEndpoint.createConsumer(Processor processor)

Constructors in org.apache.camel.component.timer with parameters of type Processor

TimerConsumer(TimerEndpoint endpoint, Processor processor)

Uses of Processor in org.apache.camel.converter

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

Processor	CamelConverter.toProcessor(Expression expresion)
Processor	CamelConverter.toProcessor(Predicate predicate)

Uses of Processor in org.apache.camel.impl

Classes in org.apache.camel.impl that implement Processor

class	DefaultAsyncProducer A default implementation of Producer for implementation inheritance, which can process Exchanges asynchronously.
class	DefaultProducer A default implementation of Producer for implementation inheritance.
class	EventDrivenPollingConsumer A default implementation of the PollingConsumer which uses the normal asynchronous consumer mechanism along with a BlockingQueue to allow the caller to pull messages on demand.
class	SynchronousDelegateProducer To process the delegated producer in synchronous mode.

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

protected Processor	DefaultProducerTemplate.createBodyAndHeaderProcessor(Object body, String header, Object headerValue)
protected Processor	DefaultProducerTemplate.createBodyAndPropertyProcessor(Object body, String property, Object propertyValue)
protected Processor	CamelPostProcessorHelper.createConsumerProcessor(Object pojo, Method method, Endpoint endpoint) Create a processor which invokes the given method when an incoming message exchange is received
protected Processor	ProcessorEndpoint.createProcessor()
Processor	DefaultRouteContext.createProcessor(ProcessorDefinition<?> node)
protected Processor	DefaultProducerTemplate.createSetBodyProcessor(Object body)
Processor	ProcessorEndpoint.getProcessor()
Processor	OnExceptionRouteNode.getProcessor()
Processor	OnCompletionRouteNode.getProcessor()
Processor	EventDrivenConsumerRoute.getProcessor()
Processor	DoFinallyRouteNode.getProcessor()
Processor	DoCatchRouteNode.getProcessor()
Processor	DefaultRouteNode.getProcessor()
Processor	DefaultConsumer.getProcessor()
Processor	AggregateRouteNode.getProcessor()

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

Navigate<Processor>

EventDrivenConsumerRoute.navigate()

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

void	DefaultRouteContext.addEventDrivenProcessor(Processor processor)
boolean	DefaultDebugger.afterProcess(Exchange exchange, Processor processor, ProcessorDefinition definition, long timeTaken)
void	BreakpointSupport.afterProcess(Exchange exchange, Processor processor, ProcessorDefinition definition, long timeTaken)
void	MDCUnitOfWork.afterProcess(Processor processor, Exchange exchange, AsyncCallback callback, boolean doneSync)
void	DefaultUnitOfWork.afterProcess(Processor processor, Exchange exchange, AsyncCallback callback, boolean doneSync)
Future<Exchange>	DefaultProducerTemplate.asyncCallback(Endpoint endpoint, Processor processor, Synchronization onCompletion)
Future<Exchange>	DefaultProducerTemplate.asyncCallback(String uri, Processor processor, Synchronization onCompletion)
Future<Exchange>	DefaultProducerTemplate.asyncSend(Endpoint endpoint, Processor processor)
Future<Exchange>	DefaultProducerTemplate.asyncSend(String uri, Processor processor)
boolean	DefaultDebugger.beforeProcess(Exchange exchange, Processor processor, ProcessorDefinition definition)
void	BreakpointSupport.beforeProcess(Exchange exchange, Processor processor, ProcessorDefinition definition)
AsyncCallback	MDCUnitOfWork.beforeProcess(Processor processor, Exchange exchange, AsyncCallback callback)
AsyncCallback	DefaultUnitOfWork.beforeProcess(Processor processor, Exchange exchange, AsyncCallback callback)
Consumer	InterceptSendToEndpoint.createConsumer(Processor processor)
Consumer	DefaultPollingEndpoint.createConsumer(Processor processor)
boolean	ConditionSupport.matchProcess(Exchange exchange, Processor processor, ProcessorDefinition definition)
protected void	DefaultDebugger.onAfterProcess(Exchange exchange, Processor processor, ProcessorDefinition definition, long timeTaken, Breakpoint breakpoint)
protected void	DefaultDebugger.onBeforeProcess(Exchange exchange, Processor processor, ProcessorDefinition definition, Breakpoint breakpoint)
Exchange	DefaultProducerTemplate.request(Endpoint endpoint, Processor processor)
Exchange	DefaultProducerTemplate.request(String endpoint, Processor processor)
Exchange	ProducerCache.send(Endpoint endpoint, ExchangePattern pattern, Processor processor) Sends an exchange to an endpoint using a supplied Processor to populate the exchange
Exchange	DefaultProducerTemplate.send(Endpoint endpoint, ExchangePattern pattern, Processor processor)
Exchange	ProducerCache.send(Endpoint endpoint, Processor processor) Sends an exchange to an endpoint using a supplied Processor to populate the exchange
Exchange	DefaultProducerTemplate.send(Endpoint endpoint, Processor processor)
Exchange	DefaultProducerTemplate.send(Processor processor)
Exchange	DefaultProducerTemplate.send(String endpointUri, ExchangePattern pattern, Processor processor)
Exchange	DefaultProducerTemplate.send(String endpointUri, Processor processor)
protected Exchange	ProducerCache.sendExchange(Endpoint endpoint, ExchangePattern pattern, Processor processor, Exchange exchange)
void	InterceptSendToEndpoint.setDetour(Processor detour)
void	ProcessorEndpoint.setProcessor(Processor processor)

Constructors in org.apache.camel.impl with parameters of type Processor

DefaultConsumer(Endpoint endpoint, Processor processor)

DefaultRouteNode(ProcessorDefinition<?> processorDefinition, Processor processor)

DefaultScheduledPollConsumer(DefaultEndpoint defaultEndpoint, Processor processor)

DefaultScheduledPollConsumer(Endpoint endpoint, Processor processor, ScheduledExecutorService executor)

EventDrivenConsumerRoute(RouteContext routeContext, Endpoint endpoint, Processor processor)

ProcessorEndpoint(String endpointUri, CamelContext context, Processor processor)

ProcessorEndpoint(String endpointUri, Component component, Processor processor)

ProcessorEndpoint(String endpointUri, Processor processor)

ProcessorPollingConsumer(Endpoint endpoint, Processor processor)

ScheduledPollConsumer(Endpoint endpoint, Processor processor)

ScheduledPollConsumer(Endpoint endpoint, Processor processor, ScheduledExecutorService executor)

Uses of Processor in org.apache.camel.impl.converter

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

static AsyncProcessor

AsyncProcessorTypeConverter.convert(Processor value)

Uses of Processor in org.apache.camel.management

Classes in org.apache.camel.management that implement Processor

class

InstrumentationProcessor JMX enabled processor that uses the ManagedCounter for instrumenting processing of exchanges.

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

Processor

InstrumentationInterceptStrategy.wrapProcessorInInterceptors(CamelContext context, ProcessorDefinition definition, Processor target, Processor nextTarget)

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

EventObject	DefaultEventFactory.createExchangeFailureHandledEvent(Exchange exchange, Processor failureHandler, boolean deadLetterChannel)
Object	DefaultManagementObjectStrategy.getManagedObjectForErrorHandler(CamelContext context, RouteContext routeContext, Processor errorHandler, ErrorHandlerBuilder errorHandlerBuilder)
Object	DefaultManagementObjectStrategy.getManagedObjectForProcessor(CamelContext context, Processor processor, ProcessorDefinition definition, Route route)
ObjectName	DefaultManagementNamingStrategy.getObjectNameForErrorHandler(RouteContext routeContext, Processor errorHandler, ErrorHandlerBuilder builder)
ObjectName	DefaultManagementNamingStrategy.getObjectNameForProcessor(CamelContext context, Processor processor, ProcessorDefinition<?> definition)
void	DefaultManagementLifecycleStrategy.onErrorHandlerAdd(RouteContext routeContext, Processor errorHandler, ErrorHandlerBuilder errorHandlerBuilder)
Processor	InstrumentationInterceptStrategy.wrapProcessorInInterceptors(CamelContext context, ProcessorDefinition definition, Processor target, Processor nextTarget)

Constructor parameters in org.apache.camel.management with type arguments of type Processor

InstrumentationInterceptStrategy(Map<ProcessorDefinition,PerformanceCounter> registeredCounters, Map<Processor,KeyValueHolder<ProcessorDefinition,InstrumentationProcessor>> wrappedProcessors)

Uses of Processor in org.apache.camel.management.event

Methods in org.apache.camel.management.event that return Processor

Processor

ExchangeFailureHandledEvent.getFailureHandler()

Constructors in org.apache.camel.management.event with parameters of type Processor

ExchangeFailureHandledEvent(Exchange source, Processor failureHandler, boolean deadLetterChannel)

Uses of Processor in org.apache.camel.management.mbean

Methods in org.apache.camel.management.mbean that return Processor

Processor	ManagedErrorHandler.getErrorHandler()
Processor	ManagedProcessor.getProcessor()

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

void	JMXNotificationTraceEventHandler.traceExchange(ProcessorDefinition node, Processor target, TraceInterceptor traceInterceptor, Exchange exchange)
Object	JMXNotificationTraceEventHandler.traceExchangeIn(ProcessorDefinition node, Processor target, TraceInterceptor traceInterceptor, Exchange exchange)
void	JMXNotificationTraceEventHandler.traceExchangeOut(ProcessorDefinition node, Processor target, TraceInterceptor traceInterceptor, Exchange exchange, Object traceState)

Constructors in org.apache.camel.management.mbean with parameters of type Processor

ManagedErrorHandler(RouteContext routeContext, Processor errorHandler, ErrorHandlerBuilder builder)

ManagedProcessor(CamelContext context, Processor processor, ProcessorDefinition<?> definition)

Uses of Processor in org.apache.camel.model

Classes in org.apache.camel.model that implement Processor

class

LoadBalancerDefinition Represents an XML <loadBalancer/> element

Fields in org.apache.camel.model declared as Processor

protected Processor

InterceptDefinition.output

Fields in org.apache.camel.model with type parameters of type Processor

protected List<Processor>

InterceptDefinition.intercepted

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

Processor	ProcessorDefinition.createChildProcessor(RouteContext routeContext, boolean mandatory) Creates the child processor (outputs) from the current definition
protected Processor	ProcessorDefinition.createCompositeProcessor(RouteContext routeContext, List<Processor> list) Creates a new instance of some kind of composite processor which defaults to using a Pipeline but derived classes could change the behaviour
protected Processor	MulticastDefinition.createCompositeProcessor(RouteContext routeContext, List<Processor> list)
Processor	ProcessorDefinition.createOutputsProcessor(RouteContext routeContext) Prefer to use {#link #createChildProcessor}.
protected Processor	ProcessorDefinition.createOutputsProcessor(RouteContext routeContext, Collection<ProcessorDefinition> outputs)
protected Processor	LoadBalanceDefinition.createOutputsProcessor(RouteContext routeContext, Collection<ProcessorDefinition> outputs)
Processor	WireTapDefinition.createProcessor(RouteContext routeContext)
Processor	UnmarshalDefinition.createProcessor(RouteContext routeContext)
Processor	TryDefinition.createProcessor(RouteContext routeContext)
Processor	TransformDefinition.createProcessor(RouteContext routeContext)
Processor	TransactedDefinition.createProcessor(RouteContext routeContext)
Processor	ThrowExceptionDefinition.createProcessor(RouteContext routeContext)
Processor	ThrottleDefinition.createProcessor(RouteContext routeContext)
Processor	ThreadsDefinition.createProcessor(RouteContext routeContext)
Processor	StopDefinition.createProcessor(RouteContext routeContext)
Processor	SplitDefinition.createProcessor(RouteContext routeContext)
Processor	SortDefinition.createProcessor(RouteContext routeContext)
Processor	SetPropertyDefinition.createProcessor(RouteContext routeContext)
Processor	SetOutHeaderDefinition.createProcessor(RouteContext routeContext)
Processor	SetHeaderDefinition.createProcessor(RouteContext routeContext)
Processor	SetFaultBodyDefinition.createProcessor(RouteContext routeContext)
Processor	SetExchangePatternDefinition.createProcessor(RouteContext routeContext)
Processor	SetBodyDefinition.createProcessor(RouteContext routeContext)
Processor	SendDefinition.createProcessor(RouteContext routeContext)
Processor	SamplingDefinition.createProcessor(RouteContext routeContext)
Processor	RoutingSlipDefinition.createProcessor(RouteContext routeContext)
Processor	RollbackDefinition.createProcessor(RouteContext routeContext)
Processor	ResequenceDefinition.createProcessor(RouteContext routeContext)
Processor	RemovePropertyDefinition.createProcessor(RouteContext routeContext)
Processor	RemoveHeadersDefinition.createProcessor(RouteContext routeContext)
Processor	RemoveHeaderDefinition.createProcessor(RouteContext routeContext)
Processor	RecipientListDefinition.createProcessor(RouteContext routeContext)
Processor	ProcessorDefinition.createProcessor(RouteContext routeContext) Override this in definition class and implement logic to create the processor based on the definition model.
Processor	ProcessDefinition.createProcessor(RouteContext routeContext)
Processor	PollEnrichDefinition.createProcessor(RouteContext routeContext)
Processor	PolicyDefinition.createProcessor(RouteContext routeContext)
Processor	PipelineDefinition.createProcessor(RouteContext routeContext)
Processor	OtherwiseDefinition.createProcessor(RouteContext routeContext)
Processor	OnCompletionDefinition.createProcessor(RouteContext routeContext)
Processor	MulticastDefinition.createProcessor(RouteContext routeContext)
Processor	MarshalDefinition.createProcessor(RouteContext routeContext)
Processor	LoopDefinition.createProcessor(RouteContext routeContext)
Processor	LogDefinition.createProcessor(RouteContext routeContext)
Processor	LoadBalanceDefinition.createProcessor(RouteContext routeContext)
Processor	InterceptSendToEndpointDefinition.createProcessor(RouteContext routeContext)
Processor	InterceptFromDefinition.createProcessor(RouteContext routeContext)
Processor	InterceptDefinition.createProcessor(RouteContext routeContext)
Processor	IdempotentConsumerDefinition.createProcessor(RouteContext routeContext)
Processor	FinallyDefinition.createProcessor(RouteContext routeContext)
Processor	EnrichDefinition.createProcessor(RouteContext routeContext)
Processor	DynamicRouterDefinition.createProcessor(RouteContext routeContext)
Processor	DelayDefinition.createProcessor(RouteContext routeContext)
Processor	ConvertBodyDefinition.createProcessor(RouteContext routeContext)
Processor	ChoiceDefinition.createProcessor(RouteContext routeContext)
Processor	BeanDefinition.createProcessor(RouteContext routeContext)
Processor	AOPDefinition.createProcessor(RouteContext routeContext) Deprecated.
Processor	AggregateDefinition.createProcessor(RouteContext routeContext)
Processor	OnExceptionDefinition.getErrorHandler()
Processor	InterceptDefinition.getInterceptedProcessor(int index)
Processor	WireTapDefinition.getNewExchangeProcessor()
Processor	OnCompletionDefinition.getOnCompletion(String routeId)
Processor	WireTapDefinition.getOnPrepare()
Processor	SplitDefinition.getOnPrepare()
Processor	RecipientListDefinition.getOnPrepare()
Processor	MulticastDefinition.getOnPrepare()
Processor	OnExceptionDefinition.getOnRedelivery()
protected Processor	ProcessorDefinition.makeProcessor(RouteContext routeContext) Creates the processor and wraps it in any necessary interceptors and error handlers
protected Processor	ProcessorDefinition.wrapChannel(RouteContext routeContext, Processor processor, ProcessorDefinition child)
protected Processor	ProcessorDefinition.wrapInErrorHandler(RouteContext routeContext, ErrorHandlerBuilder builder, Processor output) Wraps the given output in an error handler
Processor	ProcessorDefinition.wrapProcessor(RouteContext routeContext, Processor processor) Wraps the child processor in whatever necessary interceptors and error handlers

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

Collection<Processor>	OnCompletionDefinition.getOnCompletions()
List<Processor>	LoadBalancerDefinition.getProcessors()

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

void	LoadBalancerDefinition.addProcessor(Processor processor)
WireTapDefinition<Type>	WireTapDefinition.newExchange(Processor processor) Sends a new Exchange, instead of tapping an existing, using ExchangePattern.InOnly
WireTapDefinition<Type>	WireTapDefinition.onPrepare(Processor onPrepare) Uses the Processor when preparing the Exchange to be send.
SplitDefinition	SplitDefinition.onPrepare(Processor onPrepare) Uses the Processor when preparing the Exchange to be send.
RecipientListDefinition<Type>	RecipientListDefinition.onPrepare(Processor onPrepare) Uses the Processor when preparing the Exchange to be used send.
MulticastDefinition	MulticastDefinition.onPrepare(Processor onPrepare) Uses the Processor when preparing the Exchange to be send.
OnExceptionDefinition	OnExceptionDefinition.onRedelivery(Processor processor) Sets a processor that should be processed before a redelivery attempt.
Type	ProcessorDefinition.process(Processor processor) Message Translator EIP: Adds the custom processor to this destination which could be a final destination, or could be a transformation in a pipeline
void	LoadBalancerDefinition.removeProcessor(Processor processor)
void	WireTapDefinition.setNewExchangeProcessor(Processor processor)
void	WireTapDefinition.setOnPrepare(Processor onPrepare)
void	SplitDefinition.setOnPrepare(Processor onPrepare)
void	RecipientListDefinition.setOnPrepare(Processor onPrepare)
void	MulticastDefinition.setOnPrepare(Processor onPrepare)
void	OnExceptionDefinition.setOnRedelivery(Processor onRedelivery)
WireTapDefinition<Type>	ProcessorDefinition.wireTap(String uri, boolean copy, Processor processor) Deprecated. use the fluent builder from WireTapDefinition, will be removed in Camel 3.0
WireTapDefinition<Type>	ProcessorDefinition.wireTap(String uri, Processor processor) Deprecated. use the fluent builder from WireTapDefinition, will be removed in Camel 3.0
protected Processor	ProcessorDefinition.wrapChannel(RouteContext routeContext, Processor processor, ProcessorDefinition child)
protected Processor	ProcessorDefinition.wrapInErrorHandler(RouteContext routeContext, ErrorHandlerBuilder builder, Processor output) Wraps the given output in an error handler
Processor	ProcessorDefinition.wrapProcessor(RouteContext routeContext, Processor processor) Wraps the child processor in whatever necessary interceptors and error handlers

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

protected Processor	ProcessorDefinition.createCompositeProcessor(RouteContext routeContext, List<Processor> list) Creates a new instance of some kind of composite processor which defaults to using a Pipeline but derived classes could change the behaviour
protected Processor	MulticastDefinition.createCompositeProcessor(RouteContext routeContext, List<Processor> list)

Constructors in org.apache.camel.model with parameters of type Processor

ProcessDefinition(Processor processor)

Uses of Processor in org.apache.camel.model.loadbalancer

Classes in org.apache.camel.model.loadbalancer that implement Processor

class	CustomLoadBalancerDefinition Represents an XML <customLoadBalancer/> element
class	FailoverLoadBalancerDefinition Represents an XML <failover/> element
class	RandomLoadBalancerDefinition Represents an XML <random/> element
class	RoundRobinLoadBalancerDefinition Represents an XML <roundRobin/> element
class	StickyLoadBalancerDefinition Represents an XML <sticky/> element
class	TopicLoadBalancerDefinition Represents an XML <topic/> element
class	WeightedLoadBalancerDefinition Represents an XML <weighted/> element

Uses of Processor in org.apache.camel.processor

Subinterfaces of Processor in org.apache.camel.processor

interface

ErrorHandler An interface used to represent an error handler

Classes in org.apache.camel.processor that implement Processor

class	AOPProcessor
class	BatchProcessor Deprecated. may be removed in the future when we overhaul the resequencer EIP
class	CamelLogger A Processor which just logs to a CamelLogger object which can be used as an exception handler instead of using a dead letter queue.
class	CatchProcessor A processor which catches exceptions.
class	ChildUnitOfWorkProcessor An UnitOfWorkProcessor that creates a child UnitOfWork that is associated to a parent UnitOfWork.
class	ChoiceProcessor Implements a Choice structure where one or more predicates are used which if they are true their processors are used, with a default otherwise clause used if none match.
class	ConvertBodyProcessor A processor which converts the payload of the input message to be of the given type If the convertions fails an InvalidPayloadException is thrown.
class	DeadLetterChannel Implements a Dead Letter Channel after attempting to redeliver the message using the RedeliveryPolicy
class	DefaultChannel DefaultChannel is the default Channel.
class	DefaultErrorHandler Default error handler
class	Delayer A Delayer which delays processing the exchange until the correct amount of time has elapsed using an expression to determine the delivery time.
class	DelayProcessorSupport A useful base class for any processor which provides some kind of throttling or delayed processing.
class	DelegateAsyncProcessor A Delegate pattern which delegates processing to a nested AsyncProcessor which can be useful for implementation inheritance when writing an Policy Important: This implementation does support the asynchronous routing engine.
class	DelegateProcessor A Delegate pattern which delegates processing to a nested Processor which can be useful for implementation inheritance when writing an Policy Important: This implementation does not support the asynchronous routing engine.
class	DynamicRouter Implements a Dynamic Router pattern where the destination(s) is computed at runtime.
class	Enricher A content enricher that enriches input data by first obtaining additional data from a resource represented by an endpoint producer and second by aggregating input data and additional data.
class	ErrorHandlerSupport Support class for ErrorHandler implementations.
class	EvaluateExpressionProcessor A Processor which evaluates an Expression and stores the result as a property on the Exchange with the key Exchange.EVALUATE_EXPRESSION_RESULT.
class	ExchangePatternProcessor
class	FatalFallbackErrorHandler An ErrorHandler used as a safe fallback when processing by other error handlers such as the OnExceptionDefinition.
class	FilterProcessor The processor which implements the Message Filter EIP pattern.
class	InterceptEndpointProcessor Endpoint intercept processor so we know the processor is supposed to intercept an endpoint.
class	InterceptorToAsyncProcessorBridge A bridge to have regular interceptors implemented as Processor work with the asynchronous routing engine without causing side effects.
class	LoggingErrorHandler An ErrorHandler which uses commons-logging to dump the error
class	LogProcessor A processor which evaluates an Expression and logs it.
class	LoopProcessor The processor which sends messages in a loop.
class	MarshalProcessor Marshals the body of the incoming message using the given data format
class	MulticastProcessor Implements the Multicast pattern to send a message exchange to a number of endpoints, each endpoint receiving a copy of the message exchange.
class	OnCompletionProcessor
class	Pipeline Creates a Pipeline pattern where the output of the previous step is sent as input to the next step, reusing the same message exchanges
class	PollEnricher A content enricher that enriches input data by first obtaining additional data from a resource represented by an endpoint producer and second by aggregating input data and additional data.
class	RecipientList Implements a dynamic Recipient List pattern where the list of actual endpoints to send a message exchange to are dependent on some dynamic expression.
class	RecipientListProcessor Implements a dynamic Recipient List pattern where the list of actual endpoints to send a message exchange to are dependent on some dynamic expression.
class	RedeliveryErrorHandler Base redeliverable error handler that also supports a final dead letter queue in case all redelivery attempts fail.
class	Resequencer An implementation of the Resequencer which can reorder messages within a batch.
class	RollbackProcessor Processor for marking an Exchange to rollback.
class	RoutePolicyProcessor Processor which instruments the RoutePolicy.
class	RoutingSlip Implements a Routing Slip pattern where the list of actual endpoints to send a message exchange to are dependent on the value of a message header.
class	SamplingThrottler A SamplingThrottler is a special kind of throttler.
class	SendProcessor Processor for forwarding exchanges to an endpoint destination.
class	SetBodyProcessor A processor which sets the body on the IN message with an expression
class	SortProcessor A processor that sorts the expression using a comparator
class	Splitter Implements a dynamic Splitter pattern where an expression is evaluated to iterate through each of the parts of a message and then each part is then send to some endpoint.
class	StopProcessor Stops continue processing the route and marks it as complete.
class	StreamResequencer A resequencer that re-orders a (continuous) stream of Exchanges.
class	SubUnitOfWorkProcessor A processor that processes the processor in a SubUnitOfWork context.
class	ThreadsProcessor Threads processor that leverage a thread pool for continue processing the Exchanges using the asynchronous routing engine.
class	Throttler A Throttler will set a limit on the maximum number of message exchanges which can be sent to a processor within a specific time period.
class	ThroughputLogger A logger for logging message throughput.
class	ThrowExceptionProcessor The processor which implements the ThrowException DSL
class	TransformProcessor A processor which sets the body on the OUT message with an expression
class	TryProcessor Implements try/catch/finally type processing
class	UnitOfWorkProcessor Ensures the Exchange is routed under the boundaries of an UnitOfWork.
class	UnitOfWorkProducer Ensures a Producer is executed within an UnitOfWork.
class	UnmarshalProcessor Unmarshals the body of the incoming message using the given data format
class	WireTapProcessor Processor for wire tapping exchanges to an endpoint destination.
class	WrapProcessor A processor which ensures wrapping processors is having lifecycle handled.

Fields in org.apache.camel.processor declared as Processor

protected Processor	RedeliveryErrorHandler.deadLetter
protected Processor	MulticastProcessor.onPrepare
protected Processor	RedeliveryErrorHandler.output
protected Processor	DelegateProcessor.processor
protected Processor	RedeliveryErrorHandler.redeliveryProcessor

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

protected Processor	MulticastProcessor.createErrorHandler(RouteContext routeContext, Exchange exchange, Processor processor)
Processor	RedeliveryErrorHandler.getDeadLetter() Returns the dead letter that message exchanges will be sent to if the redelivery attempts fail
Processor	DefaultChannel.getErrorHandler()
Processor	DefaultChannel.getNextProcessor()
Processor	WireTapProcessor.getOnPrepare()
Processor	RecipientList.getOnPrepare()
Processor	ChoiceProcessor.getOtherwise()
Processor	RedeliveryErrorHandler.getOutput() Returns the output processor
abstract Processor	ErrorHandlerSupport.getOutput() Gets the output
Processor	DefaultChannel.getOutput()
Processor	StreamResequencer.getProcessor() Returns the next processor.
Processor	ProcessorExchangePair.getProcessor()
Processor	DelegateProcessor.getProcessor()
Processor	BatchProcessor.getProcessor() Deprecated.
static Processor	Pipeline.newInstance(CamelContext camelContext, List<Processor> processors)

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

List<Processor>	WireTapProcessor.getNewExchangeProcessors()
Collection<Processor>	MulticastProcessor.getProcessors() Returns the producers to multicast to
List<Processor>	WrapProcessor.next()
List<Processor>	TryProcessor.next()
List<Processor>	StreamResequencer.next()
List<Processor>	MulticastProcessor.next()
List<Processor>	DelegateProcessor.next()
List<Processor>	DelegateAsyncProcessor.next()
List<Processor>	DefaultChannel.next()
List<Processor>	ChoiceProcessor.next()
List<Processor>	BatchProcessor.next() Deprecated.

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

void	WireTapProcessor.addNewExchangeProcessor(Processor processor)
protected Processor	MulticastProcessor.createErrorHandler(RouteContext routeContext, Exchange exchange, Processor processor)
protected ProcessorExchangePair	MulticastProcessor.createProcessorExchangePair(int index, Processor processor, Exchange exchange, RouteContext routeContext) Creates the ProcessorExchangePair which holds the processor and exchange to be send out.
protected UnitOfWorkProcessor	MulticastProcessor.createUnitOfWorkProcessor(Processor processor, Exchange exchange) Strategy to create the UnitOfWorkProcessor to be used for the sub route
protected boolean	RedeliveryErrorHandler.deliverToFailureProcessor(Processor processor, Exchange exchange, RedeliveryErrorHandler.RedeliveryData data, AsyncCallback callback) All redelivery attempts failed so move the exchange to the dead letter queue
protected static void	OnCompletionProcessor.doProcess(Processor processor, Exchange exchange) Processes the exchange by the processors
void	DefaultChannel.setErrorHandler(Processor errorHandler)
void	DefaultChannel.setNextProcessor(Processor next)
void	WireTapProcessor.setOnPrepare(Processor onPrepare)
void	RecipientList.setOnPrepare(Processor onPrepare)
void	DefaultChannel.setOutput(Processor output)
void	DelegateProcessor.setProcessor(Processor processor)
void	DelegateAsyncProcessor.setProcessor(Processor processor)
void	InterceptorToAsyncProcessorBridge.setTarget(Processor target)
protected static void	MulticastProcessor.setToEndpoint(Exchange exchange, Processor processor)

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

protected boolean	Pipeline.continueRouting(Iterator<Processor> it, Exchange exchange)
static Processor	Pipeline.newInstance(CamelContext camelContext, List<Processor> processors)
void	WireTapProcessor.setNewExchangeProcessors(List<Processor> newExchangeProcessors)

Constructors in org.apache.camel.processor with parameters of type Processor

AOPProcessor(Processor tryProcessor, List<CatchProcessor> catchClauses, Processor finallyProcessor)

BatchProcessor(CamelContext camelContext, Processor processor, Collection<Exchange> collection)
Deprecated.

CatchProcessor(List<Class> exceptions, Processor processor, Predicate onWhen, Predicate handled)

ChildUnitOfWorkProcessor(UnitOfWork parent, Processor processor)

ChildUnitOfWorkProcessor(UnitOfWork parent, RouteContext routeContext, Processor processor)

ChoiceProcessor(List<FilterProcessor> filters, Processor otherwise)

DeadLetterChannel(CamelContext camelContext, Processor output, CamelLogger logger, Processor redeliveryProcessor, RedeliveryPolicy redeliveryPolicy, ExceptionPolicyStrategy exceptionPolicyStrategy, Processor deadLetter, String deadLetterUri, boolean useOriginalBodyPolicy, Predicate retryWhile, ScheduledExecutorService executorService)
Creates the dead letter channel.

DefaultErrorHandler(CamelContext camelContext, Processor output, CamelLogger logger, Processor redeliveryProcessor, RedeliveryPolicy redeliveryPolicy, ExceptionPolicyStrategy exceptionPolicyStrategy, Predicate retryWhile, ScheduledExecutorService executorService)
Creates the default error handler.

Delayer(Processor processor, Expression delay, ScheduledExecutorService executorService)

DelayProcessorSupport(Processor processor)

DelayProcessorSupport(Processor processor, ScheduledExecutorService executorService)

DelegateAsyncProcessor(Processor processor)

DelegateProcessor(Processor processor)

FatalFallbackErrorHandler(Processor processor)

FilterProcessor(Predicate predicate, Processor processor)

InterceptEndpointProcessor(String uri, Processor processor)

InterceptorToAsyncProcessorBridge(Processor interceptor)
Constructs the bridge

InterceptorToAsyncProcessorBridge(Processor interceptor, AsyncProcessor target)
Constructs the bridge

LoggingErrorHandler(CamelContext camelContext, Processor output, CamelLogger logger, ExceptionPolicyStrategy exceptionPolicyStrategy)
Creates the logging error handler.

LoopProcessor(Processor processor, Expression expression, boolean copy)

MulticastProcessor(CamelContext camelContext, Collection<Processor> processors, AggregationStrategy aggregationStrategy, boolean parallelProcessing, ExecutorService executorService, boolean streaming, boolean stopOnException, long timeout, Processor onPrepare, boolean shareUnitOfWork)

OnCompletionProcessor(CamelContext camelContext, Processor processor, ExecutorService executorService, boolean onCompleteOnly, boolean onFailureOnly, Predicate onWhen, boolean useOriginalBody)

RecipientListProcessor(CamelContext camelContext, ProducerCache producerCache, Iterator<Object> iter, AggregationStrategy aggregationStrategy, boolean parallelProcessing, ExecutorService executorService, boolean streaming, boolean stopOnException, long timeout, Processor onPrepare, boolean shareUnitOfWork)

RedeliveryErrorHandler(CamelContext camelContext, Processor output, CamelLogger logger, Processor redeliveryProcessor, RedeliveryPolicy redeliveryPolicy, Processor deadLetter, String deadLetterUri, boolean useOriginalMessagePolicy, Predicate retryWhile, ScheduledExecutorService executorService)

Resequencer(CamelContext camelContext, Processor processor, Expression expression)

Resequencer(CamelContext camelContext, Processor processor, Expression expression, boolean allowDuplicates, boolean reverse)

Resequencer(CamelContext camelContext, Processor processor, Set<Exchange> collection)

RoutePolicyProcessor(Processor processor, List<RoutePolicy> routePolicies)

SamplingThrottler(Processor processor, long messageFrequency)

SamplingThrottler(Processor processor, long samplePeriod, TimeUnit units)

Splitter(CamelContext camelContext, Expression expression, Processor destination, AggregationStrategy aggregationStrategy)

Splitter(CamelContext camelContext, Expression expression, Processor destination, AggregationStrategy aggregationStrategy, boolean parallelProcessing, ExecutorService executorService, boolean streaming, boolean stopOnException, long timeout, Processor onPrepare, boolean useSubUnitOfWork)

StreamResequencer(CamelContext camelContext, Processor processor, SequenceElementComparator<Exchange> comparator)
Creates a new StreamResequencer instance.

SubUnitOfWorkProcessor(Processor processor)

SubUnitOfWorkProcessor(RouteContext routeContext, Processor processor)

Throttler(Processor processor, Expression maxRequestsPerPeriodExpression, long timePeriodMillis, ScheduledExecutorService executorService)

TryProcessor(Processor tryProcessor, List<CatchProcessor> catchClauses, Processor finallyProcessor)

UnitOfWorkProcessor(Processor processor)

UnitOfWorkProcessor(RouteContext routeContext, Processor processor)

WrapProcessor(Processor processor, Processor wrapped)

Constructor parameters in org.apache.camel.processor with type arguments of type Processor

MulticastProcessor(CamelContext camelContext, Collection<Processor> processors)

MulticastProcessor(CamelContext camelContext, Collection<Processor> processors, AggregationStrategy aggregationStrategy)

MulticastProcessor(CamelContext camelContext, Collection<Processor> processors, AggregationStrategy aggregationStrategy, boolean parallelProcessing, ExecutorService executorService, boolean streaming, boolean stopOnException, long timeout, Processor onPrepare, boolean shareUnitOfWork)

Pipeline(CamelContext camelContext, Collection<Processor> processors)

Uses of Processor in org.apache.camel.processor.aggregate

Classes in org.apache.camel.processor.aggregate that implement Processor

class

AggregateProcessor An implementation of the Aggregator pattern where a batch of messages are processed (up to a maximum amount or until some timeout is reached) and messages for the same correlation key are combined together using some kind of AggregationStrategy (by default the latest message is used) to compress many message exchanges into a smaller number of exchanges.

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

List<Processor>

AggregateProcessor.next()

Constructors in org.apache.camel.processor.aggregate with parameters of type Processor

AggregateProcessor(CamelContext camelContext, Processor processor, Expression correlationExpression, AggregationStrategy aggregationStrategy, ExecutorService executorService)

Uses of Processor in org.apache.camel.processor.idempotent

Classes in org.apache.camel.processor.idempotent that implement Processor

class

IdempotentConsumer An implementation of the Idempotent Consumer pattern.

Methods in org.apache.camel.processor.idempotent that return Processor

Processor

IdempotentConsumer.getProcessor()

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

List<Processor>

IdempotentConsumer.next()

Constructors in org.apache.camel.processor.idempotent with parameters of type Processor

IdempotentConsumer(Expression messageIdExpression, IdempotentRepository<String> idempotentRepository, boolean eager, boolean skipDuplicate, Processor processor)

Uses of Processor in org.apache.camel.processor.interceptor

Classes in org.apache.camel.processor.interceptor that implement Processor

class	DelayInterceptor An interceptor for delaying routes.
class	HandleFaultInterceptor
class	StreamCachingInterceptor An interceptor that converts streams messages into a re-readable format by wrapping the stream into a StreamCache.
class	TraceInterceptor An interceptor for debugging and tracing routes

Methods in org.apache.camel.processor.interceptor that return Processor

Processor	TraceInterceptorFactory.createTraceInterceptor(ProcessorDefinition node, Processor target, TraceFormatter formatter, Tracer tracer) Create a trace interceptor.
Processor	DefaultTraceInterceptorFactory.createTraceInterceptor(ProcessorDefinition node, Processor target, TraceFormatter formatter, Tracer tracer)
Processor	Tracer.wrapProcessorInInterceptors(CamelContext context, ProcessorDefinition<?> definition, Processor target, Processor nextTarget)
Processor	StreamCaching.wrapProcessorInInterceptors(CamelContext context, ProcessorDefinition<?> definition, Processor target, Processor nextTarget)
Processor	HandleFault.wrapProcessorInInterceptors(CamelContext context, ProcessorDefinition<?> definition, Processor target, Processor nextTarget)
Processor	Delayer.wrapProcessorInInterceptors(CamelContext context, ProcessorDefinition<?> definition, Processor target, Processor nextTarget)
Processor	Debug.wrapProcessorInInterceptors(CamelContext context, ProcessorDefinition<?> definition, Processor target, Processor nextTarget)

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

Processor	TraceInterceptorFactory.createTraceInterceptor(ProcessorDefinition node, Processor target, TraceFormatter formatter, Tracer tracer) Create a trace interceptor.
Processor	DefaultTraceInterceptorFactory.createTraceInterceptor(ProcessorDefinition node, Processor target, TraceFormatter formatter, Tracer tracer)
void	TraceEventHandler.traceExchange(ProcessorDefinition node, Processor target, TraceInterceptor traceInterceptor, Exchange exchange) Event called when an Exchange is about to be processed This event is only called if trace out has been disabled (which it is by default).
void	DefaultTraceEventHandler.traceExchange(ProcessorDefinition node, Processor target, TraceInterceptor traceInterceptor, Exchange exchange)
Object	TraceEventHandler.traceExchangeIn(ProcessorDefinition node, Processor target, TraceInterceptor traceInterceptor, Exchange exchange) Event called when an Exchange is about to be processed (in) This event is only called if trace out has been enabled.
Object	DefaultTraceEventHandler.traceExchangeIn(ProcessorDefinition node, Processor target, TraceInterceptor traceInterceptor, Exchange exchange)
void	TraceEventHandler.traceExchangeOut(ProcessorDefinition node, Processor target, TraceInterceptor traceInterceptor, Exchange exchange, Object traceState) Event called when an Exchange has been processed (out) This event is only called if trace out has been enabled.
void	DefaultTraceEventHandler.traceExchangeOut(ProcessorDefinition node, Processor target, TraceInterceptor traceInterceptor, Exchange exchange, Object traceState)
Processor	Tracer.wrapProcessorInInterceptors(CamelContext context, ProcessorDefinition<?> definition, Processor target, Processor nextTarget)
Processor	StreamCaching.wrapProcessorInInterceptors(CamelContext context, ProcessorDefinition<?> definition, Processor target, Processor nextTarget)
Processor	HandleFault.wrapProcessorInInterceptors(CamelContext context, ProcessorDefinition<?> definition, Processor target, Processor nextTarget)
Processor	Delayer.wrapProcessorInInterceptors(CamelContext context, ProcessorDefinition<?> definition, Processor target, Processor nextTarget)
Processor	Debug.wrapProcessorInInterceptors(CamelContext context, ProcessorDefinition<?> definition, Processor target, Processor nextTarget)

Constructors in org.apache.camel.processor.interceptor with parameters of type Processor

DelayInterceptor(ProcessorDefinition<?> node, Processor target, Delayer delayer)

HandleFaultInterceptor(Processor processor)

StreamCachingInterceptor(Processor processor)

TraceInterceptor(ProcessorDefinition node, Processor target, TraceFormatter formatter, Tracer tracer)

Uses of Processor in org.apache.camel.processor.loadbalancer

Subinterfaces of Processor in org.apache.camel.processor.loadbalancer

interface

LoadBalancer A strategy for load balancing across a number of Processor instances

Classes in org.apache.camel.processor.loadbalancer that implement Processor

class	FailOverLoadBalancer This FailOverLoadBalancer will failover to use next processor when an exception occurred This implementation mirrors the logic from the Pipeline in the async variation as the failover load balancer is a specialized pipeline.
class	LoadBalancerSupport A default base class for a LoadBalancer implementation.
class	QueueLoadBalancer A base class for LoadBalancer implementations which choose a single destination for each exchange (rather like JMS Queues)
class	RandomLoadBalancer Implements the random load balancing policy
class	RoundRobinLoadBalancer Implements the round robin load balancing policy
class	SimpleLoadBalancerSupport A default base class for a LoadBalancer implementation.
class	StickyLoadBalancer Implements a sticky load balancer using an Expression to calculate a correlation key to perform the sticky load balancing; rather like jsessionid in the web or JMSXGroupID in JMS.
class	TopicLoadBalancer A LoadBalancer implementations which sends to all destinations (rather like JMS Topics).
class	WeightedLoadBalancer
class	WeightedRandomLoadBalancer
class	WeightedRoundRobinLoadBalancer

Methods in org.apache.camel.processor.loadbalancer that return Processor

protected Processor	WeightedRoundRobinLoadBalancer.chooseProcessor(List<Processor> processors, Exchange exchange)
protected Processor	WeightedRandomLoadBalancer.chooseProcessor(List<Processor> processors, Exchange exchange)
protected Processor	StickyLoadBalancer.chooseProcessor(List<Processor> processors, Exchange exchange)
protected Processor	RoundRobinLoadBalancer.chooseProcessor(List<Processor> processors, Exchange exchange)
protected Processor	RandomLoadBalancer.chooseProcessor(List<Processor> processors, Exchange exchange)
protected abstract Processor	QueueLoadBalancer.chooseProcessor(List<Processor> processors, Exchange exchange)

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

List<Processor>	LoadBalancerSupport.getProcessors()
List<Processor>	LoadBalancer.getProcessors() Returns the current processors available to this load balancer
List<Processor>	LoadBalancerSupport.next()

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

void	LoadBalancerSupport.addProcessor(Processor processor)
void	LoadBalancer.addProcessor(Processor processor) Adds a new processor to the load balancer
protected Exchange	TopicLoadBalancer.copyExchangeStrategy(Processor processor, Exchange exchange) Strategy method to copy the exchange before sending to another endpoint.
void	StickyLoadBalancer.removeProcessor(Processor processor)
void	LoadBalancerSupport.removeProcessor(Processor processor)
void	LoadBalancer.removeProcessor(Processor processor) Removes the given processor from the load balancer

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

protected Processor	WeightedRoundRobinLoadBalancer.chooseProcessor(List<Processor> processors, Exchange exchange)
protected Processor	WeightedRandomLoadBalancer.chooseProcessor(List<Processor> processors, Exchange exchange)
protected Processor	StickyLoadBalancer.chooseProcessor(List<Processor> processors, Exchange exchange)
protected Processor	RoundRobinLoadBalancer.chooseProcessor(List<Processor> processors, Exchange exchange)
protected Processor	RandomLoadBalancer.chooseProcessor(List<Processor> processors, Exchange exchange)
protected abstract Processor	QueueLoadBalancer.chooseProcessor(List<Processor> processors, Exchange exchange)

Constructors in org.apache.camel.processor.loadbalancer with parameters of type Processor

LoadBalancerConsumer(Endpoint endpoint, Processor processor, LoadBalancer loadBalancer)

Uses of Processor in org.apache.camel.processor.validation

Classes in org.apache.camel.processor.validation that implement Processor

class	PredicateValidatingProcessor A processor which validates the content of the inbound message body against a predicate.
class	ValidatingProcessor A processor which validates the XML version of the inbound message body against some schema either in XSD or RelaxNG

Uses of Processor in org.apache.camel.spi

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

Processor	ProcessorFactory.createChildProcessor(RouteContext routeContext, ProcessorDefinition<?> definition, boolean mandatory) Creates the child processor.
Processor	RouteContext.createProcessor(ProcessorDefinition<?> node) Creates a processor
Processor	ProcessorFactory.createProcessor(RouteContext routeContext, ProcessorDefinition<?> definition) Creates the processor.
Processor	Policy.wrap(RouteContext routeContext, Processor processor) Wraps any applicable interceptors around the given processor.
Processor	InterceptStrategy.wrapProcessorInInterceptors(CamelContext context, ProcessorDefinition<?> definition, Processor target, Processor nextTarget) This method is invoked by ProcessorDefinition.wrapProcessor(RouteContext, Processor) to give the implementor an opportunity to wrap the target processor in a route.

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

void	RouteContext.addEventDrivenProcessor(Processor processor) Adds an event driven processor
boolean	Debugger.afterProcess(Exchange exchange, Processor processor, ProcessorDefinition definition, long timeTaken) Callback invoked when an Exchange has been processed which allows implementators to notify breakpoints.
void	Breakpoint.afterProcess(Exchange exchange, Processor processor, ProcessorDefinition 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 optional work to be executed after the processing
boolean	Debugger.beforeProcess(Exchange exchange, Processor processor, ProcessorDefinition definition) Callback invoked when an Exchange is about to be processed which allows implementators to notify breakpoints.
void	Breakpoint.beforeProcess(Exchange exchange, Processor processor, ProcessorDefinition 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 optional work to be execute before processing For example the MDCUnitOfWork leverages this to ensure MDC is handled correctly during routing exchanges using the asynchronous routing engine.
EventObject	EventFactory.createExchangeFailureHandledEvent(Exchange exchange, Processor failureHandler, boolean deadLetterChannel) Creates an EventObject when an Exchange has failed but was handled by the Camel error handlers such as an dead letter channel.
Object	ManagementObjectStrategy.getManagedObjectForErrorHandler(CamelContext context, RouteContext routeContext, Processor errorHandler, ErrorHandlerBuilder errorHandlerBuilder)
Object	ManagementObjectStrategy.getManagedObjectForProcessor(CamelContext context, Processor processor, ProcessorDefinition definition, Route route)
ObjectName	ManagementNamingStrategy.getObjectNameForErrorHandler(RouteContext routeContext, Processor errorHandler, ErrorHandlerBuilder builder)
ObjectName	ManagementNamingStrategy.getObjectNameForProcessor(CamelContext context, Processor processor, ProcessorDefinition<?> definition)
boolean	Condition.matchProcess(Exchange exchange, Processor processor, ProcessorDefinition definition) Does the condition match
void	LifecycleStrategy.onErrorHandlerAdd(RouteContext routeContext, Processor errorHandler, ErrorHandlerBuilder errorHandlerBuilder) Notification on adding error handler.
Processor	Policy.wrap(RouteContext routeContext, Processor processor) Wraps any applicable interceptors around the given processor.
Processor	InterceptStrategy.wrapProcessorInInterceptors(CamelContext context, ProcessorDefinition<?> definition, Processor target, Processor nextTarget) This method is invoked by ProcessorDefinition.wrapProcessor(RouteContext, Processor) to give the implementor an opportunity to wrap the target processor in a route.

Uses of Processor in org.apache.camel.util

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

static void	EventHelper.notifyExchangeFailureHandled(CamelContext context, Exchange exchange, Processor failureHandler, boolean deadLetterChannel)
static void	EndpointHelper.pollEndpoint(Endpoint endpoint, Processor processor) Creates a PollingConsumer and polls all pending messages on the endpoint and invokes the given Processor to process each Exchange and then closes down the consumer and throws any exceptions thrown.
static void	EndpointHelper.pollEndpoint(Endpoint endpoint, Processor processor, long timeout) Creates a PollingConsumer and polls all pending messages on the endpoint and invokes the given Processor to process each Exchange and then closes down the consumer and throws any exceptions thrown.