Uses of Interface
org.apache.camel.Processor

Packages that use Processor
org.apache.camel The JAXB POJOs for the XML Configuration of the routing rules. 
org.apache.camel.builder The Camel Domain Specific Language for creating Routes, Predicates, Expressions and Error Handlers
org.apache.camel.builder.xml Support for XPath based Expressions and Predicates as well as an XSLT processor 
org.apache.camel.component.bean The Bean Component which will look up the bean name in the Spring ApplicationContext and use that to dispatch messages to a POJO 
org.apache.camel.component.browse The Browse Component which is a simple in memory component which maintains a list of all message exchanges which can be useful for debugging, tooling or visualistion. 
org.apache.camel.component.dataset A DataSet Endpoint for testing of endpoints using defined DataSets 
org.apache.camel.component.direct The Direct Component which synchronously invokes all the consumers when a producer sends an exchange to the endpoint. 
org.apache.camel.component.file The File Component for working with file systems. 
org.apache.camel.component.jmx The JMX Component for monitoring JMX Attributes uisng a CounterMonitor. 
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 Processors in the route graph.
 interface Producer
          Provides a channel on which clients can create and invoke message exchanges on an Endpoint
 

Methods in org.apache.camel that return Processor
 Processor Channel.getErrorHandler()
          Gets the ErrorHandler this Channel uses.
 Processor 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.
 

Methods in org.apache.camel that return types with arguments of type Processor
 Navigate<Processor> Route.navigate()
          Returns a navigator to navigate this route by navigating all the Processors.
 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
 

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 DeadLetterChannelBuilder.getFailureProcessor()
           
 Processor DeadLetterChannelBuilder.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)
           
 DeadLetterChannelBuilder DeadLetterChannelBuilder.onRedelivery(Processor processor)
          Sets a processor that should be processed before a redelivey attempt.
 void DeadLetterChannelBuilder.setFailureProcessor(Processor failureProcessor)
           
 void DeadLetterChannelBuilder.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)
           
 

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.jmx
 

Methods in org.apache.camel.component.jmx with parameters of type Processor
 Consumer 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.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 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)
           
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
           
 

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 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 AggregateDefinition.createProcessor(RouteContext routeContext)
           
 Processor OnExceptionDefinition.getErrorHandler()
           
 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 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 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 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 Exchanges.
 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 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 DefaultChannel.getErrorHandler()
           
 Processor WireTapProcessor.getNewExchangeProcessor()
           
 Processor DefaultChannel.getNextProcessor()
           
 Processor ChoiceProcessor.getOtherwise()
           
 Processor LoggingErrorHandler.getOutput()
          Returns the output processor
 Processor DefaultErrorHandler.getOutput()
          Returns the output processor
 Processor DefaultChannel.getOutput()
           
 Processor DeadLetterChannel.getOutput()
          Returns the output processor
 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)
           
 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)
           
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, Processor deadLetter, String deadLetterUri, Processor redeliveryProcessor, RedeliveryPolicy redeliveryPolicy, Logger logger, ExceptionPolicyStrategy exceptionPolicyStrategy, Predicate handledPolicy, boolean useOriginalBodyPolicy)
          Creates the dead letter channel.
DefaultErrorHandler(Processor output, ExceptionPolicyStrategy exceptionPolicyStrategy)
           
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 onComplete, boolean onFailure, Predicate onWhen)
           
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 DebugInterceptor
          An interceptor for debugging and tracing routes
 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)
           
 Processor Debugger.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)
           
 Processor Debugger.wrapProcessorInInterceptors(ProcessorDefinition processorDefinition, Processor target, Processor nextTarget)
           
 

Constructors in org.apache.camel.processor.interceptor with parameters of type Processor
DebugInterceptor(ProcessorDefinition node, Processor target, List<Exchange> exchanges, List<ExceptionEvent> exceptions)
           
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.
 



Copyright © 2009 Apache Software Foundation. All Rights Reserved.