|
||||||||||
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 | |
---|---|
protected Processor |
CamelTemplate.createBodyAndHeaderProcessor(Object body,
String header,
Object headerValue)
|
protected Processor |
CamelTemplate.createSetBodyProcessor(Object body)
|
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 |
CamelTemplate.request(Endpoint<E> endpoint,
Processor processor)
Send the body to an endpoint returning any result output body |
E |
ProducerTemplate.request(Endpoint<E> endpoint,
Processor processor)
Send the body to an endpoint returning any result output body |
E |
CamelTemplate.request(String endpoint,
Processor processor)
Send the body to an endpoint returning any result output body |
E |
ProducerTemplate.request(String endpoint,
Processor processor)
Send the body to an endpoint returning any result output body |
E |
CamelTemplate.send(Endpoint<E> endpoint,
ExchangePattern pattern,
Processor processor)
Sends an exchange to an endpoint using a supplied |
E |
ProducerTemplate.send(Endpoint<E> endpoint,
ExchangePattern pattern,
Processor processor)
Sends an exchange to an endpoint using a supplied |
E |
CamelTemplate.send(Endpoint<E> endpoint,
Processor processor)
Sends an exchange to an endpoint using a supplied |
E |
ProducerTemplate.send(Endpoint<E> endpoint,
Processor processor)
Sends an exchange to an endpoint using a supplied |
E |
CamelTemplate.send(Endpoint<E> endpoint,
Processor processor,
AsyncCallback callback)
Sends an exchange to an endpoint using a supplied |
E |
CamelTemplate.send(Processor processor)
Sends an exchange to the default endpoint using a supplied |
E |
ProducerTemplate.send(Processor processor)
Sends an exchange to the default endpoint using a supplied |
E |
CamelTemplate.send(String endpointUri,
ExchangePattern pattern,
Processor processor)
Sends an exchange to an endpoint using a supplied |
E |
ProducerTemplate.send(String endpointUri,
ExchangePattern pattern,
Processor processor)
Sends an exchange to an endpoint using a supplied |
E |
CamelTemplate.send(String endpointUri,
Processor processor)
Sends an exchange to an endpoint using a supplied |
E |
ProducerTemplate.send(String endpointUri,
Processor processor)
Sends an exchange to an endpoint using a supplied |
E |
CamelTemplate.send(String endpointUri,
Processor processor,
AsyncCallback callback)
Sends an exchange to an endpoint using a supplied |
Uses of Processor in org.apache.camel.builder |
---|
Methods in org.apache.camel.builder that return Processor | |
---|---|
Processor |
DeadLetterChannelBuilder.createErrorHandler(Processor processor)
|
Processor |
ErrorHandlerBuilder.createErrorHandler(Processor processor)
Creates the error handler interceptor |
Processor |
NoErrorHandlerBuilder.createErrorHandler(Processor processor)
|
Processor |
LoggingErrorHandlerBuilder.createErrorHandler(Processor processor)
|
Processor |
ProcessorFactory.createProcessor()
|
Processor |
ConstantProcessorBuilder.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 |
DeadLetterChannelBuilder.createErrorHandler(Processor processor)
|
Processor |
ErrorHandlerBuilder.createErrorHandler(Processor processor)
Creates the error handler interceptor |
Processor |
NoErrorHandlerBuilder.createErrorHandler(Processor processor)
|
Processor |
LoggingErrorHandlerBuilder.createErrorHandler(Processor processor)
|
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 |
BeanProcessor.getProcessor()
|
Processor |
RegistryBean.getProcessor()
|
Processor |
BeanHolder.getProcessor()
|
Processor |
ConstantBeanHolder.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>
|
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
A Producer implementation for File |
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 | |
---|---|
Processor |
RouteContext.createProceedProcessor()
|
Processor |
RouteContext.createProcessor(ProcessorType node)
|
Processor |
DefaultConsumer.getProcessor()
|
Processor |
ProcessorEndpoint.getProcessor()
|
Processor |
EventDrivenConsumerRoute.getProcessor()
|
Processor |
NoPolicy.wrap(Processor processor)
|
Methods in org.apache.camel.impl with parameters of type Processor | |
---|---|
void |
RouteContext.addEventDrivenProcessor(Processor processor)
|
Consumer<E> |
DefaultPollingEndpoint.createConsumer(Processor processor)
|
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 |
---|
Classes in org.apache.camel.impl.converter that implement Processor | |
---|---|
static class |
AsyncProcessorTypeConverter.ProcessorToAsynProcessorBridge
|
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
|
Uses of Processor in org.apache.camel.model |
---|
Methods in org.apache.camel.model that return Processor | |
---|---|
protected Processor |
ProcessorType.createCompositeProcessor(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 |
MulticastType.createCompositeProcessor(List<Processor> list)
|
Processor |
ProcessorType.createOutputsProcessor(RouteContext routeContext)
|
protected Processor |
ProcessorType.createOutputsProcessor(RouteContext routeContext,
Collection<ProcessorType<?>> outputs)
|
protected Processor |
LoadBalanceType.createOutputsProcessor(RouteContext routeContext,
Collection<ProcessorType<?>> outputs)
|
Processor |
ToType.createProcessor(RouteContext routeContext)
|
Processor |
ProcessorRef.createProcessor(RouteContext routeContext)
|
Processor |
MarshalType.createProcessor(RouteContext routeContext)
|
Processor |
IdempotentConsumerType.createProcessor(RouteContext routeContext)
|
Processor |
RoutingSlipType.createProcessor(RouteContext routeContext)
|
Processor |
InterceptorRef.createProcessor(RouteContext routeContext)
|
Processor |
BeanRef.createProcessor(RouteContext routeContext)
|
Processor |
DelayerType.createProcessor(RouteContext routeContext)
|
Processor |
PolicyRef.createProcessor(RouteContext routeContext)
|
Processor |
TryType.createProcessor(RouteContext routeContext)
|
Processor |
ThreadType.createProcessor(RouteContext routeContext)
|
Processor |
FinallyType.createProcessor(RouteContext routeContext)
|
Processor |
TransformType.createProcessor(RouteContext routeContext)
|
Processor |
RecipientListType.createProcessor(RouteContext routeContext)
|
Processor |
ChoiceType.createProcessor(RouteContext routeContext)
|
Processor |
UnmarshalType.createProcessor(RouteContext routeContext)
|
Processor |
ProceedType.createProcessor(RouteContext routeContext)
|
Processor |
ThrottlerType.createProcessor(RouteContext routeContext)
|
Processor |
ThrowFaultType.createProcessor(RouteContext routeContext)
|
Processor |
OtherwiseType.createProcessor(RouteContext routeContext)
|
Processor |
SetHeaderType.createProcessor(RouteContext routeContext)
|
Processor |
ConvertBodyType.createProcessor(RouteContext routeContext)
|
Processor |
SplitterType.createProcessor(RouteContext routeContext)
|
Processor |
ProcessorType.createProcessor(RouteContext routeContext)
|
Processor |
MulticastType.createProcessor(RouteContext routeContext)
|
Processor |
ResequencerType.createProcessor(RouteContext routeContext)
|
Processor |
InterceptType.createProcessor(RouteContext routeContext)
|
Processor |
LoadBalanceType.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(Processor processor)
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 |
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(Processor processor)
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 |
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 |
ProcessorType.createCompositeProcessor(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 |
MulticastType.createCompositeProcessor(List<Processor> list)
|
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
|
class |
RandomLoadBalanceStrategy
|
class |
RoundRobinLoadBalanceStrategy
|
class |
StickyLoadBalanceStrategy
|
class |
TopicLoadBalanceStrategy
|
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 |
CatchProcessor
|
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
|
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 |
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
|
class |
SetHeaderProcessor
A processor which sets the header on the IN message |
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
|
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 |
BatchProcessor.getProcessor()
|
Processor |
DelegateProcessor.getProcessor()
|
static Processor |
Pipeline.newInstance(List<Processor> processors)
|
Methods in org.apache.camel.processor that return types with arguments of type Processor | ||
---|---|---|
Collection<Processor> |
MulticastProcessor.getProcessors()
Returns the producers to multicast to |
|
Collection<Processor> |
CompositeProcessor.getProcessors()
|
|
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 |
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,
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)
|
|
SetHeaderProcessor(String name,
Expression expression,
Processor childProcessor)
|
|
Splitter(Expression expression,
Processor destination,
AggregationStrategy aggregationStrategy)
|
|
Splitter(Expression expression,
Processor destination,
AggregationStrategy aggregationStrategy,
boolean parallelProcessing,
ThreadPoolExecutor threadPoolExecutor)
|
|
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 |
StreamCachingInterceptor
Interceptor that converts a message into a re-readable format |
Constructors in org.apache.camel.processor.interceptor with parameters of type Processor | |
---|---|
StreamCachingInterceptor(Processor processor)
|
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 Processor |
StickyLoadBalancer.chooseProcessor(List<Processor> processors,
Exchange exchange)
|
protected Processor |
RandomLoadBalancer.chooseProcessor(List<Processor> processors,
Exchange exchange)
|
protected Processor |
RoundRobinLoadBalancer.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 |
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 |
StickyLoadBalancer.chooseProcessor(List<Processor> processors,
Exchange exchange)
|
protected Processor |
RandomLoadBalancer.chooseProcessor(List<Processor> processors,
Exchange exchange)
|
protected Processor |
RoundRobinLoadBalancer.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.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 |
Policy.wrap(Processor processor)
Wraps any applicable interceptors around the given processor |
Methods in org.apache.camel.spi with parameters of type Processor | |
---|---|
Processor |
Policy.wrap(Processor processor)
Wraps any applicable interceptors around the given processor |
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. |
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 |
ProducerCache.send(Endpoint<E> endpoint,
Processor processor)
Sends an exchange to an endpoint using a supplied Processor to populate the exchange |
E |
ProducerCache.send(Endpoint<E> endpoint,
Processor processor,
AsyncCallback callback)
Sends an exchange to an endpoint using a supplied Processor to populate the exchange. |
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)
|
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |