|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Uses of AnnotatedObject in org.mule.api.processor |
---|
Classes in org.mule.api.processor that implement AnnotatedObject | |
---|---|
class |
LoggerMessageProcessor
MessageProcessor implementation that logs the current element of a value evaluated from it using an expression evaluator. |
Uses of AnnotatedObject in org.mule.component |
---|
Classes in org.mule.component that implement AnnotatedObject | |
---|---|
class |
AbstractComponent
Abstract Component to be used by all Component implementations. |
class |
AbstractJavaComponent
Abstract implementation of JavaComponent adds JavaComponent specifics like EntryPointResolverSet and ObjectFactory . |
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 . |
Uses of AnnotatedObject in org.mule.component.simple |
---|
Classes in org.mule.component.simple that implement AnnotatedObject | |
---|---|
class |
PassThroughComponent
PassThroughComponent will simply return the payload back as the
result. |
Uses of AnnotatedObject in org.mule.config.dsl.routers |
---|
Classes in org.mule.config.dsl.routers that implement AnnotatedObject | |
---|---|
class |
ContentBasedRouter
Deprecated. |
Uses of AnnotatedObject in org.mule.config.spring.factories |
---|
Classes in org.mule.config.spring.factories that implement AnnotatedObject | |
---|---|
class |
AbstractEndpointFactoryBean
Abstract spring FactoryBean used to creating endpoints via spring. |
class |
AbstractSelectiveRouterFactoryBean
|
class |
AsyncMessageProcessorsFactoryBean
|
class |
ChoiceRouterFactoryBean
|
class |
InboundEndpointFactoryBean
Spring FactoryBean used to create concrete instances of inbound endpoints |
class |
OutboundEndpointFactoryBean
Spring FactoryBean used to create concrete instances of outbound endpoints |
class |
PollInboundEndpointFactoryBean
Spring FactoryBean used to create concrete instances of inbound endpoints |
class |
PollingMessageSourceFactoryBean
|
class |
WatermarkFactoryBean
|
Uses of AnnotatedObject in org.mule.config.transformer |
---|
Classes in org.mule.config.transformer that implement AnnotatedObject | |
---|---|
class |
AnnotatedTransformerProxy
Creates a Mule Transformer proxy around a transform method. |
Uses of AnnotatedObject in org.mule.construct |
---|
Classes in org.mule.construct that implement AnnotatedObject | |
---|---|
class |
AbstractConfigurationPattern
A template class for configuration patterns, which takes care of setting common message processors and optional transformers defined on the pattern. |
class |
AbstractFlowConstruct
Abstract implementation of FlowConstruct that:
Is constructed with unique name and MuleContext . |
class |
AbstractPipeline
Abstract implementation of AbstractFlowConstruct that allows a list of AbstractPipeline.ProcessIfPipelineStartedMessageProcessor s
that will be used to process messages to be configured. |
class |
AbstractPipeline.ProcessIfPipelineStartedMessageProcessor
|
class |
Bridge
A simple bridge between a single inbound endpoint and a single outbound endpoint. |
class |
Flow
This implementation of AbstractPipeline adds the following functionality:
Rejects inbound events when Flow is not started
Gathers statistics and processing time data
Implements MessagePorcessor allowing direct invocation of the pipeline
Supports the optional configuration of a ProcessingStrategy that determines how message
processors are processed. |
class |
SimpleService
In-out SOA-style simple service, with no outbound router. |
class |
Validator
|
Uses of AnnotatedObject in org.mule.endpoint |
---|
Classes in org.mule.endpoint that implement AnnotatedObject | |
---|---|
class |
AbstractEndpoint
ImmutableMuleEndpoint describes a Provider in the Mule Server. |
class |
AbstractEndpointBuilder
Abstract endpoint builder used for externalizing the complex creation logic of endpoints out of the endpoint instance itself. |
class |
AbstractMetaEndpointBuilder
A base class used for Meta endpoint builders such as RSS or ATOM. |
class |
DefaultInboundEndpoint
|
class |
DefaultOutboundEndpoint
|
class |
EndpointURIEndpointBuilder
|
class |
URIBuilder
This has the following logic: - if an address is specified, it is used verbatim (except for parameters); this is consistent with the generic case - otherwise, we construct from components, omitting things that aren't specified as much as possible (use required attributes to guarantee entries) In addition, parameters are handled as follows: - parameters can be given in the uri, the queryMap, or both - queryMap values override uri values - the order of parameters in the uri remains the same (even if values change) - queryMap parameters are appended after uri parameters TODO - check that we have sufficient control via XML (what about empty strings?) Not called EndpointURIBuilder because of EndpointURIBuilder |
Uses of AnnotatedObject in org.mule.endpoint.outbound |
---|
Classes in org.mule.endpoint.outbound that implement AnnotatedObject | |
---|---|
class |
OutboundResponsePropertiesMessageProcessor
Propagates properties from request message to response message as defined by OutboundEndpoint.getResponseProperties() . |
class |
OutboundTxRollbackMessageProcessor
MessageProcessor implementation that stops outbound flow is the current transaction has been rolled back. |
Uses of AnnotatedObject in org.mule.enricher |
---|
Classes in org.mule.enricher that implement AnnotatedObject | |
---|---|
class |
MessageEnricher
The Message Enricher allows the current message to be augmented using data from a seperate
resource. |
Uses of AnnotatedObject in org.mule.example.bookstore.transformers |
---|
Classes in org.mule.example.bookstore.transformers that implement AnnotatedObject | |
---|---|
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 AnnotatedObject in org.mule.example.errorhandler |
---|
Classes in org.mule.example.errorhandler that implement AnnotatedObject | |
---|---|
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 AnnotatedObject in org.mule.example.geomail.transformers |
---|
Classes in org.mule.example.geomail.transformers that implement AnnotatedObject | |
---|---|
class |
IPToSender
TODO |
Uses of AnnotatedObject in org.mule.example.hello |
---|
Classes in org.mule.example.hello that implement AnnotatedObject | |
---|---|
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 AnnotatedObject in org.mule.example.loanbroker.routers |
---|
Classes in org.mule.example.loanbroker.routers that implement AnnotatedObject | |
---|---|
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 AnnotatedObject in org.mule.example.loanbroker.transformers |
---|
Classes in org.mule.example.loanbroker.transformers that implement AnnotatedObject | |
---|---|
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 AnnotatedObject in org.mule.example.scripting |
---|
Classes in org.mule.example.scripting that implement AnnotatedObject | |
---|---|
class |
SimpleMathTransformer
A simple transformer which adds/subtracts/multiplies/divides a constant factor to numeric messages. |
Uses of AnnotatedObject in org.mule.exception |
---|
Classes in org.mule.exception that implement AnnotatedObject | |
---|---|
class |
AbstractExceptionListener
This is the base class for exception strategies which contains several helper methods. |
class |
AbstractExceptionStrategy
Deprecated. use AbstractExceptionListener |
class |
AbstractMessagingExceptionStrategy
Fire a notification, log exception, increment statistics, route the problematic message to a destination if one is configured (DLQ pattern), commit or rollback transaction if one exists, close any open streams. |
class |
AbstractSystemExceptionStrategy
Fire a notification, log exception, clean up transaction if any, and trigger reconnection strategy if this is a ConnectException . |
class |
CatchMessagingExceptionStrategy
|
class |
DefaultMessagingExceptionStrategy
This is the default exception handler for flows and services. |
class |
DefaultServiceExceptionStrategy
Deprecated. use DefaultMessagingExceptionStrategy instead |
class |
DefaultSystemExceptionStrategy
This is the default exception handler for any exception which does not inherit from MessagingException, i.e, when no message is in play. |
class |
RollbackMessagingExceptionStrategy
|
class |
TemplateMessagingExceptionStrategy
|
Uses of AnnotatedObject in org.mule.expression.transformers |
---|
Classes in org.mule.expression.transformers that implement AnnotatedObject | |
---|---|
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 AnnotatedObject in org.mule.interceptor |
---|
Classes in org.mule.interceptor that implement AnnotatedObject | |
---|---|
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 |
ProcessingTimeInterceptor
Calculate and record the processing time for a message processing chain |
class |
TimerInterceptor
TimerInterceptor simply times and displays the time taken to process
an event. |
Uses of AnnotatedObject in org.mule.lifecycle.processor |
---|
Classes in org.mule.lifecycle.processor that implement AnnotatedObject | |
---|---|
class |
ProcessIfStartedMessageProcessor
|
class |
ProcessIfStartedWaitIfPausedMessageProcessor
|
class |
ProcessIfStartedWaitIfSyncPausedMessageProcessor
|
Uses of AnnotatedObject in org.mule.model.seda |
---|
Classes in org.mule.model.seda that implement AnnotatedObject | |
---|---|
class |
SedaService
Deprecated. |
Uses of AnnotatedObject in org.mule.module.atom |
---|
Classes in org.mule.module.atom that implement AnnotatedObject | |
---|---|
class |
AbderaServiceComponent
This component receives requests from Mule and passes them off to Abdera. |
Uses of AnnotatedObject in org.mule.module.atom.routing |
---|
Classes in org.mule.module.atom.routing that implement AnnotatedObject | |
---|---|
class |
FeedSplitter
An inbound router that will split a Feed into entries. |
Uses of AnnotatedObject in org.mule.module.atom.transformers |
---|
Classes in org.mule.module.atom.transformers that implement AnnotatedObject | |
---|---|
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 AnnotatedObject in org.mule.module.bpm |
---|
Classes in org.mule.module.bpm that implement AnnotatedObject | |
---|---|
class |
ProcessComponent
A service backed by the execution of a business process such as jBPM. |
class |
RulesComponent
A service backed by a Business Rules engine such as Drools. |
Uses of AnnotatedObject in org.mule.module.cxf |
---|
Classes in org.mule.module.cxf that implement AnnotatedObject | |
---|---|
class |
CxfComponentExceptionStrategy
Deprecated. Currently the result is the same if no exception strategy is defined within the flow. The only difference is that when you set the CxfComponentExceptionStrategy the exception is unwrapped inside of the exception block, but the exceptionPayload doesn't change. |
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 AnnotatedObject in org.mule.module.cxf.builder |
---|
Classes in org.mule.module.cxf.builder that implement AnnotatedObject | |
---|---|
class |
AbstractInboundMessageProcessorBuilder
An abstract builder for CXF services. |
class |
ProxyServiceMessageProcessorBuilder
Creates an inbound proxy based on a specially configure CXF Server. |
class |
WebServiceMessageProcessorBuilder
Builds a CXF web service MessageProcessor using either the JAX-WS or simple frontends. |
Uses of AnnotatedObject in org.mule.module.cxf.component |
---|
Classes in org.mule.module.cxf.component that implement AnnotatedObject | |
---|---|
class |
AbstractWebServiceWrapperComponent
|
class |
WebServiceWrapperComponent
Deprecated. |
Uses of AnnotatedObject in org.mule.module.cxf.config |
---|
Classes in org.mule.module.cxf.config that implement AnnotatedObject | |
---|---|
class |
ProxyServiceFactoryBean
|
class |
WebServiceFactoryBean
|
Uses of AnnotatedObject in org.mule.module.cxf.endpoint |
---|
Classes in org.mule.module.cxf.endpoint that implement AnnotatedObject | |
---|---|
class |
CxfEndpointBuilder
|
class |
WsdlCxfEndpointBuilder
|
Uses of AnnotatedObject in org.mule.module.jersey |
---|
Classes in org.mule.module.jersey that implement AnnotatedObject | |
---|---|
class |
JerseyResourcesComponent
Wraps a set of components which can get invoked by Jersey. |
Uses of AnnotatedObject in org.mule.module.json.transformers |
---|
Classes in org.mule.module.json.transformers that implement AnnotatedObject | |
---|---|
class |
AbstractJsonTransformer
TODO |
class |
AbstractToFromXmlTransformer
Superclass for transformers that convert JSON to and from XML |
class |
JsonToObject
A transformer that will convert a JSON encoded object graph to a java object. |
class |
JsonToXml
Convert JSON to an XML document string |
class |
JsonXsltTransformer
Convert Json to Json using XSLT |
class |
ObjectToJson
Converts a java object to a JSON encoded object that can be consumed by other languages such as Javascript or Ruby. |
class |
XmlToJson
Convert XML to a JSON string |
Uses of AnnotatedObject in org.mule.module.rss.transformers |
---|
Classes in org.mule.module.rss.transformers that implement AnnotatedObject | |
---|---|
class |
ObjectToRssFeed
Converts an RSS data representation into a SyndFeed object |
Uses of AnnotatedObject in org.mule.module.scripting.component |
---|
Classes in org.mule.module.scripting.component that implement AnnotatedObject | |
---|---|
class |
ScriptComponent
A Script service backed by a JSR-223 compliant script engine such as Groovy, JavaScript, or Rhino. |
Uses of AnnotatedObject in org.mule.module.scripting.filter |
---|
Classes in org.mule.module.scripting.filter that implement AnnotatedObject | |
---|---|
class |
ScriptFilter
|
Uses of AnnotatedObject in org.mule.module.scripting.transformer |
---|
Classes in org.mule.module.scripting.transformer that implement AnnotatedObject | |
---|---|
class |
ScriptTransformer
Runs a script to perform transformation on an object. |
Uses of AnnotatedObject in org.mule.module.spring.remoting |
---|
Classes in org.mule.module.spring.remoting that implement AnnotatedObject | |
---|---|
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 AnnotatedObject in org.mule.module.sxc |
---|
Classes in org.mule.module.sxc that implement AnnotatedObject | |
---|---|
class |
SxcFilteringOutboundRouter
FilteringRouter is a router that accepts events based on a filter
set. |
Uses of AnnotatedObject in org.mule.module.ws.construct |
---|
Classes in org.mule.module.ws.construct that implement AnnotatedObject | |
---|---|
class |
WSProxy
This class is implemented to act as a Proxy for a Web Service. |
Uses of AnnotatedObject in org.mule.module.xml.transformer |
---|
Classes in org.mule.module.xml.transformer that implement AnnotatedObject | |
---|---|
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 AnnotatedObject in org.mule.module.xml.transformer.jaxb |
---|
Classes in org.mule.module.xml.transformer.jaxb that implement AnnotatedObject | |
---|---|
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 AnnotatedObject in org.mule.processor |
---|
Classes in org.mule.processor that implement AnnotatedObject | |
---|---|
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 |
AbstractInterceptingMessageProcessorBase
Abstract implementation that provides the infrastructure for intercepting message processors. |
class |
AbstractMessageProcessorOwner
An object that owns message processors and delegates startup/shutdown events to them. |
class |
AbstractRedeliveryPolicy
Implement a redelivery policy for Mule. |
class |
AbstractResponseMessageProcessor
|
class |
AsyncDelegateMessageProcessor
Processes MuleEvent 's asynchronously using a MuleWorkManager to schedule asynchronous
processing of MessageProcessor delegate configured the next MessageProcessor . |
class |
AsyncInterceptingMessageProcessor
Processes MuleEvent 's asynchronously using a MuleWorkManager to
schedule asynchronous processing of the next MessageProcessor . |
class |
EndpointTransactionalInterceptingMessageProcessor
Wraps the invocation of the next MessageProcessor with a transaction. |
class |
ExceptionHandlingMessageProcessor
|
class |
IdempotentRedeliveryPolicy
Implement a retry policy for Mule. |
class |
InvokerMessageProcessor
InvokerMessageProcessor invokes a specified method of an object. |
class |
LaxAsyncInterceptingMessageProcessor
|
class |
LaxSedaStageInterceptingMessageProcessor
Processes MuleEvent 's asynchronously using a MuleWorkManager to schedule asynchronous
processing of the next MessageProcessor . |
class |
ResponseMessageProcessorAdapter
|
class |
SecurityFilterMessageProcessor
Filters the flow using the specified SecurityFilter . |
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. |
Uses of AnnotatedObject in org.mule.routing |
---|
Classes in org.mule.routing that implement AnnotatedObject | |
---|---|
class |
AbstractAggregator
AbstractEventAggregator will aggregate a set of messages into a
single message. |
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 Collection, Iterable, MessageSequence or Iterator payload invoking the next message processor one for each item in it. |
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 |
Foreach
` * The Foreach MessageProcessor allows iterating over a collection payload, or any collection
obtained by an expression, generating a message for each element. |
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 |
MapSplitter
Splits a message that has a map payload invoking the next message processor one for each item in the map in order. |
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
Resequencer 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 |
ScatterGatherRouter
The Scatter-Gather router will broadcast copies of the current
message to every endpoint registered with the router in parallel. |
class |
SimpleCollectionAggregator
This router will return all aggregated events as a MuleMessageCollection . |
class |
UntilSuccessful
UntilSuccessful attempts to route a message to the message processor it contains. |
class |
WireTap
The WireTap MessageProcessor allows inspection of messages in a flow. |
Uses of AnnotatedObject in org.mule.routing.outbound |
---|
Classes in org.mule.routing.outbound that implement AnnotatedObject | |
---|---|
class |
AbstractMessageSequenceSplitter
Base implementation of a MuleMessage splitter, that converts its payload
in a MessageSequence , and process each element of it. |
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 |
AbstractSequenceRouter
Defines a router that sequentially routes a given message to the list of registered endpoints and returns the aggregate responses as the result. |
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 |
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
registered with the router. |
class |
OutboundPassThroughRouter
OutboundPassThroughRouter allows outbound routing over a single
endpoint without any filtering. |
class |
SequenceRouter
Defines a AbstractSequenceRouter that stops the routing of a given
message when a synchronous endpoint has returned a null or an exception
message. |
class |
StaticRecipientList
StaticRecipientList is used to dispatch a single event to multiple
recipients over the same transport. |
class |
TransformerRouter
Deprecated. |
Uses of AnnotatedObject in org.mule.routing.requestreply |
---|
Classes in org.mule.routing.requestreply that implement AnnotatedObject | |
---|---|
class |
AbstractAsyncRequestReplyRequester
|
class |
AbstractReplyToPropertyRequestReplyReplier
|
class |
AsyncReplyToPropertyRequestReplyReplier
|
class |
ReplyToPropertyRequestReplyReplier
|
class |
SimpleAsyncRequestReplyRequester
|
class |
SimpleRequestReplyReplier
|
Uses of AnnotatedObject in org.mule.service |
---|
Classes in org.mule.service that implement AnnotatedObject | |
---|---|
class |
AbstractService
Deprecated. |
class |
ForwardingConsumer
Deprecated. |
Uses of AnnotatedObject in org.mule.service.processor |
---|
Classes in org.mule.service.processor that implement AnnotatedObject | |
---|---|
class |
ServiceAsyncRequestReplyRequestor
Deprecated. |
class |
ServiceInternalMessageProcessor
Deprecated. |
class |
ServiceOutboundMessageProcessor
Deprecated. |
Uses of AnnotatedObject in org.mule.tck.functional |
---|
Classes in org.mule.tck.functional that implement AnnotatedObject | |
---|---|
class |
QuietExceptionStrategy
Restrict exceptions to debug log messages |
class |
StringAppendTestTransformer
|
Uses of AnnotatedObject in org.mule.tck.transformer |
---|
Classes in org.mule.tck.transformer that implement AnnotatedObject | |
---|---|
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 AnnotatedObject in org.mule.transformer |
---|
Classes in org.mule.transformer that implement AnnotatedObject | |
---|---|
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 AnnotatedObject in org.mule.transformer.codec |
---|
Classes in org.mule.transformer.codec that implement AnnotatedObject | |
---|---|
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 AnnotatedObject in org.mule.transformer.compression |
---|
Classes in org.mule.transformer.compression that implement AnnotatedObject | |
---|---|
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 AnnotatedObject in org.mule.transformer.encryption |
---|
Classes in org.mule.transformer.encryption that implement AnnotatedObject | |
---|---|
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 AnnotatedObject in org.mule.transformer.simple |
---|
Classes in org.mule.transformer.simple that implement AnnotatedObject | |
---|---|
class |
AbstractAddVariablePropertyTransformer
|
class |
AbstractRemoveVariablePropertyTransformer
|
class |
AddAttachmentTransformer
|
class |
AddFlowVariableTransformer
|
class |
AddPropertyTransformer
|
class |
AddSessionVariableTransformer
|
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 |
CopyAttachmentsTransformer
|
class |
CopyPropertiesTransformer
|
class |
DataHandlerToInputStreamTransformer
|
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 |
NumberToString
NumberToString converts a Number to a String. |
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 |
ParseTemplateTransformer
Loads a template and parses its content to resolve expressions. |
class |
PropertyEditorTextToValueTransformer
PropertyEditorTextToValueTransformer adapts a PropertyEditor
instance allowing it to be used to transform from a String to another type in Mule |
class |
PropertyEditorValueToTextTransformer
PropertyEditorValueToTextTransformer adapts a PropertyEditor
instance allowing it to be used to transform from a specific type to a String. |
class |
RemoveAttachmentTransformer
|
class |
RemoveFlowVariableTransformer
|
class |
RemovePropertyTransformer
|
class |
RemoveSessionVariableTransformer
|
class |
SerializableToByteArray
SerializableToByteArray converts a serializable object or a String
to a byte array. |
class |
SetPayloadTransformer
Transformer that modifies the payload of the message according to the provided value. |
class |
StringAppendTransformer
|
class |
StringToBoolean
ByteArrayToSerializable converts a serialized object to its object
representation |
class |
StringToNumber
StringToNumber converts a String to a Number. |
class |
StringToObjectArray
StringToObjectArray converts a String into an object array. |
Uses of AnnotatedObject in org.mule.transport.email.transformers |
---|
Classes in org.mule.transport.email.transformers that implement AnnotatedObject | |
---|---|
class |
EmailMessageToString
EmailMessageToString extracts the text body of java mail Message 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 AnnotatedObject in org.mule.transport.file.transformers |
---|
Classes in org.mule.transport.file.transformers that implement AnnotatedObject | |
---|---|
class |
FileToByteArray
FileToByteArray reads the contents of a file as a byte array. |
class |
FileToString
FileToString reads file contents into a string. |
Uses of AnnotatedObject in org.mule.transport.http.components |
---|
Classes in org.mule.transport.http.components that implement AnnotatedObject | |
---|---|
class |
HttpResponseBuilder
|
class |
RestServiceWrapper
This service can used to proxy REST style services as local Mule Components. |
Uses of AnnotatedObject in org.mule.transport.http.construct |
---|
Classes in org.mule.transport.http.construct that implement AnnotatedObject | |
---|---|
class |
HttpProxy
A simple HTTP proxy that supports transformation and caching. |
Uses of AnnotatedObject in org.mule.transport.http.servlet |
---|
Classes in org.mule.transport.http.servlet that implement AnnotatedObject | |
---|---|
class |
ServletTransformer
THIS CLASS IS UNSUPPORTED AND THE IMPLEMENTATION DOES NOT CONFORM TO THE SERVLET SPECIFICATION! With that said, it can be used to make integration with libraries that only support servlets easier. |
Uses of AnnotatedObject in org.mule.transport.http.transformers |
---|
Classes in org.mule.transport.http.transformers that implement AnnotatedObject | |
---|---|
class |
FormTransformer
Converts HTML forms POSTs into a Map of parameters. |
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 AnnotatedObject in org.mule.transport.jms.transformers |
---|
Classes in org.mule.transport.jms.transformers that implement AnnotatedObject | |
---|---|
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 AnnotatedObject in org.mule.transport.servlet.transformers |
---|
Classes in org.mule.transport.servlet.transformers that implement AnnotatedObject | |
---|---|
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 AnnotatedObject in org.mule.transport.sftp.transformers |
---|
Classes in org.mule.transport.sftp.transformers that implement AnnotatedObject | |
---|---|
class |
InputStreamToByteArray
TODO |
Uses of AnnotatedObject in org.mule.transport.xmpp.transformers |
---|
Classes in org.mule.transport.xmpp.transformers that implement AnnotatedObject | |
---|---|
class |
ObjectToXmppPacket
Creates an Xmpp message packet from a MuleMessage |
class |
XmppPacketToObject
|
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |