|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use Processor | |
---|---|
org.apache.camel | The core Camel API |
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.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.jmx | The JMX Component for monitoring JMX Attributes uisng a CounterMonitor. |
org.apache.camel.component.list | The List 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.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 JMX export services. |
org.apache.camel.model | The JAXB POJOs for the XML Configuration of the routing rules. |
org.apache.camel.model.loadbalancer | The LoadBalancer and the LoadBalancerStrategy JAXB Objects |
org.apache.camel.processor | A collection of Processor implementations which are used to implement the Enterprise Integration Patterns |
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.resequencer | Helper classes for the Resequencer pattern. |
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 and useful for Camel component developers |
Uses of Processor in org.apache.camel |
---|
Subinterfaces of Processor in org.apache.camel | |
---|---|
interface |
AsyncProcessor
A more complex version of Processor which supports asynchronous
processing of the Exchange . |
interface |
Producer<E extends Exchange>
Provides a channel on which clients can create and invoke message exchanges on an Endpoint |
Methods in org.apache.camel that return Processor | |
---|---|
Processor |
Intercept.getInterceptorLogic()
|
Methods in org.apache.camel with parameters of type Processor | |
---|---|
Consumer<E> |
Endpoint.createConsumer(Processor processor)
Creates a new Event Driven Consumer which consumes messages from the endpoint using the given processor |
E |
ProducerTemplate.request(Endpoint<E> endpoint,
Processor processor)
Send the body to an endpoint returning any result output body. |
E |
ProducerTemplate.request(String endpointUri,
Processor processor)
Send the body to an endpoint returning any result output body. |
E |
ProducerTemplate.send(Endpoint<E> endpoint,
ExchangePattern pattern,
Processor processor)
Sends an exchange to an endpoint using a supplied processor |
E |
ProducerTemplate.send(Endpoint<E> endpoint,
Processor processor)
Sends an exchange to an endpoint using a supplied processor |
E |
ProducerTemplate.send(Endpoint<E> endpoint,
Processor processor,
AsyncCallback callback)
Sends an exchange to an endpoint using a supplied processor |
E |
ProducerTemplate.send(Processor processor)
Sends an exchange to the default endpoint using a supplied |
E |
ProducerTemplate.send(String endpointUri,
ExchangePattern pattern,
Processor processor)
Sends an exchange to an endpoint using a supplied processor |
E |
ProducerTemplate.send(String endpointUri,
Processor processor)
Sends an exchange to an endpoint using a supplied processor |
E |
ProducerTemplate.send(String endpointUri,
Processor processor,
AsyncCallback callback)
Sends an exchange to an endpoint using a supplied processor |
void |
Intercept.setInterceptorLogic(Processor interceptorLogic)
|
Uses of Processor in org.apache.camel.builder |
---|
Methods in org.apache.camel.builder that return Processor | |
---|---|
Processor |
ErrorHandlerBuilderRef.createErrorHandler(RouteContext routeContext,
Processor processor)
|
Processor |
DeadLetterChannelBuilder.createErrorHandler(RouteContext routeContext,
Processor processor)
|
Processor |
LoggingErrorHandlerBuilder.createErrorHandler(RouteContext routeContext,
Processor processor)
|
Processor |
NoErrorHandlerBuilder.createErrorHandler(RouteContext routeContext,
Processor processor)
|
Processor |
ErrorHandlerBuilder.createErrorHandler(RouteContext routeContext,
Processor processor)
Creates the error handler interceptor |
Processor |
ConstantProcessorBuilder.createProcessor()
|
Processor |
ProcessorFactory.createProcessor()
|
Processor |
DeadLetterChannelBuilder.getDefaultDeadLetterEndpoint()
|
static Processor |
ProcessorBuilder.removeFaultHeader(String name)
Removes the header on the FAULT message |
static Processor |
ProcessorBuilder.removeHeader(String name)
Removes the header on the IN message |
static Processor |
ProcessorBuilder.removeOutHeader(String name)
Removes the header on the OUT message |
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 |
ErrorHandlerBuilderRef.createErrorHandler(RouteContext routeContext,
Processor processor)
|
Processor |
DeadLetterChannelBuilder.createErrorHandler(RouteContext routeContext,
Processor processor)
|
Processor |
LoggingErrorHandlerBuilder.createErrorHandler(RouteContext routeContext,
Processor processor)
|
Processor |
NoErrorHandlerBuilder.createErrorHandler(RouteContext routeContext,
Processor processor)
|
Processor |
ErrorHandlerBuilder.createErrorHandler(RouteContext routeContext,
Processor processor)
Creates the error handler interceptor |
void |
DeadLetterChannelBuilder.setDefaultDeadLetterEndpoint(Processor defaultDeadLetterEndpoint)
Sets the default dead letter endpoint used |
Constructors in org.apache.camel.builder with parameters of type Processor | |
---|---|
ConstantProcessorBuilder(Processor processor)
|
|
DeadLetterChannelBuilder(Processor processor)
|
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 |
ConstantBeanHolder.getProcessor()
|
Processor |
RegistryBean.getProcessor()
|
protected Processor |
BeanProcessor.getProcessor()
|
Processor |
BeanHolder.getProcessor()
|
Uses of Processor in org.apache.camel.component.dataset |
---|
Methods in org.apache.camel.component.dataset that return Processor | |
---|---|
Processor |
SimpleDataSet.getInputTransformer()
|
Processor |
DataSetSupport.getOutputTransformer()
|
Methods in org.apache.camel.component.dataset with parameters of type Processor | |
---|---|
Consumer<Exchange> |
DataSetEndpoint.createConsumer(Processor processor)
|
void |
SimpleDataSet.setInputTransformer(Processor inputTransformer)
|
void |
DataSetSupport.setOutputTransformer(Processor outputTransformer)
|
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<E extends Exchange>
The direct producer. |
Methods in org.apache.camel.component.direct with parameters of type Processor | |
---|---|
Consumer<E> |
DirectEndpoint.createConsumer(Processor processor)
|
Uses of Processor in org.apache.camel.component.file |
---|
Classes in org.apache.camel.component.file that implement Processor | |
---|---|
class |
FileProducer
For producing files. |
Methods in org.apache.camel.component.file with parameters of type Processor | |
---|---|
Consumer<FileExchange> |
FileEndpoint.createConsumer(Processor processor)
|
Constructors in org.apache.camel.component.file with parameters of type Processor | |
---|---|
FileConsumer(FileEndpoint endpoint,
Processor processor)
|
Uses of Processor in org.apache.camel.component.jmx |
---|
Methods in org.apache.camel.component.jmx with parameters of type Processor | |
---|---|
Consumer<JMXExchange> |
JMXEndpoint.createConsumer(Processor proc)
|
Constructors in org.apache.camel.component.jmx with parameters of type Processor | |
---|---|
JMXConsumer(JMXEndpoint endpoint,
Processor processor)
|
Uses of Processor in org.apache.camel.component.list |
---|
Methods in org.apache.camel.component.list with parameters of type Processor | |
---|---|
Consumer<Exchange> |
ListEndpoint.createConsumer(Processor processor)
|
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<Exchange> |
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
A simple Producer which just appends to a Collection the Exchange object. |
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<Exchange> |
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<Exchange> expresion)
|
Processor |
CamelConverter.toProcessor(Predicate<Exchange> predicate)
|
Uses of Processor in org.apache.camel.impl |
---|
Classes in org.apache.camel.impl that implement Processor | |
---|---|
class |
DefaultProducer<E extends Exchange>
A default implementation of @{link Producer} for implementation inheritence |
class |
EventDrivenPollingConsumer<E extends Exchange>
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. |
Methods in org.apache.camel.impl that return Processor | |
---|---|
protected Processor |
DefaultProducerTemplate.createBodyAndHeaderProcessor(Object body,
String header,
Object headerValue)
|
Processor |
DefaultRouteContext.createProceedProcessor()
|
protected Processor |
ProcessorEndpoint.createProcessor()
|
Processor |
DefaultRouteContext.createProcessor(ProcessorType node)
|
protected Processor |
DefaultProducerTemplate.createSetBodyProcessor(Object body)
|
Processor |
ProcessorEndpoint.getProcessor()
|
Processor |
EventDrivenConsumerRoute.getProcessor()
|
Processor |
DefaultConsumer.getProcessor()
|
Processor |
NoPolicy.wrap(Processor processor)
|
Methods in org.apache.camel.impl with parameters of type Processor | |
---|---|
void |
DefaultRouteContext.addEventDrivenProcessor(Processor processor)
|
Consumer<E> |
DefaultPollingEndpoint.createConsumer(Processor processor)
|
E |
DefaultProducerTemplate.request(Endpoint<E> endpoint,
Processor processor)
|
E |
DefaultProducerTemplate.request(String endpoint,
Processor processor)
|
E |
DefaultProducerTemplate.send(Endpoint<E> endpoint,
ExchangePattern pattern,
Processor processor)
|
E |
ProducerCache.send(Endpoint<E> endpoint,
ExchangePattern pattern,
Processor processor)
Sends an exchange to an endpoint using a supplied Processor to populate the exchange |
E |
DefaultProducerTemplate.send(Endpoint<E> endpoint,
Processor processor)
|
E |
ProducerCache.send(Endpoint<E> endpoint,
Processor processor)
Sends an exchange to an endpoint using a supplied Processor to populate the exchange |
E |
DefaultProducerTemplate.send(Endpoint<E> endpoint,
Processor processor,
AsyncCallback callback)
|
E |
ProducerCache.send(Endpoint<E> endpoint,
Processor processor,
AsyncCallback callback)
Sends an exchange to an endpoint using a supplied Processor to populate the exchange. |
E |
DefaultProducerTemplate.send(Processor processor)
|
E |
DefaultProducerTemplate.send(String endpointUri,
ExchangePattern pattern,
Processor processor)
|
E |
DefaultProducerTemplate.send(String endpointUri,
Processor processor)
|
E |
DefaultProducerTemplate.send(String endpointUri,
Processor processor,
AsyncCallback callback)
|
protected E |
ProducerCache.sendExchange(Endpoint<E> endpoint,
Producer<E> producer,
Processor processor,
E exchange)
|
protected boolean |
ProducerCache.sendExchange(Endpoint<E> endpoint,
Producer<E> producer,
Processor processor,
E exchange,
AsyncCallback callback)
|
void |
EventDrivenConsumerRoute.setProcessor(Processor processor)
|
Processor |
NoPolicy.wrap(Processor processor)
|
Constructors in org.apache.camel.impl with parameters of type Processor | |
---|---|
DefaultConsumer(Endpoint<E> endpoint,
Processor processor)
|
|
DefaultScheduledPollConsumer(DefaultEndpoint<E> defaultEndpoint,
Processor processor)
|
|
DefaultScheduledPollConsumer(Endpoint<E> endpoint,
Processor processor,
ScheduledExecutorService executor)
|
|
EventDrivenConsumerRoute(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(DefaultEndpoint<E> endpoint,
Processor processor)
|
|
ScheduledPollConsumer(Endpoint<E> 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 Counter for instrumenting
processing of exchanges. |
Methods in org.apache.camel.management that return Processor | |
---|---|
Processor |
InstrumentationErrorHandlerWrappingStrategy.wrapProcessorInErrorHandler(RouteContext routeContext,
ProcessorType processorType,
Processor target)
|
Processor |
InstrumentationInterceptStrategy.wrapProcessorInInterceptors(ProcessorType processorType,
Processor target)
|
Methods in org.apache.camel.management with parameters of type Processor | |
---|---|
Processor |
InstrumentationErrorHandlerWrappingStrategy.wrapProcessorInErrorHandler(RouteContext routeContext,
ProcessorType processorType,
Processor target)
|
Processor |
InstrumentationInterceptStrategy.wrapProcessorInInterceptors(ProcessorType processorType,
Processor target)
|
Uses of Processor in org.apache.camel.model |
---|
Methods in org.apache.camel.model that return Processor | |
---|---|
protected Processor |
MulticastType.createCompositeProcessor(RouteContext routeContext,
List<Processor> list)
|
protected Processor |
ProcessorType.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 |
Processor |
ProcessorType.createOutputsProcessor(RouteContext routeContext)
|
protected Processor |
LoadBalanceType.createOutputsProcessor(RouteContext routeContext,
Collection<ProcessorType<?>> outputs)
|
protected Processor |
ProcessorType.createOutputsProcessor(RouteContext routeContext,
Collection<ProcessorType<?>> outputs)
|
Processor |
TryType.createProcessor(RouteContext routeContext)
|
Processor |
BeanRef.createProcessor(RouteContext routeContext)
|
Processor |
PolicyRef.createProcessor(RouteContext routeContext)
|
Processor |
DelayerType.createProcessor(RouteContext routeContext)
|
Processor |
LoadBalanceType.createProcessor(RouteContext routeContext)
|
Processor |
TransformType.createProcessor(RouteContext routeContext)
|
Processor |
SplitterType.createProcessor(RouteContext routeContext)
|
Processor |
UnmarshalType.createProcessor(RouteContext routeContext)
|
Processor |
MulticastType.createProcessor(RouteContext routeContext)
|
Processor |
ConvertBodyType.createProcessor(RouteContext routeContext)
|
Processor |
IdempotentConsumerType.createProcessor(RouteContext routeContext)
|
Processor |
MarshalType.createProcessor(RouteContext routeContext)
|
Processor |
SetBodyType.createProcessor(RouteContext routeContext)
|
Processor |
SetOutHeaderType.createProcessor(RouteContext routeContext)
|
Processor |
InterceptType.createProcessor(RouteContext routeContext)
|
Processor |
ResequencerType.createProcessor(RouteContext routeContext)
|
Processor |
ChoiceType.createProcessor(RouteContext routeContext)
|
Processor |
ToType.createProcessor(RouteContext routeContext)
|
Processor |
ProcessorType.createProcessor(RouteContext routeContext)
|
Processor |
ProcessorRef.createProcessor(RouteContext routeContext)
|
Processor |
OtherwiseType.createProcessor(RouteContext routeContext)
|
Processor |
FinallyType.createProcessor(RouteContext routeContext)
|
Processor |
ThrottlerType.createProcessor(RouteContext routeContext)
|
Processor |
AggregatorType.createProcessor(RouteContext routeContext)
|
Processor |
PipelineType.createProcessor(RouteContext routeContext)
|
Processor |
InterceptorRef.createProcessor(RouteContext routeContext)
|
Processor |
ProceedType.createProcessor(RouteContext routeContext)
|
Processor |
ThrowFaultType.createProcessor(RouteContext routeContext)
|
Processor |
ThreadType.createProcessor(RouteContext routeContext)
|
Processor |
SetHeaderType.createProcessor(RouteContext routeContext)
|
Processor |
RoutingSlipType.createProcessor(RouteContext routeContext)
|
Processor |
RecipientListType.createProcessor(RouteContext routeContext)
|
Processor |
ExceptionType.getErrorHandler()
|
protected Processor |
ProcessorType.makeProcessor(RouteContext routeContext)
Creates the processor and wraps it in any necessary interceptors and error handlers |
protected Processor |
ProcessorType.wrapInErrorHandler(RouteContext routeContext,
Processor target)
A strategy method to allow newly created processors to be wrapped in an error handler. |
Processor |
ProcessorType.wrapProcessor(RouteContext routeContext,
Processor processor)
Wraps the child processor in whatever necessary interceptors and error handlers |
protected Processor |
MulticastType.wrapProcessorInInterceptors(RouteContext routeContext,
Processor target)
|
protected Processor |
ProcessorType.wrapProcessorInInterceptors(RouteContext routeContext,
Processor target)
A strategy method which allows derived classes to wrap the child processor in some kind of interceptor |
Methods in org.apache.camel.model with parameters of type Processor | |
---|---|
Type |
ProcessorType.process(Processor processor)
Adds the custom processor to this destination which could be a final destination, or could be a transformation in a pipeline |
protected Processor |
ProcessorType.wrapInErrorHandler(RouteContext routeContext,
Processor target)
A strategy method to allow newly created processors to be wrapped in an error handler. |
Processor |
ProcessorType.wrapProcessor(RouteContext routeContext,
Processor processor)
Wraps the child processor in whatever necessary interceptors and error handlers |
protected Processor |
MulticastType.wrapProcessorInInterceptors(RouteContext routeContext,
Processor target)
|
protected Processor |
ProcessorType.wrapProcessorInInterceptors(RouteContext routeContext,
Processor target)
A strategy method which allows derived classes to wrap the child processor in some kind of interceptor |
Method parameters in org.apache.camel.model with type arguments of type Processor | |
---|---|
protected Processor |
MulticastType.createCompositeProcessor(RouteContext routeContext,
List<Processor> list)
|
protected Processor |
ProcessorType.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 |
Constructors in org.apache.camel.model with parameters of type Processor | |
---|---|
ProcessorRef(Processor processor)
|
Uses of Processor in org.apache.camel.model.loadbalancer |
---|
Classes in org.apache.camel.model.loadbalancer that implement Processor | |
---|---|
class |
LoadBalancerType
Represents an XML <loadBalance/> element |
class |
RandomLoadBalanceStrategy
Represents an XML <random/> element |
class |
RoundRobinLoadBalanceStrategy
Represents an XML <roundRobin/> element |
class |
StickyLoadBalanceStrategy
Represents an XML <sticky/> element |
class |
TopicLoadBalanceStrategy
Represents an XML <topic/> element |
Methods in org.apache.camel.model.loadbalancer that return types with arguments of type Processor | |
---|---|
List<Processor> |
LoadBalancerType.getProcessors()
|
Methods in org.apache.camel.model.loadbalancer with parameters of type Processor | |
---|---|
void |
LoadBalancerType.addProcessor(Processor processor)
|
void |
LoadBalancerType.removeProcessor(Processor processor)
|
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 |
Aggregator
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. |
class |
BatchProcessor
A base class for any kind of Processor which implements some kind of
batch processing. |
class |
CatchProcessor
A processor which catches exceptions. |
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 |
CompositeProcessor
Represents a composite pattern, aggregating a collection of processors together as a single processor |
class |
ConvertBodyProcessor
A processor which converts the payload of the input message to be of the given type |
class |
DeadLetterChannel
Implements a Dead Letter Channel after attempting to redeliver the message using the RedeliveryPolicy |
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 |
class |
DelegateProcessor
A Delegate pattern which delegates processing to a nested processor which can be useful for implementation inheritance when writing an Policy |
class |
ErrorHandlerSupport
Support class for ErrorHandler implementations. |
class |
FilterProcessor
The processor which implements the Message Filter EIP pattern. |
class |
HandleFaultProcessor
|
class |
Interceptor
An interceptor which provides the processing logic as a pluggable processor which allows the DelegateProcessor.proceed(Exchange) method to be called at some point |
class |
Logger
A Processor which just logs to a Log object which can be used
as an exception handler instead of using a dead letter queue. |
class |
LoggingErrorHandler
An ErrorHandler which uses commons-logging to dump the error |
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 |
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 |
ProceedProcessor
A Processor which proceeds on an Interceptor |
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 |
Resequencer
An implementation of the Resequencer which can reorder messages within a batch. |
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 |
SendProcessor
Processor for forwarding exchanges to an endpoint destination. |
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 |
StreamResequencer
A resequencer that re-orders a (continuous) stream of Exchange s. |
class |
ThreadProcessor
A processor that forces async processing of the exchange using a thread pool. |
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 |
ThrowFaultProcessor
The processor which implements the ThrowFault 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
Handles calling the UnitOfWork.done() method when processing of an exchange is complete. |
class |
UnmarshalProcessor
Unmarshals the body of the incoming message using the given data format |
Fields in org.apache.camel.processor declared as Processor | |
---|---|
protected Processor |
DelegateProcessor.processor
|
Methods in org.apache.camel.processor that return Processor | |
---|---|
Processor |
DeadLetterChannel.getDeadLetter()
Returns the dead letter that message exchanges will be sent to if the redelivery attempts fail |
Processor |
Interceptor.getInterceptorLogic()
|
Processor |
ChoiceProcessor.getOtherwise()
|
Processor |
DeadLetterChannel.getOutput()
Returns the output processor |
Processor |
LoggingErrorHandler.getOutput()
Returns the output processor |
Processor |
DelegateProcessor.getProcessor()
|
Processor |
BatchProcessor.getProcessor()
|
static Processor |
Pipeline.newInstance(List<Processor> processors)
|
Methods in org.apache.camel.processor that return types with arguments of type Processor | ||
---|---|---|
Collection<Processor> |
CompositeProcessor.getProcessors()
|
|
Collection<Processor> |
MulticastProcessor.getProcessors()
Returns the producers to multicast to |
|
static
|
MulticastProcessor.toProducers(Collection<Endpoint> endpoints)
A helper method to convert a list of endpoints into a list of processors |
Methods in org.apache.camel.processor with parameters of type Processor | |
---|---|
protected Exchange |
Pipeline.createNextExchange(Processor producer,
Exchange previousExchange)
Strategy method to create the next exchange from the previous exchange. |
void |
Interceptor.setInterceptorLogic(Processor interceptorLogic)
|
void |
DelegateProcessor.setProcessor(Processor processor)
|
Method parameters in org.apache.camel.processor with type arguments of type Processor | |
---|---|
static Processor |
Pipeline.newInstance(List<Processor> processors)
|
Constructors in org.apache.camel.processor with parameters of type Processor | |
---|---|
Aggregator(Endpoint endpoint,
Processor processor,
AggregationCollection collection)
|
|
Aggregator(Endpoint endpoint,
Processor processor,
Expression correlationExpression,
AggregationStrategy aggregationStrategy)
|
|
Aggregator(Endpoint endpoint,
Processor processor,
Expression correlationExpression,
AggregationStrategy aggregationStrategy,
Predicate aggregationCompletedPredicate)
|
|
BatchProcessor(Endpoint endpoint,
Processor processor,
Collection<Exchange> collection)
|
|
CatchProcessor(List<Class> exceptions,
Processor processor)
|
|
ChoiceProcessor(List<FilterProcessor> filters,
Processor otherwise)
|
|
DeadLetterChannel(Processor output,
Processor deadLetter)
|
|
DeadLetterChannel(Processor output,
Processor deadLetter,
RedeliveryPolicy redeliveryPolicy,
Logger logger,
ExceptionPolicyStrategy exceptionPolicyStrategy)
|
|
Delayer(Processor processor,
Expression<Exchange> timeExpression,
long delay)
|
|
DelayProcessorSupport(Processor processor)
|
|
DelegateProcessor(Processor processor)
|
|
FilterProcessor(Predicate<Exchange> predicate,
Processor processor)
|
|
Interceptor(Processor interceptorLogic)
|
|
LoggingErrorHandler(Processor output)
|
|
LoggingErrorHandler(Processor output,
org.apache.commons.logging.Log log,
LoggingLevel level)
|
|
Resequencer(Endpoint endpoint,
Processor processor,
Expression<Exchange> expression)
|
|
Resequencer(Endpoint endpoint,
Processor processor,
List<Expression> expressions)
|
|
Resequencer(Endpoint endpoint,
Processor processor,
Set<Exchange> collection)
|
|
Splitter(Expression expression,
Processor destination,
AggregationStrategy aggregationStrategy)
|
|
Splitter(Expression expression,
Processor destination,
AggregationStrategy aggregationStrategy,
boolean parallelProcessing,
ThreadPoolExecutor threadPoolExecutor,
boolean streaming)
|
|
StreamResequencer(Processor processor,
SequenceElementComparator<Exchange> comparator,
int capacity)
Creates a new StreamResequencer instance. |
|
Throttler(Processor processor,
long maximumRequestsPerPeriod)
|
|
Throttler(Processor processor,
long maximumRequestsPerPeriod,
long timePeriodMillis)
|
|
TransformProcessor(Expression expression,
Processor childProcessor)
|
|
TryProcessor(Processor tryProcessor,
List<CatchProcessor> catchClauses,
Processor finallyProcessor)
|
Constructor parameters in org.apache.camel.processor with type arguments of type Processor | |
---|---|
CompositeProcessor(Collection<Processor> processors)
|
|
MulticastProcessor(Collection<Processor> processors)
|
|
MulticastProcessor(Collection<Processor> processors,
AggregationStrategy aggregationStrategy)
|
|
MulticastProcessor(Collection<Processor> processors,
AggregationStrategy aggregationStrategy,
boolean parallelProcessing,
ThreadPoolExecutor executor)
|
|
Pipeline(Collection<Processor> processors)
|
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.getNextProcessor()
|
Constructors in org.apache.camel.processor.idempotent with parameters of type Processor | |
---|---|
IdempotentConsumer(Expression<Exchange> messageIdExpression,
MessageIdRepository messageIdRepository,
Processor nextProcessor)
|
Uses of Processor in org.apache.camel.processor.interceptor |
---|
Classes in org.apache.camel.processor.interceptor that implement Processor | |
---|---|
class |
DebugInterceptor
An interceptor for debugging and tracing routes |
class |
StreamCachingInterceptor
Interceptor that converts a message into a re-readable format |
class |
TraceInterceptor
An interceptor for debugging and tracing routes |
Methods in org.apache.camel.processor.interceptor that return Processor | |
---|---|
Processor |
Tracer.wrapProcessorInInterceptors(ProcessorType processorType,
Processor target)
|
Processor |
Debugger.wrapProcessorInInterceptors(ProcessorType processorType,
Processor target)
|
Methods in org.apache.camel.processor.interceptor with parameters of type Processor | |
---|---|
Processor |
Tracer.wrapProcessorInInterceptors(ProcessorType processorType,
Processor target)
|
Processor |
Debugger.wrapProcessorInInterceptors(ProcessorType processorType,
Processor target)
|
Constructors in org.apache.camel.processor.interceptor with parameters of type Processor | |
---|---|
DebugInterceptor(ProcessorType node,
Processor target,
List<Exchange> exchanges,
List<ExceptionEvent> exceptions)
|
|
StreamCachingInterceptor(Processor processor)
|
|
TraceInterceptor(ProcessorType node,
Processor target,
TraceFormatter formatter)
|
|
TraceInterceptor(ProcessorType node,
Processor target,
TraceFormatter formatter,
Tracer tracer)
|
|
TraceInterceptor(ProcessorType node,
Processor target,
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 |
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 |
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) |
Methods in org.apache.camel.processor.loadbalancer that return Processor | |
---|---|
protected abstract Processor |
QueueLoadBalancer.chooseProcessor(List<Processor> processors,
Exchange exchange)
|
protected Processor |
RandomLoadBalancer.chooseProcessor(List<Processor> processors,
Exchange exchange)
|
protected Processor |
StickyLoadBalancer.chooseProcessor(List<Processor> processors,
Exchange exchange)
|
protected Processor |
RoundRobinLoadBalancer.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 |
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 abstract Processor |
QueueLoadBalancer.chooseProcessor(List<Processor> processors,
Exchange exchange)
|
protected Processor |
RandomLoadBalancer.chooseProcessor(List<Processor> processors,
Exchange exchange)
|
protected Processor |
StickyLoadBalancer.chooseProcessor(List<Processor> processors,
Exchange exchange)
|
protected Processor |
RoundRobinLoadBalancer.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.resequencer |
---|
Constructors in org.apache.camel.processor.resequencer with parameters of type Processor | |
---|---|
SequenceSender(Processor processor)
Creates a new SequenceSender thread. |
Uses of Processor in org.apache.camel.processor.validation |
---|
Classes in org.apache.camel.processor.validation that implement Processor | |
---|---|
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 |
RouteContext.createProceedProcessor()
Creates a proceed processor |
Processor |
RouteContext.createProcessor(ProcessorType node)
Creates a processor |
Processor |
Policy.wrap(Processor processor)
Wraps any applicable interceptors around the given processor |
Processor |
ErrorHandlerWrappingStrategy.wrapProcessorInErrorHandler(RouteContext routeContext,
ProcessorType processorType,
Processor target)
This method is invoked by ProcessorType.wrapProcessor(RouteContext, Processor)
to give the implementor an opportunity to wrap the target processor
in a route. |
Processor |
InterceptStrategy.wrapProcessorInInterceptors(ProcessorType processorType,
Processor target)
This method is invoked by ProcessorType.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 |
Processor |
Policy.wrap(Processor processor)
Wraps any applicable interceptors around the given processor |
Processor |
ErrorHandlerWrappingStrategy.wrapProcessorInErrorHandler(RouteContext routeContext,
ProcessorType processorType,
Processor target)
This method is invoked by ProcessorType.wrapProcessor(RouteContext, Processor)
to give the implementor an opportunity to wrap the target processor
in a route. |
Processor |
InterceptStrategy.wrapProcessorInInterceptors(ProcessorType processorType,
Processor target)
This method is invoked by ProcessorType.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 |
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. |
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |