|
||||||||||
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.cache |
---|
Classes in org.mule.cache that implement FlowConstructAware | |
---|---|
class |
CachingMessageProcessor
Processes a MuleEvent using a CachingStrategy . |
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
|
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 |
AbstractExceptionStrategy
This is the base class for exception strategies which contains several helper methods. |
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 |
DefaultMessagingExceptionStrategy
This is the default exception handler for flows and services. |
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. |
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
This exception strategy forces the exception thrown from a web service invocation to be passed as-is, not wrapped in a Mule exception object. |
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
|
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 |
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. |
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 |
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 |
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 |
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 |
RestServiceWrapper
This service can used to proxy REST style services as local Mule Components. |
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |