Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES

## Uses of Interface
org.mule.api.processor.MessageProcessor

Packages that use MessageProcessor
org.mule | The Mule implementation of the Universal Message Objects(tm) API specification.
org.mule.api | The Universal Message Object(tm) API provides a way for components to interact without needing to know about the protocol or delivery mechanisms of information passed between them
org.mule.api.component |
org.mule.api.endpoint | Endpoint interfaces.
org.mule.api.interceptor |
org.mule.api.processor |
org.mule.api.routing | Interfaces that define inbound and outbound routing API.
org.mule.api.service |
org.mule.api.source |
org.mule.api.transformer | Contains the interfaces for transformers and exceptions for the Transformer API.
org.mule.api.transport | Contains the interfaces that comprise a provider implementation.
org.mule.component |
org.mule.component.simple | A collection of simple mule components that can be useful to simplify configuration while testing.
org.mule.config.dsl.routers |
org.mule.config.i18n | Internationalisation support for Mule messages and exception messages.
org.mule.config.spring.factories |
org.mule.config.transformer |
org.mule.construct |
org.mule.construct.builder |
org.mule.construct.processor |
org.mule.endpoint | Implemtation of Mule endpoint uris.
org.mule.endpoint.inbound |
org.mule.endpoint.outbound |
org.mule.example.bookstore.transformers |
org.mule.example.errorhandler |
org.mule.example.geomail.transformers |
org.mule.example.hello |
org.mule.example.loanbroker.processor |
org.mule.example.loanbroker.routers |
org.mule.example.loanbroker.transformers |
org.mule.example.scripting |
org.mule.exception |
org.mule.expression.transformers |
org.mule.interceptor |
org.mule.lifecycle.processor |
org.mule.model.seda |
org.mule.module.atom |
org.mule.module.atom.routing |
org.mule.module.atom.transformers |
org.mule.module.bpm |
org.mule.module.client | Simple interface for Mule clients to send and receive events from local or remote Mule Servers.
org.mule.module.cxf |
org.mule.module.cxf.component |
org.mule.module.cxf.config |
org.mule.module.ibeans.config |
org.mule.module.ibeans.spi.support |
org.mule.module.jca | A Resource Adapter implementation that allows a Mule instance to be deployed to a J2ee application server and exposes Mule services via the JCA connector architecture.
org.mule.module.jersey |
org.mule.module.json.transformers | Transfromers for converting from JavaBeans and collections to JSON and back again.
org.mule.module.rss.transformers |
org.mule.module.scripting.component | Base classes for script based components such as BeanShell or Groovy.
org.mule.module.scripting.transformer |
org.mule.module.spring.remoting |
org.mule.module.sxc |
org.mule.module.ws.config.spring.factories |
org.mule.module.ws.construct |
org.mule.module.xml.routing |
org.mule.module.xml.transformer | Xml and Xslt Transformer implementations.
org.mule.module.xml.transformer.jaxb |
org.mule.processor |
org.mule.processor.builder |
org.mule.routing | Defines the core routing patterns supported by mule.
org.mule.routing.correlation |
org.mule.routing.outbound | Outbound router implementation as described in the Enterprise Integration Patterns book.
org.mule.routing.requestreply |
org.mule.service |
org.mule.service.processor |
org.mule.source |
org.mule.tck.functional | Helper classes and interfaces used by Mule fnctional tests.
org.mule.tck.transformer |
org.mule.transformer | Provides the default transformer base implementations for Mule including compression and encryption support.
org.mule.transformer.codec | Transformers for Base64, UC and UU encoding/decoding.
org.mule.transformer.compression | Transformers for compressing and uncompressing message payloads.
org.mule.transformer.encryption | Transformers for encrypting and decrypting message payloads.
org.mule.transformer.simple | Basic transformer implementations.
org.mule.transport | Contains Abstract classes providing common functionality for all Mule providers.
org.mule.transport.ajax |
org.mule.transport.bpm |
org.mule.transport.ejb |
org.mule.transport.email | Provides pop3, smtp and imap connectivity for Mule.
org.mule.transport.email.transformers | Contains transformers to convert to and from the java.mail.Message type.
org.mule.transport.file | Provides file transport in the form of a directory listeners and file dispatchers.
org.mule.transport.file.transformers | Transformers for converting to and from the FileMessage type.
org.mule.transport.ftp |
org.mule.transport.http | Provides http transport including proxy support.
org.mule.transport.http.components |
org.mule.transport.http.transformers |
org.mule.transport.ibean |
org.mule.transport.jdbc | Provides jdbc transport.
org.mule.transport.jms | Provides Jms transport connectivity with support for all Jms features.
org.mule.transport.jms.transformers | Contains transformers to convert to and from different javax.jms.Message types
org.mule.transport.quartz |
org.mule.transport.rmi |
org.mule.transport.servlet.transformers |
org.mule.transport.soap.axis | Provides an Axis soap transport for Mule.
org.mule.transport.soap.axis.wsdl |
org.mule.transport.stdio |
org.mule.transport.tcp | Provides tcp connectivity for Mule.
org.mule.transport.udp | Provides Udp connectivity for Mule.
org.mule.transport.vm | A connector implementation allowing events to be passed between Mule sessions via in-memory queues.
org.mule.transport.xmpp |
org.mule.transport.xmpp.transformers |

Uses of MessageProcessor in org.mule

Methods in org.mule with parameters of type MessageProcessor
`static MuleEvent` | `RequestContext.cloneAndUpdateEventEndpoint(MuleEvent event, MessageProcessor target)`
`static MuleEvent` | `RequestContext.updateEventEndpoint(MuleEvent event, MessageProcessor target)`

Uses of MessageProcessor in org.mule.api

Methods in org.mule.api that return MessageProcessor
`MessageProcessor` | `MessageProcessorAnnotationParser.parseMessageProcessor(Annotation annotation)` Will create a Mule Router according to the annotation.

Uses of MessageProcessor in org.mule.api.component

Subinterfaces of MessageProcessor in org.mule.api.component
`interface` | `Component` A `Component` component processes a `MuleEvent` by invoking the component instance that has been configured, optionally returning a result.
`interface` | `InterfaceBinding`
`interface` | `JavaComponent` `JavaComponent` is a Java `Component` implementation used to invoke Java component implementations.

Uses of MessageProcessor in org.mule.api.endpoint

Subinterfaces of MessageProcessor in org.mule.api.endpoint
`interface` | `OutboundEndpoint`

Methods in org.mule.api.endpoint that return MessageProcessor
`MessageProcessor` | `EndpointMessageProcessorChainFactory.createInboundMessageProcessorChain(InboundEndpoint endpoint, FlowConstruct flowConstruct, MessageProcessor target)`
`MessageProcessor` | `EndpointMessageProcessorChainFactory.createOutboundMessageProcessorChain(OutboundEndpoint endpoint, FlowConstruct flowConstruct, MessageProcessor target)`

Methods in org.mule.api.endpoint that return types with arguments of type MessageProcessor
`List<MessageProcessor>` | `ImmutableEndpoint.getMessageProcessors()`
`List<MessageProcessor>` | `ImmutableEndpoint.getResponseMessageProcessors()`

Methods in org.mule.api.endpoint with parameters of type MessageProcessor
`void` | `EndpointBuilder.addMessageProcessor(MessageProcessor messageProcessor)`
`void` | `EndpointBuilder.addResponseMessageProcessor(MessageProcessor responseMessageProcessor)`
`MessageProcessor` | `EndpointMessageProcessorChainFactory.createInboundMessageProcessorChain(InboundEndpoint endpoint, FlowConstruct flowConstruct, MessageProcessor target)`
`MessageProcessor` | `EndpointMessageProcessorChainFactory.createOutboundMessageProcessorChain(OutboundEndpoint endpoint, FlowConstruct flowConstruct, MessageProcessor target)`

Method parameters in org.mule.api.endpoint with type arguments of type MessageProcessor
`void` | `EndpointBuilder.setMessageProcessors(List<MessageProcessor> messageProcessors)`
`void` | `EndpointBuilder.setResponseMessageProcessors(List<MessageProcessor> responseMessageProcessors)`

Uses of MessageProcessor in org.mule.api.interceptor

Subinterfaces of MessageProcessor in org.mule.api.interceptor
`interface` | `Interceptor` `Interceptor` is based on a similar concept of servlet filters and works much the same way.

Uses of MessageProcessor in org.mule.api.processor

Subinterfaces of MessageProcessor in org.mule.api.processor
`interface` | `InterceptingMessageProcessor` Processes `MuleEvent`'s intercepting another listener `MessageProcessor`.
`interface` | `MessageRouter` A `MessageProcessor` that routes messages to zero or more destination message processors.
`interface` | `RequestReplyReplierMessageProcessor` Processes a `MuleEvent`'s by invoking the next `MessageProcessor` and then rather than returning the result to this processors `MessageSource` sending it via a seperate reply `MessageProcessor`,
`interface` | `RequestReplyRequesterMessageProcessor` Processes a `MuleEvent`'s by invoking the next `MessageProcessor` but receiving the reply, which is turn is returned from this MessageProcessor from a seperate `MessageSource` rather than using the return value of the `next` MessageProcessor invocation.

Methods in org.mule.api.processor that return MessageProcessor
`MessageProcessor` | `MessageProcessorBuilder.build()`

Methods in org.mule.api.processor with parameters of type MessageProcessor
`void` | `MessageRouter.addRoute(MessageProcessor processor)` Adds a new message processor to the list of routes
`void` | `MessageRouter.removeRoute(MessageProcessor processor)` Removes a message processor from the list of routes
`void` | `RequestReplyReplierMessageProcessor.setReplyProcessor(MessageProcessor replyMessageProcessor)`

Uses of MessageProcessor in org.mule.api.routing

Subinterfaces of MessageProcessor in org.mule.api.routing
`interface` | `MatchableMessageProcessor`
`interface` | `MatchableMessageRouter`
`interface` | `MatchingRouter` Routes the message to zero or more `MatchableMessageProcessor`s.
`interface` | `OutboundRouter` `OutboundRouter` is used to control outbound routing behaviour for an event.
`interface` | `OutboundRouterCatchAllStrategy` `RouterCatchAllStrategy` is a strategy interface that allows developers to hook in custom code when an event is being routed on the inbound or outbound but does not match any of the criteria defined for the routing.
`interface` | `OutboundRouterCollection` `RouterCollection` defines the interface for a MessageRouter that manages more than one router.
`interface` | `SelectiveRouter` Routes the event to `MessageProcessor`s using a `Filter` to evaluate the event being processed and determine if a given route should be used.

Fields in org.mule.api.routing declared as MessageProcessor
`protected MessageProcessor` | `RoutingException.route`

Methods in org.mule.api.routing that return MessageProcessor
`MessageProcessor` | `RoutingException.getRoute()`

Methods in org.mule.api.routing that return types with arguments of type MessageProcessor
`List<MessageProcessor>` | `OutboundRouter.getRoutes()` Gets a list of MessageProcessor instances associated with this router

Methods in org.mule.api.routing with parameters of type MessageProcessor
`void` | `SelectiveRouter.addRoute(MessageProcessor processor, Filter filter)`
`void` | `SelectiveRouter.removeRoute(MessageProcessor processor)`
`void` | `SelectiveRouter.setDefaultRoute(MessageProcessor processor)`
`void` | `SelectiveRouter.updateRoute(MessageProcessor processor, Filter filter)`

Constructors in org.mule.api.routing with parameters of type MessageProcessor
`CouldNotRouteOutboundMessageException(Message message, MuleEvent event, MessageProcessor target)`
`CouldNotRouteOutboundMessageException(Message message, MuleEvent event, MessageProcessor target, Throwable cause)`
`CouldNotRouteOutboundMessageException(MuleEvent event, MessageProcessor target)`
`CouldNotRouteOutboundMessageException(MuleEvent event, MessageProcessor target, Throwable cause)`
`ResponseTimeoutException(Message message, MuleEvent event, MessageProcessor target)`
`ResponseTimeoutException(Message message, MuleEvent event, MessageProcessor target, Throwable cause)`
`RoutePathNotFoundException(Message message, MuleEvent event, MessageProcessor target)`
`RoutePathNotFoundException(Message message, MuleEvent event, MessageProcessor target, Throwable cause)`
`RoutePathNotFoundException(MuleEvent event, MessageProcessor target)`
`RoutePathNotFoundException(MuleEvent event, MessageProcessor target, Throwable cause)`
`RoutingException(Message message, MuleEvent event, MessageProcessor route)`
`RoutingException(Message message, MuleEvent event, MessageProcessor route, Throwable cause)`
`RoutingException(MuleEvent event, MessageProcessor route)`
`RoutingException(MuleEvent event, MessageProcessor route, Throwable cause)`

Uses of MessageProcessor in org.mule.api.service

Methods in org.mule.api.service that return MessageProcessor
`MessageProcessor` | `Service.getOutboundMessageProcessor()` Outbound Routers control how events are published by a service once.

Methods in org.mule.api.service with parameters of type MessageProcessor
`void` | `Service.setOutboundMessageProcessor(MessageProcessor processor)` Outbound Routers control how events are published by a service once.

Uses of MessageProcessor in org.mule.api.source

Methods in org.mule.api.source with parameters of type MessageProcessor
`void` | `MessageSource.setListener(MessageProcessor listener)` Set the MessageProcessor listener on a message source which will be invoked when a message is received or generated.

Uses of MessageProcessor in org.mule.api.transformer

Subinterfaces of MessageProcessor in org.mule.api.transformer
`interface` | `MessageTransformer` A transformer intended to transform Mule messages rather than arbitrary objects
`interface` | `Transformer` `Transformer` can be chained together to covert message payloads from one object type to another.

Uses of MessageProcessor in org.mule.api.transport

Subinterfaces of MessageProcessor in org.mule.api.transport
`interface` | `MessageDispatcher` Combine `MessageDispatching` with various lifecycle methods for the actual instances doing message sending.

Methods in org.mule.api.transport with parameters of type MessageProcessor
`void` | `Connector.registerListener(InboundEndpoint endpoint, MessageProcessor listener, FlowConstruct flowConstruct)` Registers a MessageProcessor listener which will listen to new message received from a specific transport channel and then processed by the endpoint.

Constructors in org.mule.api.transport with parameters of type MessageProcessor
`DispatchException(Message message, MuleEvent event, MessageProcessor target)`
`DispatchException(Message message, MuleEvent event, MessageProcessor target, Throwable cause)`
`DispatchException(MuleEvent event, MessageProcessor target)`
`DispatchException(MuleEvent event, MessageProcessor target, Throwable cause)`

Uses of MessageProcessor in org.mule.component

Classes in org.mule.component that implement MessageProcessor
`class` | `AbstractComponent` Abstract `Component` to be used by all `Component` implementations.
`class` | `AbstractJavaComponent` Abstract implementation of JavaComponent adds JavaComponent specific's: `EntryPointResolverSet`, `org.mule.api.routing.BindingCollection` and `ObjectFactory`.
`class` | `DefaultInterfaceBinding`
`class` | `DefaultJavaComponent` Default implementation of `JavaComponent`.
`class` | `PooledJavaComponent` `PooledJavaComponent` implements pooling.
`class` | `SimpleCallableJavaComponent` Simple `JavaComponent` implementation to be used when `LifecycleAdapter` is not required because i) the object instance implements `Callable` and so entry-point resolution is required and ii) component bindings are not used. An `ObjectFactory` can be set but must return object instances that implement `Callable`.

Fields in org.mule.component declared as MessageProcessor
`protected MessageProcessor` | `AbstractComponent.interceptorChain`

Uses of MessageProcessor in org.mule.component.simple

Classes in org.mule.component.simple that implement MessageProcessor
`class` | `PassThroughComponent` `PassThroughComponent` will simply return the payload back as the result.

Uses of MessageProcessor in org.mule.config.dsl.routers

Classes in org.mule.config.dsl.routers that implement MessageProcessor
`class` | `ContentBasedRouter` TODO

Uses of MessageProcessor in org.mule.config.i18n

Methods in org.mule.config.i18n with parameters of type MessageProcessor
`static Message` | `CoreMessages.errorInvokingMessageProcessorAsynchronously(MessageProcessor processor)`
`static Message` | `CoreMessages.errorInvokingMessageProcessorWithinTransaction(MessageProcessor processor, TransactionConfig transactionConfig)`
`static Message` | `CoreMessages.errorSchedulingMessageProcessorForAsyncInvocation(MessageProcessor processor)`
`static Message` | `CoreMessages.failedToRouterViaEndpoint(MessageProcessor target)`

Uses of MessageProcessor in org.mule.config.spring.factories

Methods in org.mule.config.spring.factories that return MessageProcessor
`MessageProcessor` | `FlowRefFactoryBean.getObject()`

Methods in org.mule.config.spring.factories with parameters of type MessageProcessor
`void` | `ValidatorFactoryBean.setMessageProcessor(MessageProcessor processor)`
`void` | `BridgeFactoryBean.setMessageProcessor(MessageProcessor processor)`
`void` | `MessageProcessorFilterPairFactoryBean.setMessageProcessor(MessageProcessor messageProcessor)`
`void` | `SimpleServiceFactoryBean.setMessageProcessor(MessageProcessor component)`

Uses of MessageProcessor in org.mule.config.transformer

Classes in org.mule.config.transformer that implement MessageProcessor
`class` | `AnnotatedTransformerProxy` Creates a Mule `Transformer` proxy around a transform method.

Uses of MessageProcessor in org.mule.construct

Classes in org.mule.construct that implement MessageProcessor
`class` | `AbstractFlowConstruct` Abstract implementation of `FlowConstruct` that: Is constructed with unique name and `MuleContext`.
`class` | `Bridge` A simple bridge between a single inbound endpoint and a single outbound endpoint.
`class` | `SimpleFlowConstruct` Simple implementation of `AbstractFlowConstruct` that allows a list of `MessageProcessor`s that will be used to process messages to be configured.
`class` | `SimpleService` In-out SOA-style simple service, with no outbound router.
`class` | `Validator`

Fields in org.mule.construct declared as MessageProcessor
`protected MessageProcessor` | `AbstractFlowConstruct.messageProcessorChain`

Fields in org.mule.construct with type parameters of type MessageProcessor
`protected List<MessageProcessor>` | `SimpleFlowConstruct.messageProcessors`

Methods in org.mule.construct that return types with arguments of type MessageProcessor
`List<MessageProcessor>` | `SimpleFlowConstruct.getMessageProcessors()`

Method parameters in org.mule.construct with type arguments of type MessageProcessor
`void` | `SimpleFlowConstruct.setMessageProcessors(List<MessageProcessor> messageProcessors)`

Uses of MessageProcessor in org.mule.construct.builder

Fields in org.mule.construct.builder with type parameters of type MessageProcessor
`protected List<MessageProcessor>` | `AbstractFlowConstructWithSingleInboundEndpointBuilder.inboundResponseTransformers`
`protected List<MessageProcessor>` | `AbstractFlowConstructWithSingleInboundEndpointBuilder.inboundTransformers`
`protected List<MessageProcessor>` | `AbstractFlowConstructWithSingleInboundAndOutboundEndpointBuilder.outboundResponseTransformers`
`protected List<MessageProcessor>` | `AbstractFlowConstructWithSingleInboundAndOutboundEndpointBuilder.outboundTransformers`

Uses of MessageProcessor in org.mule.construct.processor

Classes in org.mule.construct.processor that implement MessageProcessor
`class` | `FlowConstructStatisticsMessageObserver`

Uses of MessageProcessor in org.mule.endpoint

Classes in org.mule.endpoint that implement MessageProcessor
`class` | `DefaultOutboundEndpoint`
`class` | `DynamicOutboundEndpoint` An Outbound endpoint who's URI will be constructed based on the current message.
`protected static class` | `DynamicOutboundEndpoint.NullOutboundEndpoint`
`class` | `DynamicURIOutboundEndpoint` Allows EndpointURI to be set and changed dynamically by wrapping up an immutable endpoint instance.

Fields in org.mule.endpoint with type parameters of type MessageProcessor
`protected List<MessageProcessor>` | `AbstractEndpointBuilder.messageProcessors`
`protected List<MessageProcessor>` | `AbstractEndpointBuilder.responseMessageProcessors`

Methods in org.mule.endpoint that return MessageProcessor
`MessageProcessor` | `DefaultEndpointMessageProcessorChainFactory.createInboundMessageProcessorChain(InboundEndpoint endpoint, FlowConstruct flowConstruct, MessageProcessor target)`
`protected MessageProcessor` | `DefaultOutboundEndpoint.createMessageProcessorChain(FlowConstruct flowContruct)`
`protected MessageProcessor` | `DynamicOutboundEndpoint.NullOutboundEndpoint.createMessageProcessorChain(FlowConstruct flowConstruct)`
`MessageProcessor` | `DefaultInboundEndpoint.createMessageProcessorChain(FlowConstruct flowContruct)`
`protected abstract MessageProcessor` | `AbstractEndpoint.createMessageProcessorChain(FlowConstruct flowContruct)`
`MessageProcessor` | `DefaultEndpointMessageProcessorChainFactory.createOutboundMessageProcessorChain(OutboundEndpoint endpoint, FlowConstruct flowConstruct, MessageProcessor target)`
`MessageProcessor` | `AbstractEndpoint.getMessageProcessorChain(FlowConstruct flowContruct)`
`protected MessageProcessor` | `EndpointInterceptingChainMessageProcessorBuilder.initializeMessageProcessor(Object processor)`

Methods in org.mule.endpoint that return types with arguments of type MessageProcessor
`protected List<MessageProcessor>` | `AbstractEndpointBuilder.addResponseTransformerProcessors(EndpointURI endpointURI)`
`protected List<MessageProcessor>` | `AbstractEndpointBuilder.addTransformerProcessors(EndpointURI endpointURI)`
`protected List<MessageProcessor>` | `DefaultEndpointMessageProcessorChainFactory.createInboundMessageProcessors(InboundEndpoint endpoint)` Override this method to change the default MessageProcessors.
`protected List<MessageProcessor>` | `DefaultEndpointMessageProcessorChainFactory.createInboundResponseMessageProcessors(InboundEndpoint endpoint)` Override this method to change the default MessageProcessors.
`protected List<MessageProcessor>` | `DefaultEndpointMessageProcessorChainFactory.createOutboundMessageProcessors(OutboundEndpoint endpoint)` Override this method to change the default MessageProcessors.
`protected List<MessageProcessor>` | `DefaultEndpointMessageProcessorChainFactory.createOutboundResponseMessageProcessors(OutboundEndpoint endpoint)` Override this method to change the default MessageProcessors.
`List<MessageProcessor>` | `DynamicURIInboundEndpoint.getMessageProcessors()`
`List<MessageProcessor>` | `DynamicURIOutboundEndpoint.getMessageProcessors()`
`List<MessageProcessor>` | `AbstractEndpointBuilder.getMessageProcessors()`
`List<MessageProcessor>` | `AbstractEndpoint.getMessageProcessors()`
`List<MessageProcessor>` | `DynamicURIInboundEndpoint.getResponseMessageProcessors()`
`List<MessageProcessor>` | `DynamicURIOutboundEndpoint.getResponseMessageProcessors()`
`List<MessageProcessor>` | `AbstractEndpointBuilder.getResponseMessageProcessors()`
`List<MessageProcessor>` | `AbstractEndpoint.getResponseMessageProcessors()`

Methods in org.mule.endpoint with parameters of type MessageProcessor
`void` | `AbstractEndpointBuilder.addMessageProcessor(MessageProcessor messageProcessor)`
`void` | `AbstractEndpointBuilder.addResponseMessageProcessor(MessageProcessor messageProcessor)`
`MessageProcessor` | `DefaultEndpointMessageProcessorChainFactory.createInboundMessageProcessorChain(InboundEndpoint endpoint, FlowConstruct flowConstruct, MessageProcessor target)`
`MessageProcessor` | `DefaultEndpointMessageProcessorChainFactory.createOutboundMessageProcessorChain(OutboundEndpoint endpoint, FlowConstruct flowConstruct, MessageProcessor target)`
`void` | `DynamicURIInboundEndpoint.setListener(MessageProcessor listener)`
`void` | `DefaultInboundEndpoint.setListener(MessageProcessor listener)`

Method parameters in org.mule.endpoint with type arguments of type MessageProcessor
`void` | `AbstractEndpointBuilder.setMessageProcessors(List<MessageProcessor> newMessageProcessors)`
`void` | `AbstractEndpointBuilder.setResponseMessageProcessors(List<MessageProcessor> newResponseMessageProcessors)`

Constructor parameters in org.mule.endpoint with type arguments of type MessageProcessor
`AbstractEndpoint(Connector connector, EndpointURI endpointUri, String name, Map properties, TransactionConfig transactionConfig, boolean deleteUnacceptedMessages, MessageExchangePattern messageExchangePattern, int responseTimeout, String initialState, String endpointEncoding, String endpointBuilderName, MuleContext muleContext, RetryPolicyTemplate retryPolicyTemplate, EndpointMessageProcessorChainFactory messageProcessorsFactory, List<MessageProcessor> messageProcessors, List<MessageProcessor> responseMessageProcessors, boolean disableTransportTransformer, String endpointMimeType)`
`AbstractEndpoint(Connector connector, EndpointURI endpointUri, String name, Map properties, TransactionConfig transactionConfig, boolean deleteUnacceptedMessages, MessageExchangePattern messageExchangePattern, int responseTimeout, String initialState, String endpointEncoding, String endpointBuilderName, MuleContext muleContext, RetryPolicyTemplate retryPolicyTemplate, EndpointMessageProcessorChainFactory messageProcessorsFactory, List<MessageProcessor> messageProcessors, List<MessageProcessor> responseMessageProcessors, boolean disableTransportTransformer, String endpointMimeType)`
`DefaultInboundEndpoint(Connector connector, EndpointURI endpointUri, String name, Map properties, TransactionConfig transactionConfig, boolean deleteUnacceptedMessage, MessageExchangePattern messageExchangePattern, int responseTimeout, String initialState, String endpointEncoding, String endpointBuilderName, MuleContext muleContext, RetryPolicyTemplate retryPolicyTemplate, EndpointMessageProcessorChainFactory messageProcessorsFactory, List<MessageProcessor> messageProcessors, List<MessageProcessor> responseMessageProcessors, boolean disableTransportTransformer, String mimeType)`
`DefaultInboundEndpoint(Connector connector, EndpointURI endpointUri, String name, Map properties, TransactionConfig transactionConfig, boolean deleteUnacceptedMessage, MessageExchangePattern messageExchangePattern, int responseTimeout, String initialState, String endpointEncoding, String endpointBuilderName, MuleContext muleContext, RetryPolicyTemplate retryPolicyTemplate, EndpointMessageProcessorChainFactory messageProcessorsFactory, List<MessageProcessor> messageProcessors, List<MessageProcessor> responseMessageProcessors, boolean disableTransportTransformer, String mimeType)`
`DefaultOutboundEndpoint(Connector connector, EndpointURI endpointUri, String name, Map properties, TransactionConfig transactionConfig, boolean deleteUnacceptedMessage, MessageExchangePattern messageExchangePattern, int responseTimeout, String initialState, String endpointEncoding, String endpointBuilderName, MuleContext muleContext, RetryPolicyTemplate retryPolicyTemplate, String responsePropertiesList, EndpointMessageProcessorChainFactory messageProcessorsFactory, List<MessageProcessor> messageProcessors, List<MessageProcessor> responseMessageProcessors, boolean disableTransportTransformer, String endpointMimeType)`
`DefaultOutboundEndpoint(Connector connector, EndpointURI endpointUri, String name, Map properties, TransactionConfig transactionConfig, boolean deleteUnacceptedMessage, MessageExchangePattern messageExchangePattern, int responseTimeout, String initialState, String endpointEncoding, String endpointBuilderName, MuleContext muleContext, RetryPolicyTemplate retryPolicyTemplate, String responsePropertiesList, EndpointMessageProcessorChainFactory messageProcessorsFactory, List<MessageProcessor> messageProcessors, List<MessageProcessor> responseMessageProcessors, boolean disableTransportTransformer, String endpointMimeType)`

Uses of MessageProcessor in org.mule.endpoint.inbound

Classes in org.mule.endpoint.inbound that implement MessageProcessor
`class` | `InboundEndpointMimeTypeCheckingMessageProcessor` Verify that the inbound mime type is acceptable by this endpoint.
`class` | `InboundEndpointPropertyMessageProcessor` Sets the inbound endpoint uri on as a property of the message using the following key: `MuleProperties.MULE_ORIGINATING_ENDPOINT_PROPERTY`.
`class` | `InboundExceptionDetailsMessageProcessor` Sets error message properties as specified by the transport based on the exception type of the exception payload.
`class` | `InboundLoggingMessageProcessor`
`class` | `InboundNotificationMessageProcessor` Publishes a `EndpointMessageNotification`'s when a message is received.

Uses of MessageProcessor in org.mule.endpoint.outbound

Classes in org.mule.endpoint.outbound that implement MessageProcessor
`class` | `OutboundEndpointMimeTypeCheckingMessageProcessor` Verify that the outbound mime type is acceptable by this endpoint.
`class` | `OutboundEndpointPropertyMessageProcessor` Sets the outbound endpoint uri on as a property of the message using the following key: `MuleProperties.MULE_ENDPOINT_PROPERTY`.
`class` | `OutboundEventTimeoutMessageProcessor`
`class` | `OutboundLoggingMessageProcessor`
`class` | `OutboundNotificationMessageProcessor` Publishes a `EndpointMessageNotification`'s when a message is sent or dispatched.
`class` | `OutboundResponsePropertiesMessageProcessor` Propagates properties from request message to response message as defined by `OutboundEndpoint.getResponseProperties()`.
`class` | `OutboundRewriteResponseEventMessageProcessor`
`class` | `OutboundSessionHandlerMessageProcessor` Stores session information on the outbound message.
`class` | `OutboundTxRollbackMessageProcessor` MessageProcessor implementation that stops outbound flow is the current transaction has been rolled back.

Uses of MessageProcessor in org.mule.example.bookstore.transformers

Classes in org.mule.example.bookstore.transformers that implement MessageProcessor
`class` | `AddBookResponse` A call to addBook() returns a Long representing the number of books in the catalog.
`class` | `HttpRequestToBook` Transforms a Map of HttpRequest parameters into a Book object.
`class` | `OrderToEmailTransformer` Composes an e-mail notification message to be sent based on the Book Order.

Uses of MessageProcessor in org.mule.example.errorhandler

Classes in org.mule.example.errorhandler that implement MessageProcessor
`class` | `ErrorMessageToException` The `ErrorMessageToException` transformer extracts and returns the exception encapsulated by the ErrorMessage message payload.
`class` | `ErrorMessageToExceptionBean` The `ErrorMessageToExceptionBean` transformer returns the exception bean encapsulated by the ErrorMessage message payload.
`class` | `ExceptionBeanToErrorMessage`

Uses of MessageProcessor in org.mule.example.geomail.transformers

Classes in org.mule.example.geomail.transformers that implement MessageProcessor
`class` | `IPToSender` TODO

Uses of MessageProcessor in org.mule.example.hello

Classes in org.mule.example.hello that implement MessageProcessor
`class` | `ChatStringToString` `NameStringToChatString` is a dummy transformer used in the hello world application to transform the ChatString object into a string.
`class` | `ExceptionToString` `ExceptionToString` converts an exception to a String, returning the exception's `getMessage()` result.
`class` | `HttpRequestToNameString`
`class` | `NameStringToChatString` `NameStringToChatString` converts from a NameString object to a ChatString object.
`class` | `StdinToNameString` The transformation removes break-lines and newlines from the string, which potentially could have been added during a `stdin` input operation.
`class` | `StringToNameString` `StringToNameString` converts from a String to a NameString object.

Uses of MessageProcessor in org.mule.example.loanbroker.processor

Classes in org.mule.example.loanbroker.processor that implement MessageProcessor
`class` | `LowestQuoteProcessor`

Uses of MessageProcessor in org.mule.example.loanbroker.routers

Classes in org.mule.example.loanbroker.routers that implement MessageProcessor
`class` | `BankQuotesInboundAggregator` `BankQuotesInboundAggregator` receives a number of quotes and selects the lowest
`class` | `BankQuotesResponseAggregator` `BankQuotesInboundAggregator` receives a number of quotes and selects the lowest

Uses of MessageProcessor in org.mule.example.loanbroker.transformers

Classes in org.mule.example.loanbroker.transformers that implement MessageProcessor
`class` | `CreditProfileXmlToCreditProfile`
`class` | `LoanQuoteRequestToCreditProfileArgs` Extracts the customer information from the request into an array of arguments used to invoke the Credit Agency MuleSession bean
`class` | `RestRequestToCustomerRequest` Converts parameters on the message into a CustomerQuoteRequest object

Uses of MessageProcessor in org.mule.example.scripting

Classes in org.mule.example.scripting that implement MessageProcessor
`class` | `SimpleMathTransformer` A simple transformer which adds/subtracts/multiplies/divides a constant factor to numeric messages.
`class` | `StringToNumber` Converts a string to a number.

Uses of MessageProcessor in org.mule.exception

Fields in org.mule.exception with type parameters of type MessageProcessor
`protected List<MessageProcessor>` | `AbstractExceptionListener.messageProcessors`

Methods in org.mule.exception that return types with arguments of type MessageProcessor
`List<MessageProcessor>` | `AbstractExceptionListener.getMessageProcessors()`
`protected List<MessageProcessor>` | `AbstractExceptionListener.getMessageProcessors(Throwable t)` Returns an endpoint for the given exception.

Methods in org.mule.exception with parameters of type MessageProcessor
`void` | `AbstractExceptionListener.addEndpoint(MessageProcessor processor)`
`void` | `AbstractMessagingExceptionStrategy.handleRoutingException(MuleMessage message, MessageProcessor target, Throwable t)`
`boolean` | `AbstractExceptionListener.removeMessageProcessor(MessageProcessor processor)`
`protected void` | `AbstractExceptionListener.routeException(MuleMessage message, MessageProcessor target, Throwable t)` Routes the current exception to an error endpoint such as a Dead Letter Queue (jms) This method is only invoked if there is a MuleMessage available to dispatch.
`protected void` | `DefaultServiceExceptionStrategy.routeException(MuleMessage message, MessageProcessor target, Throwable t)`

Uses of MessageProcessor in org.mule.expression.transformers

Classes in org.mule.expression.transformers that implement MessageProcessor
`class` | `AbstractExpressionTransformer` This transformer will evaluate one or more expressions on the current message and return the results as an Array.
`class` | `BeanBuilderTransformer` This transformer uses the returnClass to create the return object and then will populate the bean with arguments defined as expressions
`class` | `ExpressionTransformer` This transformer will evaluate one or more expressions on the current message and return the results as an Array.

Uses of MessageProcessor in org.mule.interceptor

Classes in org.mule.interceptor that implement MessageProcessor
`class` | `AbstractEnvelopeInterceptor` `EnvelopeInterceptor` is an intercepter that will fire before and after an event is received.
`class` | `InterceptorStack` Maintains a list of interceptors that can be applied to components.
`class` | `LoggingInterceptor` `LoggingInterceptor` is a simple interceptor that logs a message before and after the event processing.
`class` | `TimerInterceptor` `TimerInterceptor` simply times and displays the time taken to process an event.

Uses of MessageProcessor in org.mule.lifecycle.processor

Classes in org.mule.lifecycle.processor that implement MessageProcessor
`class` | `ProcessIfStartedMessageProcessor`
`class` | `ProcessIfStartedWaitIfPausedMessageProcessor`
`class` | `ProcessIfStartedWaitIfSyncPausedMessageProcessor`

Uses of MessageProcessor in org.mule.model.seda

Classes in org.mule.model.seda that implement MessageProcessor
`class` | `SedaService` A Seda service runs inside a Seda Model and is responsible for managing a Seda Queue and thread pool for a Mule sevice service.

Methods in org.mule.model.seda that return MessageProcessor
`protected MessageProcessor` | `SedaService.getServiceStartedAssertingMessageProcessor()`

Uses of MessageProcessor in org.mule.module.atom

Classes in org.mule.module.atom that implement MessageProcessor
`class` | `AbderaServiceComponent` This component receives requests from Mule and passes them off to Abdera.

Uses of MessageProcessor in org.mule.module.atom.routing

Classes in org.mule.module.atom.routing that implement MessageProcessor
`class` | `FeedSplitter` An inbound router that will split a Feed into entries.

Uses of MessageProcessor in org.mule.module.atom.transformers

Classes in org.mule.module.atom.transformers that implement MessageProcessor
`class` | `AtomEntryBuilderTransformer`
`class` | `BaseToOutputHandler` Converts Abdera model elements which extend `Base` to OutputHandlers.
`class` | `ObjectToFeed` `ObjectToInputStream` converts serilaizable object to a input stream but treats `java.lang.String` differently by converting to bytes using the `String.getBytes()` method.

Uses of MessageProcessor in org.mule.module.bpm

Classes in org.mule.module.bpm that implement MessageProcessor
`class` | `ProcessComponent` A service backed by the execution of a business process such as jBPM.

Uses of MessageProcessor in org.mule.module.client

Classes in org.mule.module.client that implement MessageProcessor
`class` | `AbstractEventTransformer` `AbstractEventTransformer` adds support for adding method details to the result message.

Uses of MessageProcessor in org.mule.module.cxf

Classes in org.mule.module.cxf that implement MessageProcessor
`class` | `CxfInboundMessageProcessor` The CxfInboundMessageProcessor performs inbound CXF processing, sending an event through the CXF service, then on to the next MessageProcessor.
`class` | `CxfOutboundMessageProcessor` The CxfOutboundMessageProcessor performs outbound CXF processing, sending an event through the CXF client, then on to the next MessageProcessor.

Uses of MessageProcessor in org.mule.module.cxf.component

Classes in org.mule.module.cxf.component that implement MessageProcessor
`class` | `AbstractWebServiceWrapperComponent`
`class` | `WebServiceWrapperComponent`

Uses of MessageProcessor in org.mule.module.cxf.config

Classes in org.mule.module.cxf.config that implement MessageProcessor
`class` | `FlowConfiguringMessageProcessor` Wraps a `MessageProcessorBuilder` and configures it lazily so it can be injected with the `FlowConstruct`.

Methods in org.mule.module.cxf.config that return MessageProcessor
`MessageProcessor` | `FlowConfiguringMessageProcessor.getWrappedMessageProcessor()` The MessageProcessor that this class built.

Methods in org.mule.module.cxf.config with parameters of type MessageProcessor
`void` | `FlowConfiguringMessageProcessor.setListener(MessageProcessor listener)`

Uses of MessageProcessor in org.mule.module.ibeans.config

Classes in org.mule.module.ibeans.config that implement MessageProcessor
`class` | `CallInterfaceBinding` An instance of a binding that matches iBean method name with an endpoint to invoke.
`class` | `IBeanBinding` TODO
`class` | `IBeanFlowConstruct` This is an empty flow construct that is used to host an iBean as a component with one or more component bindings.

Uses of MessageProcessor in org.mule.module.ibeans.spi.support

Classes in org.mule.module.ibeans.spi.support that implement MessageProcessor
`class` | `CallOutboundEndpoint` A dynamic outbound endpoint defined when using the `Call` annotation.
`class` | `DefaultRequestInterfaceBinding` Used for making a request from a message dispatcher
`class` | `DynamicRequestInterfaceBinding` Creates an component binding that can use the `MessageRequester` interface to make a call.

Methods in org.mule.module.ibeans.spi.support that return MessageProcessor
`MessageProcessor` | `DynamicRequestEndpoint.NullInboundEndpoint.createMessageProcessorChain(FlowConstruct flowContruct)`

Uses of MessageProcessor in org.mule.module.jca

Classes in org.mule.module.jca that implement MessageProcessor
`class` | `JcaComponent`
`class` | `JcaService` `JcaService` Is the type of service used in Mule when embedded inside an app server using JCA.

Uses of MessageProcessor in org.mule.module.jersey

Classes in org.mule.module.jersey that implement MessageProcessor
`class` | `JerseyResourcesComponent` Wraps a set of components which can get invoked by Jersey.

Method parameters in org.mule.module.jersey with type arguments of type MessageProcessor
`void` | `JerseyResourcesComponent.setMessageProcessors(List<MessageProcessor> messageProcessors)`

Uses of MessageProcessor in org.mule.module.json.transformers

Classes in org.mule.module.json.transformers that implement MessageProcessor
`class` | `AbstractJsonTransformer` TODO
`class` | `JsonToObject` A transformer that will convert a JSON encoded object graph to a java object.
`class` | `ObjectToJson` Converts a java object to a JSON encoded object that can be consumed by other languages such as Javascript or Ruby.

Uses of MessageProcessor in org.mule.module.rss.transformers

Classes in org.mule.module.rss.transformers that implement MessageProcessor
`class` | `ObjectToRssFeed` Converts an RSS data representation into a SyndFeed object

Uses of MessageProcessor in org.mule.module.scripting.component

Classes in org.mule.module.scripting.component that implement MessageProcessor
`class` | `ScriptComponent` A Script service backed by a JSR-223 compliant script engine such as Groovy, JavaScript, or Rhino.

Uses of MessageProcessor in org.mule.module.scripting.transformer

Classes in org.mule.module.scripting.transformer that implement MessageProcessor
`class` | `ScriptTransformer` Runs a script to perform transformation on an object.

Uses of MessageProcessor in org.mule.module.spring.remoting

Classes in org.mule.module.spring.remoting that implement MessageProcessor
`class` | `ObjectToRemoteInvocationResultTransformer` Converts an Object to a Spring RemoteInvocationResult and then into a byte[].
`class` | `ObjectToRemoteInvocationTransformer` Transforms a byte[] into an ObjectInputStream and then into a Spring RemoteInvocation instance.

Uses of MessageProcessor in org.mule.module.sxc

Classes in org.mule.module.sxc that implement MessageProcessor
`class` | `SxcFilteringOutboundRouter` `FilteringRouter` is a router that accepts events based on a filter set.

Uses of MessageProcessor in org.mule.module.ws.config.spring.factories

Methods in org.mule.module.ws.config.spring.factories with parameters of type MessageProcessor
`void` | `WSProxyFactoryBean.setMessageProcessor(MessageProcessor processor)`

Uses of MessageProcessor in org.mule.module.ws.construct

Classes in org.mule.module.ws.construct that implement MessageProcessor
`class` | `WSProxy` This class is implemented to act as a Proxy for a Web Service.

Uses of MessageProcessor in org.mule.module.xml.routing

Classes in org.mule.module.xml.routing that implement MessageProcessor
`class` | `FilterBasedXmlMessageSplitter` This splitter will select the endpoint to send a message part on by filtering parts using the endpoint filters.
`class` | `XmlMessageSplitter` `XmlMessageSplitter` will split a DOM4J document into nodes based on the "splitExpression" property.

Uses of MessageProcessor in org.mule.module.xml.transformer

Classes in org.mule.module.xml.transformer that implement MessageProcessor
`class` | `AbstractXmlTransformer` `AbstractXmlTransformer` offers some XSLT transform on a DOM (or other XML-ish) object.
`class` | `AbstractXStreamTransformer` `AbstractXStreamTransformer` is a base class for all XStream based transformers.
`class` | `DomDocumentToXml` `DomDocumentToXml` Transform a org.w3c.dom.Document to XML String
`class` | `JXPathExtractor` The JXPathExtractor is a simple transformer that evaluates an xpath expression against the given bean and that returns the result.
`class` | `ObjectToXml` `ObjectToXml` converts any object to XML using Xstream.
`class` | `XmlPrettyPrinter`
`class` | `XmlToDomDocument` `XmlToDomDocument` transforms a XML String to org.w3c.dom.Document.
`class` | `XmlToObject` `XmlToObject` converts xml created by the ObjectToXml transformer in to a java object graph.
`class` | `XmlToOutputHandler`
`class` | `XmlToXMLStreamReader`
`class` | `XPathExtractor` Simple transformer for using the JAXP XPath library to extract an XPath value from an XPath expression.
`class` | `XQueryTransformer` The XQuery Module gives users the ability to perform XQuery transformations on XML messages in Mule
`class` | `XsltTransformer` `XsltTransformer` performs an XSLT transform on a DOM (or other XML-ish) object.

Uses of MessageProcessor in org.mule.module.xml.transformer.jaxb

Classes in org.mule.module.xml.transformer.jaxb that implement MessageProcessor
`class` | `JAXBMarshallerTransformer` Allows marshaling of Java objects to XML using JAXB 2.
`class` | `JAXBUnmarshallerTransformer` Allows un-marshaling of XML generated by JAXB to a Java object graph.

Uses of MessageProcessor in org.mule.processor

Classes in org.mule.processor that implement MessageProcessor
`class` | `AbstractDynamicMessageProcessor` Implementation of `MessageProcessor` that dynamically chooses and uses another `MessageProcessor`
`class` | `AbstractFilteringMessageProcessor` Abstract `InterceptingMessageProcessor` that can be easily be extended and used for filtering message flow through a `MessageProcessor` chain.
`class` | `AbstractInterceptingMessageProcessor` Abstract implementation of `InterceptingMessageProcessor` that simply provides an implementation of setNext and holds the next message processor as an attribute.
`class` | `AbstractMessageObserver` Can be used for simple `MessageProcessor`s that require the `MuleEvent` to log or send notifications etc.
`class` | `AbstractResponseMessageProcessor`
`class` | `AsyncInterceptingMessageProcessor` Processes `MuleEvent`'s asynchronously using a `MuleWorkManager` to schedule asynchronous processing of the next `MessageProcessor`.
`class` | `ExceptionHandlingMessageProcessor`
`class` | `NullMessageProcessor`
`class` | `OptionalAsyncInterceptingMessageProcessor` Implementation of `AsyncInterceptingMessageProcessor` which continues processing in the same thread if the inbound endpoint has an exchange pattern that has a response or if a transaction is present.
`class` | `ResponseMessageProcessorAdapter`
`class` | `SecurityFilterMessageProcessor` Filters the flow using the `EndpointSecurityFilter` configured on the endpoint.
`class` | `SedaStageInterceptingMessageProcessor` Processes `MuleEvent`'s asynchronously using a `MuleWorkManager` to schedule asynchronous processing of the next `MessageProcessor`.
`class` | `StopFurtherMessageProcessingMessageProcessor`
`class` | `TransactionalInterceptingMessageProcessor` Wraps the invocation of the next `MessageProcessor` with a transaction.

Fields in org.mule.processor declared as MessageProcessor
`protected MessageProcessor` | `AbstractInterceptingMessageProcessor.next`
`protected MessageProcessor` | `ResponseMessageProcessorAdapter.responseProcessor`
`protected MessageProcessor` | `AbstractFilteringMessageProcessor.unacceptedMessageProcessor` The `MessageProcessor` that should be used to handle messages that are not accepted by the filter.

Methods in org.mule.processor that return MessageProcessor
`MessageProcessor` | `AbstractFilteringMessageProcessor.getUnacceptedMessageProcessor()`
`protected abstract MessageProcessor` | `AbstractDynamicMessageProcessor.resolveMessageProcessor(MuleEvent event)` Determines which MessageProcessor should be used.

Methods in org.mule.processor with parameters of type MessageProcessor
`void` | `AbstractInterceptingMessageProcessor.setListener(MessageProcessor next)`
`void` | `ResponseMessageProcessorAdapter.setProcessor(MessageProcessor processor)`
`void` | `AbstractFilteringMessageProcessor.setUnacceptedMessageProcessor(MessageProcessor unacceptedMessageProcessor)`

Constructors in org.mule.processor with parameters of type MessageProcessor
`ResponseMessageProcessorAdapter(MessageProcessor responseProcessor)`

Uses of MessageProcessor in org.mule.processor.builder

Classes in org.mule.processor.builder that implement MessageProcessor
`class` | `InterceptingChainCompositeMessageProcessor` Builder needs to return a composite rather than the first MessageProcessor in the chain.

Methods in org.mule.processor.builder that return MessageProcessor
`MessageProcessor` | `IteratingListMessageProcessorBuilder.build()`
`MessageProcessor` | `InterceptingChainMessageProcessorBuilder.build()`
`protected MessageProcessor` | `InterceptingChainMessageProcessorBuilder.initializeMessageProcessor(Object processor)`

Methods in org.mule.processor.builder with parameters of type MessageProcessor
`IteratingListMessageProcessorBuilder` | `IteratingListMessageProcessorBuilder.add(MessageProcessor... processors)`
`IteratingListMessageProcessorBuilder` | `IteratingListMessageProcessorBuilder.addBefore(MessageProcessor processor)`
`InterceptingChainMessageProcessorBuilder` | `InterceptingChainMessageProcessorBuilder.chain(MessageProcessor... processors)`
`InterceptingChainMessageProcessorBuilder` | `InterceptingChainMessageProcessorBuilder.chainBefore(MessageProcessor processor)`

Method parameters in org.mule.processor.builder with type arguments of type MessageProcessor
`InterceptingChainMessageProcessorBuilder` | `InterceptingChainMessageProcessorBuilder.chain(List<MessageProcessor> processors)`
`IteratingListMessageProcessorBuilder` | `IteratingListMessageProcessorBuilder.InterceptingChainMessageProcessorBuilder(Collection<MessageProcessor> processors)`

Constructor parameters in org.mule.processor.builder with type arguments of type MessageProcessor
`InterceptingChainCompositeMessageProcessor(InterceptingMessageProcessor firstInChain, List<MessageProcessor> allProcessors, String name)`

Uses of MessageProcessor in org.mule.routing

Classes in org.mule.routing that implement MessageProcessor
`class` | `AbstractAggregator` `AbstractEventAggregator` will aggregate a set of messages into a single message.
`class` | `AbstractCatchAllStrategy` `RouterCatchAllStrategy` is a strategy interface that allows developers to hook in custom code when an event is being routed on the inbound or outbound but does not match any of the criteria defined for the routing.
`class` | `AbstractCorrelationAggregator` `AbstractCorrelationAggregatingMessageProcessor` uses the CorrelationID and CorrelationGroupSize properties of the `MuleMessage` to manage message groups.
`class` | `AbstractMatchingRouter` `AbstractRouterCollection` provides common method implementations of router collections for in and outbound routers.
`class` | `AbstractSelectiveRouter`
`class` | `AbstractSplitter` Splits a message invoking the next message processor one for each split part.
`class` | `ChoiceRouter` Routes the event to a single`MessageProcessor` using a `Filter` to evaluate the event being processed and find the first route that can be used.
`class` | `CollectionSplitter` Splits a message that has a list payload invoking the next message processor one for each item in the list in order.
`class` | `ExpressionSplitter` Splits a message using the expression provided invoking the next message processor one for each split part.
`class` | `FirstSuccessful` FirstSuccessful routes an event to the first target route that can accept it without throwing or returning an exception.
`class` | `ForwardingCatchAllStrategy` `ForwardingCatchAllStrategy` acts as a catch and forward router for any events not caught by the router this strategy is associated with.
`class` | `IdempotentMessageFilter` `IdempotentMessageFilter` ensures that only unique messages are passed on.
`class` | `IdempotentSecureHashMessageFilter` `IdempotentSecureHashMessageFilter` ensures that only unique messages are received by a service.
`class` | `LoggingCatchAllStrategy` `LoggingCatchAllStrategy` is a simple strategy that only logs any events not caught by the router associated with this strategy.
`class` | `MessageChunkAggregator`
`class` | `MessageChunkSplitter` A router that breaks up the current message onto smaller parts and sends them to the same destination.
`class` | `MessageFilter` Implementation of `InterceptingMessageProcessor` that filters message flow using a `Filter`.
`class` | `Resequencer` `CorrelationEventResequencer` is used to resequence events according to their dispatch sequence in the correlation group.
`class` | `RoundRobin` RoundRobin divides the messages it receives among its target routes in round-robin fashion.
`class` | `ServiceCatchAllStrategy` Deprecated.
`class` | `SimpleCollectionAggregator` This router will return all aggregated events as a `MuleMessageCollection`.
`class` | `WireTap` The `WireTap` MessageProcessor allows inspection of messages in a flow.

Fields in org.mule.routing declared as MessageProcessor
`protected MessageProcessor` | `AbstractMatchingRouter.defaultRoute`
`protected MessageProcessor` | `WireTap.filteredTap`
`protected MessageProcessor` | `WireTap.tap`

Methods in org.mule.routing that return MessageProcessor
`MessageProcessor` | `AbstractMatchingRouter.getDefaultRoute()`
`MessageProcessor` | `MessageProcessorFilterPair.getMessageProcessor()`
`MessageProcessor` | `WireTap.getTap()`

Methods in org.mule.routing that return types with arguments of type MessageProcessor
`protected abstract Collection<MessageProcessor>` | `AbstractSelectiveRouter.selectProcessors(MuleEvent event)`
`protected Collection<MessageProcessor>` | `ChoiceRouter.selectProcessors(MuleEvent event)`

Methods in org.mule.routing with parameters of type MessageProcessor
`void` | `AbstractSelectiveRouter.addRoute(MessageProcessor processor, Filter filter)`
`void` | `AbstractSelectiveRouter.removeRoute(MessageProcessor processor)`
`void` | `AbstractSelectiveRouter.setDefaultRoute(MessageProcessor processor)`
`void` | `AbstractMatchingRouter.setDefaultRoute(MessageProcessor defaultRoute)`
`void` | `WireTap.setMessageProcessor(MessageProcessor tap)` Deprecated.
`void` | `ForwardingCatchAllStrategy.setMessageProcessor(MessageProcessor processor)`
`void` | `WireTap.setTap(MessageProcessor tap)`
`void` | `AbstractSelectiveRouter.updateRoute(MessageProcessor processor, Filter filter)`

Constructors in org.mule.routing with parameters of type MessageProcessor
`AggregationException(EventGroup eventGroup, MessageProcessor endpoint)`
`AggregationException(EventGroup eventGroup, MessageProcessor endpoint, Throwable cause)`
`AggregationException(Message message, EventGroup eventGroup, MessageProcessor endpoint)`
`AggregationException(Message message, EventGroup eventGroup, MessageProcessor endpoint, Throwable cause)`
`MessageFilter(Filter filter, boolean throwExceptionOnUnaccepted, MessageProcessor messageProcessor)`
`MessageProcessorFilterPair(MessageProcessor messageProcessor, Filter filter)`

Uses of MessageProcessor in org.mule.routing.correlation

Constructors in org.mule.routing.correlation with parameters of type MessageProcessor
`EventCorrelator(EventCorrelatorCallback callback, MessageProcessor timeoutMessageProcessor, MessageInfoMapping messageInfoMapping, MuleContext context)`

Uses of MessageProcessor in org.mule.routing.outbound

Classes in org.mule.routing.outbound that implement MessageProcessor
`class` | `AbstractMessageSplitter` `AbstractMessageSplitter` is an outbound Message Splitter used to split the contents of a received message into sub parts that can be processed by other components.
`class` | `AbstractOutboundRouter` `AbstractOutboundRouter` is a base router class that tracks statistics about message processing through the router.
`class` | `AbstractRecipientList` `AbstractRecipientList` is used to dispatch a single event to multiple recipients over the same transport.
`class` | `AbstractRoundRobinMessageSplitter` `FilteringListMessageSplitter` accepts a List as a message payload then routes list elements as messages over an endpoint where the endpoint's filter accepts the payload.
`class` | `ChainingRouter` `ChainingRouter` is used to pass a Mule event through multiple targets using the result of the first as the input for the second.
`class` | `DefaultOutboundRouterCollection` `DefaultOutboundRouterCollection` is a container of routers.
`class` | `EndpointSelector` `EndpointSelector` selects the outgoing endpoint based on a an expression evaluator ("header:endpoint" by default).
`class` | `ExceptionBasedRouter` `ExceptionBasedRouter` Will send the current event to the first endpoint that doesn't throw an exception.
`class` | `ExpressionMessageSplitter` Evaluates a single expression and adds the results of the expression as individual message parts.
`class` | `ExpressionRecipientList`
`class` | `FilteringOutboundRouter` `FilteringRouter` is a router that accepts events based on a filter set.
`class` | `ListMessageSplitter` `FilteringListMessageSplitter` accepts a List as a message payload then routes list elements as messages over an endpoint where the endpoint's filter accepts the payload.
`class` | `MessageChunkingRouter` A router that breaks up the current message onto smaller parts and sends them to the same destination.
`class` | `MulticastingRouter` `MulticastingRouter` will broadcast the current message to every endpoint registed with the router.
`class` | `OutboundPassThroughRouter` `OutboundPassThroughRouter` allows outbound routing over a single endpoint without any filtering.
`class` | `StaticRecipientList` `StaticRecipientList` is used to dispatch a single event to multiple recipients over the same transport.
`class` | `TransformerRouter` Deprecated.

Fields in org.mule.routing.outbound with type parameters of type MessageProcessor
`protected List<MessageProcessor>` | `AbstractOutboundRouter.routes`

Methods in org.mule.routing.outbound that return MessageProcessor
`MessageProcessor` | `FilteringOutboundRouter.getRoute(int index, MuleEvent event)` Will Return the target at the given index and will resolve any template tags on the Endpoint URI if necessary
`MessageProcessor` | `AbstractOutboundRouter.getRoute(String name)`
`protected MessageProcessor` | `EndpointSelector.lookupEndpoint(String endpointName)`

Methods in org.mule.routing.outbound that return types with arguments of type MessageProcessor
`List<MessageProcessor>` | `AbstractOutboundRouter.getRoutes()`

Methods in org.mule.routing.outbound with parameters of type MessageProcessor
`void` | `AbstractOutboundRouter.addRoute(MessageProcessor route)`
`void` | `FilteringOutboundRouter.addRoute(MessageProcessor target)`
`void` | `OutboundPassThroughRouter.addRoute(MessageProcessor target)`
`void` | `AbstractOutboundRouter.removeRoute(MessageProcessor route)`
`protected MuleEvent` | `AbstractOutboundRouter.sendRequest(MuleEvent routedEvent, MuleMessage message, MessageProcessor route, boolean awaitResponse)`
`protected MuleEvent` | `AbstractOutboundRouter.sendRequestEvent(MuleEvent routedEvent, MuleMessage message, MessageProcessor route, boolean awaitResponse)` Send message event to destination.
`protected void` | `AbstractOutboundRouter.setMessageProperties(FlowConstruct service, MuleMessage message, MessageProcessor route)`

Method parameters in org.mule.routing.outbound with type arguments of type MessageProcessor
`protected SplitMessage` | `AbstractRoundRobinMessageSplitter.getMessageParts(MuleMessage message, List<MessageProcessor> endpoints)` Retrieves a specific message part for the given endpoint.
`protected abstract SplitMessage` | `AbstractMessageSplitter.getMessageParts(MuleMessage message, List<MessageProcessor> endpoints)` Implementing classes should create a `SplitMessage` instance and for each part can associate an endpoint.
`void` | `AbstractOutboundRouter.setMessageProcessors(List<MessageProcessor> routes)` Deprecated.
`void` | `AbstractOutboundRouter.setRoutes(List<MessageProcessor> routes)`
`void` | `OutboundPassThroughRouter.setRoutes(List<MessageProcessor> endpoints)`

Uses of MessageProcessor in org.mule.routing.requestreply

Classes in org.mule.routing.requestreply that implement MessageProcessor
`class` | `AbstractAsyncRequestReplyRequester`
`class` | `ReplyToPropertyRequestReplyReplier`
`class` | `SimpleAsyncRequestReplyRequester`
`class` | `SimpleRequestReplyReplier`

Fields in org.mule.routing.requestreply declared as MessageProcessor
`protected MessageProcessor` | `SimpleRequestReplyReplier.replyMessageProcessor`

Methods in org.mule.routing.requestreply with parameters of type MessageProcessor
`void` | `SimpleAsyncRequestReplyRequester.setMessageProcessor(MessageProcessor processor)`
`void` | `ReplyToPropertyRequestReplyReplier.setReplyProcessor(MessageProcessor replyMessageProcessor)`
`void` | `SimpleRequestReplyReplier.setReplyProcessor(MessageProcessor replyMessageProcessor)`

Uses of MessageProcessor in org.mule.service

Classes in org.mule.service that implement MessageProcessor
`class` | `AbstractService` A base implementation for all Services in Mule
`class` | `ForwardingConsumer` Deprecated.

Fields in org.mule.service declared as MessageProcessor
`protected MessageProcessor` | `ServiceCompositeMessageSource.catchAllStrategy`
`protected MessageProcessor` | `AbstractService.messageProcessorChain`
`protected MessageProcessor` | `AbstractService.outboundRouter`

Fields in org.mule.service with type parameters of type MessageProcessor
`protected List<MessageProcessor>` | `ServiceCompositeMessageSource.processors`

Methods in org.mule.service that return MessageProcessor
`MessageProcessor` | `ServiceCompositeMessageSource.getCatchAllStrategy()`
`MessageProcessor` | `AbstractService.getOutboundMessageProcessor()`
`protected MessageProcessor` | `AbstractService.getServiceStartedAssertingMessageProcessor()`

Methods in org.mule.service that return types with arguments of type MessageProcessor
`List<MessageProcessor>` | `ServiceCompositeMessageSource.getMessageProcessors()`

Methods in org.mule.service with parameters of type MessageProcessor
`void` | `ServiceCompositeMessageSource.addMessageProcessor(MessageProcessor processor)`
`void` | `ServiceCompositeMessageSource.setCatchAllStrategy(MessageProcessor catchAllStrategy)`
`void` | `AbstractService.setMessageProcessor(MessageProcessor processor)` Deprecated.
`void` | `AbstractService.setOutboundMessageProcessor(MessageProcessor processor)`

Method parameters in org.mule.service with type arguments of type MessageProcessor
`void` | `ServiceCompositeMessageSource.setMessageProcessors(List<MessageProcessor> processors)`

Uses of MessageProcessor in org.mule.service.processor

Classes in org.mule.service.processor that implement MessageProcessor
`class` | `ServiceAsyncRequestReplyRequestor`
`class` | `ServiceInternalMessageProcessor`
`class` | `ServiceLoggingMessageObserver`
`class` | `ServiceOutboundMessageProcessor` Responsible for determining if the Service outbound phase should be used and making a copy of the event to use.
`class` | `ServiceOutboundStatisticsObserver`
`class` | `ServiceSetEventRequestContextMessageObserver`
`class` | `ServiceStatisticsMessageObserver`

Fields in org.mule.service.processor declared as MessageProcessor
`protected MessageProcessor` | `ServiceInternalMessageProcessor.receiveAsyncReplyMessageProcessor`

Uses of MessageProcessor in org.mule.source

Fields in org.mule.source declared as MessageProcessor
`protected MessageProcessor` | `StartableCompositeMessageSource.listener`

Methods in org.mule.source with parameters of type MessageProcessor
`void` | `StartableCompositeMessageSource.setListener(MessageProcessor listener)`

Uses of MessageProcessor in org.mule.tck.functional

Classes in org.mule.tck.functional that implement MessageProcessor
`class` | `StringAppendTestTransformer`

Methods in org.mule.tck.functional with parameters of type MessageProcessor
`void` | `QuietExceptionStrategy.handleRoutingException(MuleMessage message, MessageProcessor target, Throwable e)`

Uses of MessageProcessor in org.mule.tck.transformer

Classes in org.mule.tck.transformer that implement MessageProcessor
`class` | `NoActionTransformer` `NoActionTransformer` doesn't do any transformation on the source object and returns the source as the result.
`class` | `ValidateResponse` Throws an exception if the message does not contain "success".

Uses of MessageProcessor in org.mule.transformer

Classes in org.mule.transformer that implement MessageProcessor
`class` | `AbstractDiscoverableTransformer`
`class` | `AbstractMessageAwareTransformer` Deprecated.
`class` | `AbstractMessageTransformer` `AbstractMessageTransformer` is a transformer that has a reference to the current message.
`class` | `AbstractTransformer` `AbstractTransformer` is a base class for all transformers.
`class` | `TransformerChain` A referencable chain of transformers that can be used as a single transformer
`class` | `TransformerTemplate` TODO

Uses of MessageProcessor in org.mule.transformer.codec

Classes in org.mule.transformer.codec that implement MessageProcessor
`class` | `Base64Decoder` `Base64Encoder` transforms Base64 encoded data into strings or byte arrays.
`class` | `Base64Encoder` `Base64Encoder` transforms strings or byte arrays into Base64 encoded string.
`class` | `XmlEntityDecoder` Decodes a String or byte[] containing XML entities
`class` | `XmlEntityEncoder` Encodes a string with XML entities

Uses of MessageProcessor in org.mule.transformer.compression

Classes in org.mule.transformer.compression that implement MessageProcessor
`class` | `AbstractCompressionTransformer` `AbstractCompressionTransformer` is a base class for all transformers that can compress or uncompress data when they performa message transformation.
`class` | `GZipCompressTransformer` `GZipCompressTransformer` is a transformer compressing objects into byte arrays.
`class` | `GZipUncompressTransformer` `GZipCompressTransformer` will uncompress a byte[] or InputStream

Uses of MessageProcessor in org.mule.transformer.encryption

Classes in org.mule.transformer.encryption that implement MessageProcessor
`class` | `AbstractEncryptionTransformer` `EncryptionTransformer` will transform an array of bytes or string into an encrypted array of bytes
`class` | `DecryptionTransformer` `EncryptionTransformer` will transform an encrypted array of bytes or string into an decrypted array of bytes
`class` | `EncryptionTransformer` `EncryptionTransformer` will transform an array of bytes or string into an encrypted array of bytes

Uses of MessageProcessor in org.mule.transformer.simple

Classes in org.mule.transformer.simple that implement MessageProcessor
`class` | `AutoTransformer` A transformer that uses the transform discovery mechanism to convert the message payload.
`class` | `BeanToMap` Conversts a simple bean object to a Map.
`class` | `ByteArrayToHexString` Converts a Byte array to a Hex String.
`class` | `ByteArrayToMuleMessage` TODO
`class` | `ByteArrayToObject` `ByteArrayToObject` works in the same way as `ByteArrayToSerializable` but checks if the byte array is a serialised object and if not will return a String created from the bytes as the returnType on the transformer.
`class` | `ByteArrayToSerializable` `ByteArrayToSerializable` converts a serialized object to its object representation
`class` | `GetBeanProperty` Looks up a property from a JavaBean using PropertyUtils.getProperty().
`class` | `HexStringToByteArray` Converts a Hex String to a Byte array
`class` | `MapLookup` `MapLookup` looks up and returns an object from a Map based on a key.
`class` | `MapToBean` Creates and object of type `AbstractTransformer.getReturnClass()` and populates values of a `Map` as bean properties on the object.
`class` | `MessagePropertiesTransformer` A configurable message transformer that allows users to add, overwrite, rename and delete properties on the current message.
`class` | `MuleMessageToByteArray` TODO
`class` | `ObjectArrayToString` `ObjectArrayToString` transformer is the opposite of StringToObjectArray - it simply converts Object[] to a String in which each element is separated by a configurable delimiter (default is a space).
`class` | `ObjectToByteArray` `ObjectToByteArray` converts serilaizable object to a byte array but treats `java.lang.String` differently by converting to bytes using the `String.getBytrs()` method.
`class` | `ObjectToInputStream` `ObjectToInputStream` converts Serializable objects to an InputStream but treats `java.lang.String`, `byte[]` and `org.mule.api.transport.OutputHandler` differently by using their byte[] content rather thqn Serializing them.
`class` | `ObjectToOutputHandler` `ObjectToOutputHandler` converts a byte array into a String.
`class` | `ObjectToString` `ObjectToString` transformer is useful for debugging.
`class` | `SerializableToByteArray` `SerializableToByteArray` converts a serializable object or a String to a byte array.
`class` | `StringAppendTransformer`
`class` | `StringToObjectArray` `StringToObjectArray` converts a String into an object array.

Uses of MessageProcessor in org.mule.transport

Classes in org.mule.transport that implement MessageProcessor
`class` | `AbstractMessageDispatcher` Abstract implementation of an outbound channel adaptors.
`class` | `UnsupportedMessageDispatcher`

Fields in org.mule.transport declared as MessageProcessor
`protected MessageProcessor` | `AbstractMessageReceiver.listener` `MessageProcessor` chain used to process messages once the transport specific `MessageReceiver` has received transport message and created the `MuleEvent`

Methods in org.mule.transport that return MessageProcessor
`MessageProcessor` | `AbstractConnector.createDispatcherMessageProcessor(OutboundEndpoint endpoint)`

Methods in org.mule.transport with parameters of type MessageProcessor
`void` | `AbstractConnector.registerListener(InboundEndpoint endpoint, MessageProcessor messageProcessorChain, FlowConstruct flowConstruct)`
`void` | `AbstractMessageReceiver.setListener(MessageProcessor processor)`

Uses of MessageProcessor in org.mule.transport.ajax

Classes in org.mule.transport.ajax that implement MessageProcessor
`class` | `AjaxMessageDispatcher` Will dispatch Mule events to ajax clients available in Bayeux that are listening to this endpoint.

Uses of MessageProcessor in org.mule.transport.bpm

Classes in org.mule.transport.bpm that implement MessageProcessor
`class` | `ProcessMessageDispatcher` Deprecated. It is recommended to configure BPM as a component rather than a transport for 3.x

Uses of MessageProcessor in org.mule.transport.ejb

Classes in org.mule.transport.ejb that implement MessageProcessor
`class` | `EjbMessageDispatcher` Invokes a method on an EJB object stored in Jndi.

Uses of MessageProcessor in org.mule.transport.email

Classes in org.mule.transport.email that implement MessageProcessor
`class` | `SmtpMessageDispatcher` `SmtpMessageDispatcher` will dispatch Mule events as Mime email messages over an SMTP gateway.

Uses of MessageProcessor in org.mule.transport.email.transformers

Classes in org.mule.transport.email.transformers that implement MessageProcessor
`class` | `EmailMessageToString` `EmailMessageToString` extracts a java mail Message contents and returns a string.
`class` | `MimeMessageToRfc822ByteArray`
`class` | `ObjectToMimeMessage` Transforms a `Message` to a `MuleMessage`, with support for attachments
`class` | `Rfc822ByteArraytoMimeMessage`
`class` | `StringToEmailMessage` `StringToEmailMessage` will convert a String to a JavaMail Message, using the String as the contents.

Uses of MessageProcessor in org.mule.transport.file

Classes in org.mule.transport.file that implement MessageProcessor
`class` | `FileMessageDispatcher` `FileMessageDispatcher` is used to read/write files to the filesystem

Uses of MessageProcessor in org.mule.transport.file.transformers

Classes in org.mule.transport.file.transformers that implement MessageProcessor
`class` | `FileToByteArray` `FileToByteArray` reads the contents of a file as a byte array.
`class` | `FileToString` `FileToString` reads file contents into a string.

Uses of MessageProcessor in org.mule.transport.ftp

Classes in org.mule.transport.ftp that implement MessageProcessor
`class` | `FtpMessageDispatcher`

Uses of MessageProcessor in org.mule.transport.http

Classes in org.mule.transport.http that implement MessageProcessor
`class` | `HttpClientMessageDispatcher` `HttpClientMessageDispatcher` dispatches Mule events over HTTP.
`class` | `HttpsClientMessageDispatcher`

Methods in org.mule.transport.http with parameters of type MessageProcessor
`void` | `HttpConnector.registerListener(InboundEndpoint endpoint, MessageProcessor listener, FlowConstruct flowConstruct)`

Uses of MessageProcessor in org.mule.transport.http.components

Classes in org.mule.transport.http.components that implement MessageProcessor
`class` | `RestServiceWrapper` This service can used to proxy REST style services as local Mule Components.

Uses of MessageProcessor in org.mule.transport.http.transformers

Classes in org.mule.transport.http.transformers that implement MessageProcessor
`class` | `HttpClientMethodResponseToObject` `HttpClientMethodResponseToObject` transforms a http client response to a DefaultMuleMessage.
`class` | `HttpRequestBodyToParamMap`
`class` | `HttpResponseToString` Converts an Http Response object to String.
`class` | `MuleMessageToHttpResponse` Converts a `MuleMessage` into an Http response.
`class` | `ObjectToHttpClientMethodRequest` `ObjectToHttpClientMethodRequest` transforms a MuleMessage into a HttpClient HttpMethod that represents an HttpRequest.
`class` | `ServletRequestToOutputHandler` Adds support for converting a `HttpServletRequest` into an `OutputHandler`

Uses of MessageProcessor in org.mule.transport.ibean

Classes in org.mule.transport.ibean that implement MessageProcessor
`class` | `IBeansMessageDispatcher` `IBeansMessageDispatcher` TODO document

Uses of MessageProcessor in org.mule.transport.jdbc

Classes in org.mule.transport.jdbc that implement MessageProcessor
`class` | `JdbcMessageDispatcher` The Jdbc Message dispatcher is responsible for executing SQL queries against a database.

Uses of MessageProcessor in org.mule.transport.jms

Classes in org.mule.transport.jms that implement MessageProcessor
`class` | `JmsMessageDispatcher` `JmsMessageDispatcher` is responsible for dispatching messages to JMS destinations.

Uses of MessageProcessor in org.mule.transport.jms.transformers

Classes in org.mule.transport.jms.transformers that implement MessageProcessor
`class` | `AbstractJmsTransformer` `AbstractJmsTransformer` is an abstract class that should be used for all transformers where a JMS message will be the transformed or transformee object.
`class` | `JMSMessageToObject` `JMSMessageToObject` Will convert a `javax.jms.Message` or sub-type into an object by extracting the message payload.
`class` | `ObjectToJMSMessage` `ObjectToJMSMessage` will convert any object to a `javax.jms.Message` or sub-type into an object.

Uses of MessageProcessor in org.mule.transport.quartz

Classes in org.mule.transport.quartz that implement MessageProcessor
`class` | `QuartzMessageDispatcher` Can schedule a Job with the Quartz scheduler.

Uses of MessageProcessor in org.mule.transport.rmi

Classes in org.mule.transport.rmi that implement MessageProcessor
`class` | `RmiMessageDispatcher` `RmiMessageDispatcher` will send transformed mule events over RMI-JRMP.

Uses of MessageProcessor in org.mule.transport.servlet.transformers

Classes in org.mule.transport.servlet.transformers that implement MessageProcessor
`class` | `HttpRequestToByteArray` Converts an `HttpServletRequest` into an array of bytes by extracting the payload of the request.
`class` | `HttpRequestToInputStream` Converts a `HttpServletRequest` into an `InputStream`.
`class` | `HttpRequestToParameter`
`class` | `HttpRequestToParameterMap` Returns a simple Map of the parameters sent with the HTTP Request.

Uses of MessageProcessor in org.mule.transport.soap.axis

Classes in org.mule.transport.soap.axis that implement MessageProcessor
`class` | `AxisMessageDispatcher` `AxisMessageDispatcher` is used to make soap requests via the Axis soap client.

Uses of MessageProcessor in org.mule.transport.soap.axis.wsdl

Classes in org.mule.transport.soap.axis.wsdl that implement MessageProcessor
`class` | `AxisWsdlMessageDispatcher` Creates and Axis client services from WSDL and invokes it.

Uses of MessageProcessor in org.mule.transport.stdio

Classes in org.mule.transport.stdio that implement MessageProcessor
`class` | `StdioMessageDispatcher` `StdioMessageDispatcher` is a simple stream dispatcher that obtains a stream from the Stream Connector to write to.

Methods in org.mule.transport.stdio with parameters of type MessageProcessor
`void` | `StdioConnector.registerListener(InboundEndpoint endpoint, MessageProcessor listener, FlowConstruct flowConstruct)`

Uses of MessageProcessor in org.mule.transport.tcp

Classes in org.mule.transport.tcp that implement MessageProcessor
`class` | `LocalSocketTcpMessageDispatcher` `LocalSocketTcpMessageDispatcher` will send transformed Mule events over TCP.
`class` | `TcpMessageDispatcher` Send transformed Mule events over TCP.

Uses of MessageProcessor in org.mule.transport.udp

Classes in org.mule.transport.udp that implement MessageProcessor
`class` | `UdpMessageDispatcher` `UdpMessageDispatcher` is responsible for dispatching MuleEvents as UDP packets on the network

Uses of MessageProcessor in org.mule.transport.vm

Classes in org.mule.transport.vm that implement MessageProcessor
`class` | `VMMessageDispatcher` `VMMessageDispatcher` is used for providing in memory interaction between components.

Uses of MessageProcessor in org.mule.transport.xmpp

Classes in org.mule.transport.xmpp that implement MessageProcessor
`class` | `XmppMessageDispatcher` Allows Mule events to be sent over Xmpp

Uses of MessageProcessor in org.mule.transport.xmpp.transformers

Classes in org.mule.transport.xmpp.transformers that implement MessageProcessor
`class` | `ObjectToXmppPacket` Creates an Xmpp message packet from a MuleMessage
`class` | `XmppPacketToObject`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES

Copyright © 2003-2010 MuleSoft, Inc.. All Rights Reserved.