Uses of Interface
org.apache.camel.Processor

Packages that use Processor
org.apache.camel The core Camel API 
org.apache.camel.builder The Camel Domain Specific Language for creating Routes, Predicates, Expressions and Error Handlers
org.apache.camel.builder.xml Support for XPath based Expressions and Predicates as well as an XSLT processor 
org.apache.camel.component.bean The Bean Component which will look up the bean name in the Spring ApplicationContext and use that to dispatch messages to a POJO 
org.apache.camel.component.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.impl Default implementation classes for Camel Core 
org.apache.camel.model Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. 
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.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 Producer<E extends Exchange>
          Provides a channel on which clients can create and invoke message exchanges on an Endpoint
 

Methods in org.apache.camel with parameters of type Processor
 Consumer<E> Endpoint.createConsumer(Processor processor)
          Creates a new Event Driven Consumer which consumes messages from the endpoint using the given processor
 E ProducerTemplate.send(Endpoint<E> endpoint, Processor processor)
          Sends an exchange to an endpoint using a supplied
 E CamelTemplate.send(Endpoint<E> endpoint, Processor processor)
          Sends an exchange to an endpoint using a supplied
 E ProducerTemplate.send(Processor processor)
          Sends an exchange to the default endpoint using a supplied
 E CamelTemplate.send(Processor processor)
          Sends an exchange to the default endpoint using a supplied
 E ProducerTemplate.send(String endpointUri, Processor processor)
          Sends an exchange to an endpoint using a supplied
 E CamelTemplate.send(String endpointUri, Processor processor)
          Sends an exchange to an endpoint using a supplied
 

Uses of Processor in org.apache.camel.builder
 

Methods in org.apache.camel.builder that return Processor
 Processor DeadLetterChannelBuilder.createErrorHandler(Processor processor)
           
 Processor LoggingErrorHandlerBuilder.createErrorHandler(Processor processor)
           
 Processor NoErrorHandlerBuilder.createErrorHandler(Processor processor)
           
 Processor ErrorHandlerBuilder.createErrorHandler(Processor processor)
          Creates the error handler interceptor
 Processor ConstantProcessorBuilder.createProcessor()
           
 Processor ProcessorFactory.createProcessor()
           
 Processor DeadLetterChannelBuilder.getDefaultDeadLetterEndpoint()
           
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.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 IN 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
 

Methods in org.apache.camel.builder with parameters of type Processor
 Processor DeadLetterChannelBuilder.createErrorHandler(Processor processor)
           
 Processor LoggingErrorHandlerBuilder.createErrorHandler(Processor processor)
           
 Processor NoErrorHandlerBuilder.createErrorHandler(Processor processor)
           
 Processor ErrorHandlerBuilder.createErrorHandler(Processor processor)
          Creates the error handler interceptor
 void DeadLetterChannelBuilder.setDefaultDeadLetterEndpoint(Processor defaultDeadLetterEndpoint)
          Sets the default dead letter endpoint used
 

Constructors in org.apache.camel.builder with parameters of type Processor
ConstantProcessorBuilder(Processor processor)
           
DeadLetterChannelBuilder(Processor processor)
           
 

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

Classes in org.apache.camel.builder.xml that implement Processor
 class XsltBuilder
          Creates a Processor which performs an XSLT transformation of the IN message body
 

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

Classes in org.apache.camel.component.bean that implement Processor
 class BeanProcessor
          A Processor which converts the inbound exchange to a method invocation on a POJO
 

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

Methods in org.apache.camel.component.direct with parameters of type Processor
 Consumer<E> DirectEndpoint.createConsumer(Processor processor)
           
 

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

Classes in org.apache.camel.component.file that implement Processor
 class FileProducer
          A Producer implementation for File
 

Methods in org.apache.camel.component.file with parameters of type Processor
 Consumer<FileExchange> FileEndpoint.createConsumer(Processor file)
           
 

Constructors in org.apache.camel.component.file with parameters of type Processor
FileConsumer(FileEndpoint endpoint, Processor processor)
           
 

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

Methods in org.apache.camel.component.jmx with parameters of type Processor
 Consumer<JMXExchange> JMXEndpoint.createConsumer(Processor proc)
           
 

Constructors in org.apache.camel.component.jmx with parameters of type Processor
JMXConsumer(JMXEndpoint endpoint, Processor processor)
           
 

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

Methods in org.apache.camel.component.mock with parameters of type Processor
 Consumer<Exchange> MockEndpoint.createConsumer(Processor processor)
           
 

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

Methods in org.apache.camel.component.seda with parameters of type Processor
 Consumer<E> SedaEndpoint.createConsumer(Processor processor)
           
 

Constructors in org.apache.camel.component.seda with parameters of type Processor
SedaConsumer(SedaEndpoint<E> 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<BeanExchange> 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.impl
 

Classes in org.apache.camel.impl that implement Processor
 class DefaultPollingConsumer<E extends Exchange>
          A default implementation of the PollingConsumer which uses the normal asynchronous consumer mechanism along with a BlockingQueue to allow the caller to pull messages on demand.
 class DefaultProducer<E extends Exchange>
          A default implementation of @{link Producer} for implementation inheritence
 

Methods in org.apache.camel.impl that return Processor
 Processor RouteContext.createProceedProcessor()
           
 Processor RouteContext.createProcessor(ProcessorType node)
           
 Processor ProcessorEndpoint.getProcessor()
           
 Processor EventDrivenConsumerRoute.getProcessor()
           
 Processor DefaultConsumer.getProcessor()
           
 Processor NoPolicy.wrap(Processor processor)
           
 

Methods in org.apache.camel.impl with parameters of type Processor
 void RouteContext.addEventDrivenProcessor(Processor processor)
           
 Consumer<Exchange> ProcessorEndpoint.createConsumer(Processor processor)
           
 void EventDrivenConsumerRoute.setProcessor(Processor processor)
           
 Processor NoPolicy.wrap(Processor processor)
           
 

Constructors in org.apache.camel.impl with parameters of type Processor
DefaultConsumer(Endpoint<E> endpoint, Processor processor)
           
EventDrivenConsumerRoute(Endpoint endpoint, Processor processor)
           
ProcessorEndpoint(String endpointUri, CamelContext context, Processor processor)
           
ProcessorEndpoint(String endpointUri, Component component, Processor processor)
           
ScheduledPollConsumer(DefaultEndpoint<E> endpoint, Processor processor)
           
ScheduledPollConsumer(Endpoint<E> endpoint, Processor processor, ScheduledExecutorService executor)
           
 

Uses of Processor in org.apache.camel.model
 

Methods in org.apache.camel.model that return Processor
protected  Processor MulticastType.createCompositeProcessor(List<Processor> list)
           
protected  Processor ProcessorType.createCompositeProcessor(List<Processor> list)
          Creates a new instance of some kind of composite processor which defaults to using a Pipeline but derived classes could change the behaviour
 Processor ProcessorType.createOutputsProcessor(RouteContext routeContext)
           
protected  Processor ProcessorType.createOutputsProcessor(RouteContext routeContext, Collection<ProcessorType> outputs)
           
 Processor BeanRef.createProcessor(RouteContext routeContext)
           
 Processor ProcessorRef.createProcessor(RouteContext routeContext)
           
 Processor ProceedType.createProcessor(RouteContext routeContext)
           
 Processor RecipientListType.createProcessor(RouteContext routeContext)
           
 Processor ToType.createProcessor(RouteContext routeContext)
           
 Processor FinallyType.createProcessor(RouteContext routeContext)
           
 Processor PolicyRef.createProcessor(RouteContext routeContext)
           
 Processor ThrottlerType.createProcessor(RouteContext routeContext)
           
 Processor DelayerType.createProcessor(RouteContext routeContext)
           
 Processor SplitterType.createProcessor(RouteContext routeContext)
           
 Processor TryType.createProcessor(RouteContext routeContext)
           
 Processor ChoiceType.createProcessor(RouteContext routeContext)
           
 Processor IdempotentConsumerType.createProcessor(RouteContext routeContext)
           
 Processor MulticastType.createProcessor(RouteContext routeContext)
           
 Processor OtherwiseType.createProcessor(RouteContext routeContext)
           
 Processor ProcessorType.createProcessor(RouteContext routeContext)
           
 Processor ExceptionType.getErrorHandler()
           
protected  Processor ProcessorType.makeProcessor(RouteContext routeContext)
          Creates the processor and wraps it in any necessary interceptors and error handlers
protected  Processor ProcessorType.wrapInErrorHandler(Processor processor)
          A strategy method to allow newly created processors to be wrapped in an error handler.
 Processor ProcessorType.wrapProcessor(RouteContext routeContext, Processor processor)
          Wraps the child processor in whatever necessary interceptors and error handlers
protected  Processor ProcessorType.wrapProcessorInInterceptors(RouteContext routeContext, Processor target)
          A strategy method which allows derived classes to wrap the child processor in some kind of interceptor
 

Methods in org.apache.camel.model with parameters of type Processor
 TryType TryType.process(Processor processor)
           
 ProcessorType ProcessorType.process(Processor processor)
          Adds the custom processor to this destination which could be a final destination, or could be a transformation in a pipeline
protected  Processor ProcessorType.wrapInErrorHandler(Processor processor)
          A strategy method to allow newly created processors to be wrapped in an error handler.
 Processor ProcessorType.wrapProcessor(RouteContext routeContext, Processor processor)
          Wraps the child processor in whatever necessary interceptors and error handlers
protected  Processor ProcessorType.wrapProcessorInInterceptors(RouteContext routeContext, Processor target)
          A strategy method which allows derived classes to wrap the child processor in some kind of interceptor
 

Method parameters in org.apache.camel.model with type arguments of type Processor
protected  Processor MulticastType.createCompositeProcessor(List<Processor> list)
           
protected  Processor ProcessorType.createCompositeProcessor(List<Processor> list)
          Creates a new instance of some kind of composite processor which defaults to using a Pipeline but derived classes could change the behaviour
 

Constructors in org.apache.camel.model with parameters of type Processor
ProcessorRef(Processor processor)
           
 

Uses of Processor in org.apache.camel.processor
 

Subinterfaces of Processor in org.apache.camel.processor
 interface ErrorHandler
          An interface used to represent an error handler
 

Classes in org.apache.camel.processor that implement Processor
 class CatchProcessor
           
 class ChoiceProcessor
          Implements a Choice structure where one or more predicates are used which if they are true their processors are used, with a default otherwise clause used if none match.
 class CompositeProcessor
          Represents a composite pattern, aggregating a collection of processors together as a single processor
 class DeadLetterChannel
          Implements a Dead Letter Channel after attempting to redeliver the message using the RedeliveryPolicy
 class Delayer
          A Delayer which delays processing the exchange until the correct amount of time has elapsed using an expression to determine the delivery time.
 class DelayProcessorSupport
          A useful base class for any processor which provides some kind of throttling or delayed processing
 class DelegateProcessor
          A Delegate pattern which delegates processing to a nested processor which can be useful for implementation inheritance when writing an Policy
 class ErrorHandlerSupport
           
 class FilterProcessor
           
 class Interceptor
          An interceptor which provides the processing logic as a pluggable processor which allows the DelegateProcessor.proceed(Exchange) method to be called at some point
 class Logger
          A Processor which just logs to a Log object which can be used as an exception handler instead of using a dead letter queue.
 class LoggingErrorHandler
          An ErrorHandler which uses commons-logging to dump the error
 class MulticastProcessor
          Implements the Multicast pattern to send a message exchange to a number of endpoints, each endpoint receiving a copy of the message exchange.
 class Pipeline
          Creates a Pipeline pattern where the output of the previous step is sent as input to the next step, reusing the same message exchanges
 class ProceedProcessor
          A Processor which proceeds on an Interceptor
 class RecipientList
          Implements a dynamic Recipient List pattern where the list of actual endpoints to send a message exchange to are dependent on some dynamic expression.
 class SendProcessor
           
 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 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 TryProcessor
          Implements try/catch/finally type processing
 

Methods in org.apache.camel.processor that return Processor
 Processor DeadLetterChannel.getDeadLetter()
          Returns the dead letter that message exchanges will be sent to if the redelivery attempts fail
 Processor Interceptor.getInterceptorLogic()
           
 Processor ChoiceProcessor.getOtherwise()
           
 Processor LoggingErrorHandler.getOutput()
          Returns the output processor
 Processor DeadLetterChannel.getOutput()
          Returns the output processor
 Processor DelegateProcessor.getProcessor()
           
 Processor BatchProcessor.getProcessor()
           
static Processor Pipeline.newInstance(List<Processor> processors)
           
 

Methods in org.apache.camel.processor that return types with arguments of type Processor
 Collection<Processor> CompositeProcessor.getProcessors()
           
 Collection<Processor> MulticastProcessor.getProcessors()
          Returns the producers to multicast to
static
<E extends Exchange>
Collection<Processor>
MulticastProcessor.toProducers(Collection<Endpoint> endpoints)
          A helper method to convert a list of endpoints into a list of processors
 

Methods in org.apache.camel.processor with parameters of type Processor
protected  Exchange MulticastProcessor.copyExchangeStrategy(Processor processor, Exchange exchange)
          Strategy method to copy the exchange before sending to another endpoint.
protected  Exchange Pipeline.createNextExchange(Processor producer, Exchange previousExchange)
          Strategy method to create the next exchange from the
 void Interceptor.setInterceptorLogic(Processor interceptorLogic)
           
 void DelegateProcessor.setProcessor(Processor processor)
           
 

Method parameters in org.apache.camel.processor with type arguments of type Processor
static Processor Pipeline.newInstance(List<Processor> processors)
           
 

Constructors in org.apache.camel.processor with parameters of type Processor
Aggregator(Endpoint endpoint, Processor processor, AggregationCollection collection)
           
Aggregator(Endpoint endpoint, Processor processor, Expression correlationExpression, AggregationStrategy aggregationStrategy)
           
BatchProcessor(Endpoint endpoint, Processor processor, Collection<Exchange> collection)
           
CatchProcessor(List<Class> exceptions, Processor processor)
           
ChoiceProcessor(List<FilterProcessor> filters, Processor otherwise)
           
DeadLetterChannel(Processor output, Processor deadLetter)
           
DeadLetterChannel(Processor output, Processor deadLetter, RedeliveryPolicy redeliveryPolicy, Logger logger)
           
Delayer(Processor processor, Expression<Exchange> timeExpression, long delay)
           
DelayProcessorSupport(Processor processor)
           
DelegateProcessor(Processor processor)
           
FilterProcessor(Predicate<Exchange> predicate, Processor processor)
           
Interceptor(Processor interceptorLogic)
           
LoggingErrorHandler(Processor output)
           
LoggingErrorHandler(Processor output, Log log, LoggingLevel level)
           
Resequencer(Endpoint endpoint, Processor processor, Expression<Exchange> expression)
           
Resequencer(Endpoint endpoint, Processor processor, List<Expression> expressions)
           
Resequencer(Endpoint endpoint, Processor processor, Set<Exchange> collection)
           
Splitter(Expression expression, Processor destination)
           
Throttler(Processor processor, long maximumRequestsPerPeriod)
           
Throttler(Processor processor, long maximumRequestsPerPeriod, long timePeriodMillis)
           
TryProcessor(Processor tryProcessor, List<CatchProcessor> catchClauses, Processor finallyProcessor)
           
 

Constructor parameters in org.apache.camel.processor with type arguments of type Processor
CompositeProcessor(Collection<Processor> processors)
           
MulticastProcessor(Collection<Processor> processors)
           
Pipeline(Collection<Processor> processors)
           
 

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

Classes in org.apache.camel.processor.idempotent that implement Processor
 class IdempotentConsumer
          An implementation of the Idempotent Consumer pattern.
 

Methods in org.apache.camel.processor.idempotent that return Processor
 Processor IdempotentConsumer.getNextProcessor()
           
 

Constructors in org.apache.camel.processor.idempotent with parameters of type Processor
IdempotentConsumer(Expression<Exchange> messageIdExpression, MessageIdRepository messageIdRepository, Processor nextProcessor)
           
 

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

Subinterfaces of Processor in org.apache.camel.processor.loadbalancer
 interface LoadBalancer
          A strategy for load balancing across a number of Processor instances
 

Classes in org.apache.camel.processor.loadbalancer that implement Processor
 class LoadBalancerSupport
          A default base class for a LoadBalancer implementation
 class QueueLoadBalancer
          A base class for LoadBalancer implementations which choose a single destination for each exchange (rather like JMS Queues)
 class RandomLoadBalancer
          Implements the random load balancing policy
 class RoundRobinLoadBalancer
          Implements the round robin load balancing policy
 class StickyLoadBalancer
          Implements a sticky load balancer using an Expression to calculate a correlation key to perform the sticky load balancing; rather like jsessionid in the web or JMSXGroupID in JMS.
 class TopicLoadBalancer
          A LoadBalancer implementations which sends to all destinations (rather like JMS Topics)
 

Methods in org.apache.camel.processor.loadbalancer that return Processor
protected  Processor RandomLoadBalancer.chooseProcessor(List<Processor> processors, Exchange exchange)
           
protected  Processor StickyLoadBalancer.chooseProcessor(List<Processor> processors, Exchange exchange)
           
protected  Processor RoundRobinLoadBalancer.chooseProcessor(List<Processor> processors, Exchange exchange)
           
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> LoadBalancer.getProcessors()
          Returns the current processors available to this load balancer
 List<Processor> LoadBalancerSupport.getProcessors()
           
 

Methods in org.apache.camel.processor.loadbalancer with parameters of type Processor
 void LoadBalancer.addProcessor(Processor processor)
          Adds a new processor to the load balancer
 void LoadBalancerSupport.addProcessor(Processor processor)
           
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 LoadBalancer.removeProcessor(Processor processor)
          Removes the given processor from the load balancer
 void LoadBalancerSupport.removeProcessor(Processor processor)
           
 

Method parameters in org.apache.camel.processor.loadbalancer with type arguments of type Processor
protected  Processor RandomLoadBalancer.chooseProcessor(List<Processor> processors, Exchange exchange)
           
protected  Processor StickyLoadBalancer.chooseProcessor(List<Processor> processors, Exchange exchange)
           
protected  Processor RoundRobinLoadBalancer.chooseProcessor(List<Processor> processors, Exchange exchange)
           
protected abstract  Processor QueueLoadBalancer.chooseProcessor(List<Processor> processors, Exchange exchange)
           
 

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

Classes in org.apache.camel.processor.validation that implement Processor
 class ValidatingProcessor
          A processor which validates the XML version of the inbound message body against some schema either in XSD or RelaxNG
 

Uses of Processor in org.apache.camel.spi
 

Methods in org.apache.camel.spi that return Processor
 Processor Policy.wrap(Processor processor)
          Wraps any applicable interceptors around the given processor
 

Methods in org.apache.camel.spi with parameters of type Processor
 Processor Policy.wrap(Processor processor)
          Wraps any applicable interceptors around the given processor
 

Uses of Processor in org.apache.camel.util
 

Methods in org.apache.camel.util with parameters of type Processor
 E ProducerCache.send(Endpoint<E> endpoint, Processor processor)
          Sends an exchange to an endpoint using a supplied
 



Copyright © 2007 Apache Software Foundation. All Rights Reserved.