|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
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.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.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.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 |
Channel
Channel acts as a channel between Processor s 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 |
Intercept.getInterceptorLogic()
|
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 Processor s. |
List<Processor> |
Channel.next()
|
Methods in org.apache.camel with parameters of type Processor | |
---|---|
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 |
Exchange |
ProducerTemplate.send(Endpoint endpoint,
Processor processor)
Sends an exchange to an endpoint using a supplied processor |
Exchange |
ProducerTemplate.send(Processor processor)
Sends an exchange to the default endpoint using a supplied processor |
Exchange |
ProducerTemplate.send(String endpointUri,
ExchangePattern pattern,
Processor processor)
Sends an exchange to an endpoint using a supplied processor |
Exchange |
ProducerTemplate.send(String endpointUri,
Processor processor)
Sends an exchange to an endpoint using a supplied processor |
void |
Channel.setErrorHandler(Processor errorHandler)
Sets the ErrorHandler this Channel uses. |
void |
Intercept.setInterceptorLogic(Processor interceptorLogic)
|
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)
Removes the header on the FAULT message |
static Processor |
ProcessorBuilder.removeHeader(String name)
Removes the header on the IN 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 |
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 redelivey 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 |
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 |
SimpleDataSet.getInputTransformer()
|
Processor |
DataSetSupport.getOutputTransformer()
|
Methods in org.apache.camel.component.dataset with parameters of type Processor | |
---|---|
Consumer |
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
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 |
Methods in org.apache.camel.component.file with parameters of type Processor | |
---|---|
abstract GenericFileConsumer<T> |
GenericFileEndpoint.createConsumer(Processor processor)
|
FileConsumer |
FileEndpoint.createConsumer(Processor processor)
|
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.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
A simple Producer which just appends to a Collection the Exchange object. |
class |
SedaProducer
|
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 |
DefaultProducer
A default implementation of @{link Producer} for implementation inheritence |
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 |
ProducerTemplateProcessor
A simple processor which just sends the message exchange to the default endpoint of the ProducerTemplate |
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 |
EventDrivenConsumerRoute.getProcessor()
|
Processor |
DefaultRouteNode.getProcessor()
|
Processor |
DefaultConsumer.getProcessor()
|
Processor |
NoPolicy.wrap(RouteContext routeContext,
Processor processor)
|
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)
|
Future<Exchange> |
DefaultProducerTemplate.asyncSend(String uri,
Processor processor)
|
Consumer |
InterceptSendToEndpoint.createConsumer(Processor processor)
|
Consumer |
DefaultPollingEndpoint.createConsumer(Processor processor)
|
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)
|
Processor |
NoPolicy.wrap(RouteContext routeContext,
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(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 endpoint,
Processor processor)
|
|
ScheduledPollConsumer(Endpoint endpoint,
Processor processor,
ScheduledExecutorService executor)
|
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 |
InstrumentationInterceptStrategy.wrapProcessorInInterceptors(ProcessorDefinition processorDefinition,
Processor target,
Processor nextTarget)
|
Methods in org.apache.camel.management with parameters of type Processor | |
---|---|
Processor |
InstrumentationInterceptStrategy.wrapProcessorInInterceptors(ProcessorDefinition processorDefinition,
Processor target,
Processor nextTarget)
|
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 | |
---|---|
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)
|
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 |
SetExchangePatternDefinition.createProcessor(RouteContext routeContext)
|
Processor |
SetBodyDefinition.createProcessor(RouteContext routeContext)
|
Processor |
SendDefinition.createProcessor(RouteContext routeContext)
|
Processor |
RoutingSlipDefinition.createProcessor(RouteContext routeContext)
|
Processor |
RollbackDefinition.createProcessor(RouteContext routeContext)
|
Processor |
ResequenceDefinition.createProcessor(RouteContext routeContext)
|
Processor |
RemovePropertyDefinition.createProcessor(RouteContext routeContext)
|
Processor |
RemoveHeaderDefinition.createProcessor(RouteContext routeContext)
|
Processor |
RecipientListDefinition.createProcessor(RouteContext routeContext)
|
Processor |
ProcessorDefinition.createProcessor(RouteContext routeContext)
|
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 |
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 |
DelayDefinition.createProcessor(RouteContext routeContext)
|
Processor |
ConvertBodyDefinition.createProcessor(RouteContext routeContext)
|
Processor |
ChoiceDefinition.createProcessor(RouteContext routeContext)
|
Processor |
BeanDefinition.createProcessor(RouteContext routeContext)
|
Processor |
AOPDefinition.createProcessor(RouteContext routeContext)
|
Processor |
AggregateDefinition.createProcessor(RouteContext routeContext)
|
Processor |
OnExceptionDefinition.getErrorHandler()
|
Processor |
InterceptDefinition.getInterceptedProcessor(int index)
|
Processor |
WireTapDefinition.getNewExchangeProcessor()
|
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)
|
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 | |
---|---|
List<Processor> |
LoadBalancerDefinition.getProcessors()
|
Methods in org.apache.camel.model with parameters of type Processor | |
---|---|
void |
LoadBalancerDefinition.addProcessor(Processor processor)
|
OnExceptionDefinition |
OnExceptionDefinition.onRedelivery(Processor processor)
Sets a processor that should be processed before a redelivey 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 |
OnExceptionDefinition.setOnRedelivery(Processor onRedelivery)
|
Type |
ProcessorDefinition.wireTap(String uri,
Processor processor)
WireTap EIP: Sends a new Exchange to the destination
using ExchangePattern.InOnly . |
protected Processor |
ProcessorDefinition.wrapChannel(RouteContext routeContext,
Processor processor)
|
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 |
FailoverLoadBalancerDefinition
|
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 |
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 |
AOPProcessor
|
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 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 |
DelegateProcessor
A Delegate pattern which delegates processing to a nested processor which can be useful for implementation inheritance when writing an Policy |
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 |
ExchangePatternProcessor
|
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 andpoint. |
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 |
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 |
RedeliveryErrorHandler
Base redeliverable error handler that also suppors 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 |
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 |
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 Exchange s. |
class |
ThreadsProcessor
Threads processor that leverage a thread pool for processing exchanges. |
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
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 |
class |
WireTapProcessor
Processor for wire tapping exchanges to an endpoint destination. |
Fields in org.apache.camel.processor declared as Processor | |
---|---|
protected Processor |
RedeliveryErrorHandler.deadLetter
|
protected Processor |
TryProcessor.finallyProcessor
|
protected Processor |
RedeliveryErrorHandler.output
|
protected Processor |
DelegateProcessor.processor
|
protected Processor |
RedeliveryErrorHandler.redeliveryProcessor
|
protected Processor |
TryProcessor.tryProcessor
|
Methods in org.apache.camel.processor that return Processor | |
---|---|
Processor |
RedeliveryErrorHandler.getDeadLetter()
Returns the dead letter that message exchanges will be sent to if the redelivery attempts fail |
Processor |
DefaultChannel.getErrorHandler()
|
Processor |
WireTapProcessor.getNewExchangeProcessor()
|
Processor |
DefaultChannel.getNextProcessor()
|
Processor |
ChoiceProcessor.getOtherwise()
|
Processor |
RedeliveryErrorHandler.getOutput()
Returns the output processor |
Processor |
LoggingErrorHandler.getOutput()
Returns the output processor |
Processor |
DefaultChannel.getOutput()
|
Processor |
StreamResequencer.getProcessor()
Returns the next 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> |
MulticastProcessor.getProcessors()
Returns the producers to multicast to |
Collection<Processor> |
CompositeProcessor.getProcessors()
|
List<Processor> |
TryProcessor.next()
|
List<Processor> |
StreamResequencer.next()
|
List<Processor> |
MulticastProcessor.next()
|
List<Processor> |
DelegateProcessor.next()
|
List<Processor> |
DefaultChannel.next()
|
List<Processor> |
CompositeProcessor.next()
|
List<Processor> |
ChoiceProcessor.next()
|
List<Processor> |
BatchProcessor.next()
|
Methods in org.apache.camel.processor with parameters of type Processor | |
---|---|
protected Callable<Exchange> |
ThreadsProcessor.createTask(Processor output,
Exchange copy)
|
protected void |
RedeliveryErrorHandler.deliverToFailureProcessor(Processor processor,
Exchange exchange,
RedeliveryErrorHandler.RedeliveryData data)
All redelivery attempts failed so move the exchange to the dead letter queue |
void |
DefaultChannel.setErrorHandler(Processor errorHandler)
|
void |
WireTapProcessor.setNewExchangeProcessor(Processor newExchangeProcessor)
|
void |
DefaultChannel.setNextProcessor(Processor next)
|
void |
DefaultChannel.setOutput(Processor output)
|
void |
DelegateProcessor.setProcessor(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(List<Processor> processors)
|
Constructors in org.apache.camel.processor with parameters of type Processor | |
---|---|
Aggregator(Processor processor,
AggregationCollection collection)
|
|
Aggregator(Processor processor,
Expression correlationExpression,
AggregationStrategy aggregationStrategy)
|
|
Aggregator(Processor processor,
Expression correlationExpression,
AggregationStrategy aggregationStrategy,
Predicate aggregationCompletedPredicate)
|
|
AOPProcessor(Processor tryProcessor,
List<CatchProcessor> catchClauses,
Processor finallyProcessor)
|
|
BatchProcessor(Processor processor,
Collection<Exchange> collection)
|
|
CatchProcessor(List<Class> exceptions,
Processor processor,
Predicate onWhen,
Predicate handled)
|
|
ChoiceProcessor(List<FilterProcessor> filters,
Processor otherwise)
|
|
DeadLetterChannel(Processor output,
Logger logger,
Processor redeliveryProcessor,
RedeliveryPolicy redeliveryPolicy,
Predicate handledPolicy,
ExceptionPolicyStrategy exceptionPolicyStrategy,
Processor deadLetter,
String deadLetterUri,
boolean useOriginalBodyPolicy)
Creates the dead letter channel. |
|
DefaultErrorHandler(Processor output,
Logger logger,
Processor redeliveryProcessor,
RedeliveryPolicy redeliveryPolicy,
Predicate handledPolicy,
ExceptionPolicyStrategy exceptionPolicyStrategy)
Creates the default error handler. |
|
Delayer(Processor processor,
Expression delay)
|
|
DelayProcessorSupport(Processor processor)
|
|
DelegateProcessor(Processor processor)
|
|
FilterProcessor(Predicate predicate,
Processor processor)
|
|
InterceptEndpointProcessor(String uri,
Processor processor)
|
|
LoggingErrorHandler(Processor output)
|
|
LoggingErrorHandler(Processor output,
org.apache.commons.logging.Log log,
LoggingLevel level)
|
|
LoopProcessor(Expression expression,
Processor processor)
|
|
OnCompletionProcessor(Processor processor,
boolean onCompleteOnly,
boolean onFailureOnly,
Predicate onWhen)
|
|
RedeliveryErrorHandler(Processor output,
Logger logger,
Processor redeliveryProcessor,
RedeliveryPolicy redeliveryPolicy,
Predicate handledPolicy,
Processor deadLetter,
String deadLetterUri,
boolean useOriginalMessagePolicy)
|
|
Resequencer(Processor processor,
Expression expression)
|
|
Resequencer(Processor processor,
List<Expression> expressions)
|
|
Resequencer(Processor processor,
Set<Exchange> collection)
|
|
Splitter(Expression expression,
Processor destination,
AggregationStrategy aggregationStrategy)
|
|
Splitter(Expression expression,
Processor destination,
AggregationStrategy aggregationStrategy,
boolean parallelProcessing,
ExecutorService executorService,
boolean streaming)
|
|
StreamResequencer(Processor processor,
SequenceElementComparator<Exchange> comparator)
Creates a new StreamResequencer instance. |
|
ThreadsProcessor(Processor output,
ExecutorService executorService,
WaitForTaskToComplete waitForTaskToComplete)
|
|
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)
|
|
UnitOfWorkProcessor(Processor processor)
|
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,
ExecutorService executorService,
boolean streaming)
|
|
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.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 idempotentRepository,
boolean eager,
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
DelegateProcessor 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(ProcessorDefinition processorDefinition,
Processor target,
Processor nextTarget)
|
Processor |
StreamCaching.wrapProcessorInInterceptors(ProcessorDefinition processorDefinition,
Processor target,
Processor nextTarget)
|
Processor |
HandleFault.wrapProcessorInInterceptors(ProcessorDefinition processorDefinition,
Processor target,
Processor nextTarget)
|
Processor |
Delayer.wrapProcessorInInterceptors(ProcessorDefinition processorDefinition,
Processor target,
Processor nextTarget)
|
Methods in org.apache.camel.processor.interceptor with parameters of type Processor | |
---|---|
Processor |
Tracer.wrapProcessorInInterceptors(ProcessorDefinition processorDefinition,
Processor target,
Processor nextTarget)
|
Processor |
StreamCaching.wrapProcessorInInterceptors(ProcessorDefinition processorDefinition,
Processor target,
Processor nextTarget)
|
Processor |
HandleFault.wrapProcessorInInterceptors(ProcessorDefinition processorDefinition,
Processor target,
Processor nextTarget)
|
Processor |
Delayer.wrapProcessorInInterceptors(ProcessorDefinition processorDefinition,
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)
|
|
TraceInterceptor(ProcessorDefinition 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 |
FailOverLoadBalancer
This FailOverLoadBalancer will failover to use next processor when an exception occured |
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 |
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 |
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 |
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.createProcessor(ProcessorDefinition node)
Creates a processor |
Processor |
Policy.wrap(RouteContext routeContext,
Processor processor)
Wraps any applicable interceptors around the given processor |
Processor |
InterceptStrategy.wrapProcessorInInterceptors(ProcessorDefinition processorDefinition,
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 |
Processor |
Policy.wrap(RouteContext routeContext,
Processor processor)
Wraps any applicable interceptors around the given processor |
Processor |
InterceptStrategy.wrapProcessorInInterceptors(ProcessorDefinition processorDefinition,
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 Future<Exchange> |
AsyncProcessorHelper.asyncProcess(ExecutorService executor,
Processor processor,
Exchange exchange)
Processes the exchange async. |
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 |