|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Uses of FlowConstructAware in org.mule.api.component |
---|
Subinterfaces of FlowConstructAware 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 |
JavaComponent
JavaComponent is a Java Component implementation used to
invoke Java component implementations. |
Uses of FlowConstructAware in org.mule.api.endpoint |
---|
Subinterfaces of FlowConstructAware in org.mule.api.endpoint | |
---|---|
interface |
InboundEndpoint
|
Uses of FlowConstructAware in org.mule.api.routing |
---|
Subinterfaces of FlowConstructAware in org.mule.api.routing | |
---|---|
interface |
OutboundRouter
OutboundRouter is used to control outbound routing behaviour for an
event. |
Uses of FlowConstructAware in org.mule.component |
---|
Classes in org.mule.component that implement FlowConstructAware | |
---|---|
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 FlowConstructAware in org.mule.component.simple |
---|
Classes in org.mule.component.simple that implement FlowConstructAware | |
---|---|
class |
PassThroughComponent
PassThroughComponent will simply return the payload back as the
result. |
Uses of FlowConstructAware in org.mule.config.dsl.routers |
---|
Classes in org.mule.config.dsl.routers that implement FlowConstructAware | |
---|---|
class |
ContentBasedRouter
TODO |
Uses of FlowConstructAware in org.mule.config.spring.util |
---|
Classes in org.mule.config.spring.util that implement FlowConstructAware | |
---|---|
class |
SpringBeanLookup
This is an implementation of the ObjectFactory interface which simply delegates to the Spring ApplicationContext. |
Uses of FlowConstructAware in org.mule.construct.processor |
---|
Classes in org.mule.construct.processor that implement FlowConstructAware | |
---|---|
class |
FlowConstructStatisticsMessageProcessor
|
Uses of FlowConstructAware in org.mule.endpoint |
---|
Classes in org.mule.endpoint that implement FlowConstructAware | |
---|---|
class |
DefaultInboundEndpoint
|
class |
DynamicURIInboundEndpoint
Allow's EndpointURI to be set and changed dynamically by wrapping up an immutable endpoint instance. |
Uses of FlowConstructAware in org.mule.enricher |
---|
Classes in org.mule.enricher that implement FlowConstructAware | |
---|---|
class |
MessageEnricher
The Message Enricher allows the current message to be augmented using data from a seperate
resource. |
Uses of FlowConstructAware in org.mule.example.loanbroker.bank |
---|
Classes in org.mule.example.loanbroker.bank that implement FlowConstructAware | |
---|---|
class |
Bank
Bank is a representation of a bank from which to obtain loan
quotes. |
Uses of FlowConstructAware in org.mule.example.loanbroker.routers |
---|
Classes in org.mule.example.loanbroker.routers that implement FlowConstructAware | |
---|---|
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 FlowConstructAware in org.mule.exception |
---|
Classes in org.mule.exception that implement FlowConstructAware | |
---|---|
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 |
ChoiceMessagingExceptionStrategy
Selects which exception strategy to execute based on filtering. |
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 |
MessagingExceptionStrategyAcceptorDelegate
Allows to use MessagingExceptionHandler as MessagingExceptionHandlerAcceptor . |
class |
RedeliveryExceeded
|
class |
RollbackMessagingExceptionStrategy
|
class |
TemplateMessagingExceptionStrategy
|
Uses of FlowConstructAware in org.mule.interceptor |
---|
Classes in org.mule.interceptor that implement FlowConstructAware | |
---|---|
class |
AbstractEnvelopeInterceptor
EnvelopeInterceptor is an intercepter that will fire before and after
an event is received. |
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 |
Uses of FlowConstructAware in org.mule.module.atom |
---|
Classes in org.mule.module.atom that implement FlowConstructAware | |
---|---|
class |
AbderaServiceComponent
This component receives requests from Mule and passes them off to Abdera. |
Uses of FlowConstructAware in org.mule.module.bpm |
---|
Classes in org.mule.module.bpm that implement FlowConstructAware | |
---|---|
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 FlowConstructAware in org.mule.module.cxf |
---|
Classes in org.mule.module.cxf that implement FlowConstructAware | |
---|---|
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. |
Uses of FlowConstructAware in org.mule.module.cxf.builder |
---|
Classes in org.mule.module.cxf.builder that implement FlowConstructAware | |
---|---|
class |
WebServiceMessageProcessorBuilder
Builds a CXF web service MessageProcessor using either the JAX-WS or simple frontends. |
Uses of FlowConstructAware in org.mule.module.cxf.component |
---|
Classes in org.mule.module.cxf.component that implement FlowConstructAware | |
---|---|
class |
AbstractWebServiceWrapperComponent
|
class |
WebServiceWrapperComponent
Deprecated. |
Uses of FlowConstructAware in org.mule.module.cxf.config |
---|
Classes in org.mule.module.cxf.config that implement FlowConstructAware | |
---|---|
class |
FlowConfiguringMessageProcessor
Wraps a MessageProcessorBuilder and configures it lazily so it can
be injected with the FlowConstruct . |
class |
WebServiceFactoryBean
|
Uses of FlowConstructAware in org.mule.module.ibeans.spi.support |
---|
Classes in org.mule.module.ibeans.spi.support that implement FlowConstructAware | |
---|---|
class |
CallRequestEndpoint
A dynamic inbound endpoint used for request calls defined using the Call annotation. |
class |
DynamicRequestEndpoint
A dynamic request endpoint is used in conjunction with the Call annotation when there are no Body ,
BodyParam or HeaderParam annotations
on a method and allows a dynamic InboundEndpoint to be created. |
protected static class |
DynamicRequestEndpoint.NullInboundEndpoint
|
Uses of FlowConstructAware in org.mule.module.jca |
---|
Classes in org.mule.module.jca that implement FlowConstructAware | |
---|---|
class |
JcaComponent
|
Uses of FlowConstructAware in org.mule.module.jersey |
---|
Classes in org.mule.module.jersey that implement FlowConstructAware | |
---|---|
class |
JerseyResourcesComponent
Wraps a set of components which can get invoked by Jersey. |
Uses of FlowConstructAware in org.mule.module.scripting.component |
---|
Classes in org.mule.module.scripting.component that implement FlowConstructAware | |
---|---|
class |
ScriptComponent
A Script service backed by a JSR-223 compliant script engine such as Groovy, JavaScript, or Rhino. |
Uses of FlowConstructAware in org.mule.module.sxc |
---|
Classes in org.mule.module.sxc that implement FlowConstructAware | |
---|---|
class |
SxcFilteringOutboundRouter
FilteringRouter is a router that accepts events based on a filter
set. |
Uses of FlowConstructAware in org.mule.module.xml.routing |
---|
Classes in org.mule.module.xml.routing that implement FlowConstructAware | |
---|---|
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 FlowConstructAware in org.mule.object |
---|
Classes in org.mule.object that implement FlowConstructAware | |
---|---|
class |
AbstractObjectFactory
Creates object instances based on the class and sets any properties. |
class |
PrototypeObjectFactory
Creates a new instance of the object on each call. |
class |
SingletonObjectFactory
Creates an instance of the object once and then always returns the same instance. |
Uses of FlowConstructAware in org.mule.processor |
---|
Classes in org.mule.processor that implement FlowConstructAware | |
---|---|
class |
AbstractMessageProcessorOwner
An object that owns message processors and delegates startup/shutdown events to them. |
class |
AbstractMuleObjectOwner<T>
An object that owns Mule objects and delegates startup/shutdown events to them. |
class |
AbstractRedeliveryPolicy
Implement a redelivery policy for Mule. |
class |
AsyncDelegateMessageProcessor
Processes MuleEvent 's asynchronously using a MuleWorkManager to schedule asynchronous
processing of MessageProcessor delegate configured the next MessageProcessor . |
class |
IdempotentRedeliveryPolicy
Implement a retry policy for Mule. |
class |
ResponseMessageProcessorAdapter
|
Uses of FlowConstructAware in org.mule.processor.chain |
---|
Classes in org.mule.processor.chain that implement FlowConstructAware | |
---|---|
class |
AbstractMessageProcessorChain
Builder needs to return a composite rather than the first MessageProcessor in the chain. |
class |
DefaultMessageProcessorChain
|
class |
InterceptingChainLifecycleWrapper
Builder needs to return a composite rather than the first MessageProcessor in the chain. |
class |
SimpleMessageProcessorChain
|
Uses of FlowConstructAware in org.mule.routing |
---|
Classes in org.mule.routing that implement FlowConstructAware | |
---|---|
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 |
AbstractSelectiveRouter
|
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 |
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 |
MessageChunkAggregator
|
class |
MessageFilter
Implementation of InterceptingMessageProcessor that filters message flow
using a Filter . |
class |
MessageProcessorFilterPair
A holder for a pair of MessageProcessor and 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 |
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 in an asynchronous manner. |
class |
WireTap
The WireTap MessageProcessor allows inspection of messages in a flow. |
Uses of FlowConstructAware in org.mule.routing.outbound |
---|
Classes in org.mule.routing.outbound that implement FlowConstructAware | |
---|---|
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 FlowConstructAware in org.mule.routing.requestreply |
---|
Classes in org.mule.routing.requestreply that implement FlowConstructAware | |
---|---|
class |
AbstractAsyncRequestReplyRequester
|
class |
SimpleAsyncRequestReplyRequester
|
Uses of FlowConstructAware in org.mule.service |
---|
Classes in org.mule.service that implement FlowConstructAware | |
---|---|
class |
ForwardingConsumer
Deprecated. |
class |
ServiceAsyncReplyCompositeMessageSource
Extension of StartableCompositeMessageSource which adds message processors between the composite
source and the target listener |
class |
ServiceCompositeMessageSource
Extension of StartableCompositeMessageSource which adds message processors between the composite
source and the target listener |
Uses of FlowConstructAware in org.mule.service.processor |
---|
Classes in org.mule.service.processor that implement FlowConstructAware | |
---|---|
class |
ServiceAsyncRequestReplyRequestor
|
Uses of FlowConstructAware in org.mule.source |
---|
Classes in org.mule.source that implement FlowConstructAware | |
---|---|
class |
ClusterizableMessageSourceWrapper
Wraps a ClusterizableMessageSource in order to manage the lifecycle
of the wrapped instance differently depending if the node is primary or not
inside a cluster. |
class |
StartableCompositeMessageSource
Implementation of CompositeMessageSource that propagates both injection of FlowConstruct
and lifecycle to nested MessageSource s. |
Uses of FlowConstructAware in org.mule.tck.functional |
---|
Classes in org.mule.tck.functional that implement FlowConstructAware | |
---|---|
class |
AssertionMessageProcessor
|
class |
QuietExceptionStrategy
Restrict exceptions to debug log messages |
Uses of FlowConstructAware in org.mule.transport.http.components |
---|
Classes in org.mule.transport.http.components that implement FlowConstructAware | |
---|---|
class |
HttpResponseBuilder
|
class |
RestServiceWrapper
This service can used to proxy REST style services as local Mule Components. |
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |