|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use Stoppable | |
---|---|
org.mule | The Mule implementation of the Universal Message Objects(tm) API specification. |
org.mule.agent | Admin components and Agents used to control and Monitor Mule |
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.agent | |
org.mule.api.component | |
org.mule.api.endpoint | Endpoint interfaces. |
org.mule.api.lifecycle | Lifecycle interfaces for all Components. |
org.mule.api.model | Contains the interfaces for the Model and supporting objects such as the CompoenntResolver, EntryPointResolver, etc. |
org.mule.api.routing | Interfaces that define inbound and outbound routing API. |
org.mule.api.service | |
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.support | |
org.mule.construct | |
org.mule.endpoint | Implemtation of Mule endpoint uris. |
org.mule.endpoint.dynamic | |
org.mule.enricher | |
org.mule.example.loanbroker.routers | |
org.mule.example.notifications | |
org.mule.exception | |
org.mule.model | |
org.mule.model.seda | |
org.mule.module.atom | |
org.mule.module.bpm | |
org.mule.module.client.remoting | |
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.management.agent | Management agents including agents for Jdmk, MX4J, and Log4J |
org.mule.module.management.mbean | Jmx Management beans for mule components, the model and the Mule server. |
org.mule.module.scripting.component | Base classes for script based components such as BeanShell or Groovy. |
org.mule.module.sxc | |
org.mule.module.ws.construct | |
org.mule.module.xml.routing | |
org.mule.processor | |
org.mule.processor.chain | |
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.testmodels.services | |
org.mule.transport | Contains Abstract classes providing common functionality for all Mule providers. |
org.mule.transport.ajax | |
org.mule.transport.ajax.container | A AJAX transport allows Mule applications to send a receive events to the web browser. |
org.mule.transport.ajax.embedded | A AJAX transport allows Mule applications to send a receive events to the web browser. |
org.mule.transport.ejb | |
org.mule.transport.email | Provides pop3, smtp and imap connectivity for Mule. |
org.mule.transport.file | Provides file transport in the form of a directory listeners and file dispatchers. |
org.mule.transport.ftp | |
org.mule.transport.http | Provides http transport including proxy support. |
org.mule.transport.http.components | |
org.mule.transport.http.construct | |
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.activemq | Provides Jms connectivity with ActiveMQ-specific workarounds and improvements. |
org.mule.transport.jms.jndi | |
org.mule.transport.jms.mulemq | |
org.mule.transport.jms.weblogic | Provides Jms connectivity with Weblogic-specific workarounds and improvements. |
org.mule.transport.jms.websphere | Provides Jms connectivity with Websphere-specific workarounds and improvements. |
org.mule.transport.jnp | |
org.mule.transport.multicast | IP multicast connectivity for Mule. |
org.mule.transport.polling | |
org.mule.transport.quartz | |
org.mule.transport.quartz.jobs | |
org.mule.transport.rmi | |
org.mule.transport.servlet | |
org.mule.transport.servlet.jetty | |
org.mule.transport.sftp | |
org.mule.transport.soap.axis | Provides an Axis soap transport for Mule. |
org.mule.transport.soap.axis.wsdl | |
org.mule.transport.ssl | Provides tcp connectivity over Ssl for Mule. |
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.util.pool | |
org.mule.util.queue | A resource manager that allow access to transactional queues with optional persistence. |
Uses of Stoppable in org.mule |
---|
Classes in org.mule that implement Stoppable | |
---|---|
class |
AbstractAgent
Implements common methods for all Agents. |
class |
DefaultMuleContext
|
Uses of Stoppable in org.mule.agent |
---|
Classes in org.mule.agent that implement Stoppable | |
---|---|
class |
AbstractNotificationLoggerAgent
AbstractNotificationLoggerAgent Receives Mule server notifications
and logs them and can optionally route them to an endpoint. |
class |
EndpointNotificationLoggerAgent
EndpointAbstractEventLoggerAgent will forward server notifications
to a configurered endpoint uri. |
class |
Log4jNotificationLoggerAgent
AbstractNotificationLoggerAgent Receives Mule server notifications
and logs them and can optionally route them to an endpoint |
Uses of Stoppable in org.mule.api |
---|
Subinterfaces of Stoppable in org.mule.api | |
---|---|
interface |
MuleContext
|
Uses of Stoppable in org.mule.api.agent |
---|
Subinterfaces of Stoppable in org.mule.api.agent | |
---|---|
interface |
Agent
Agent is a server plugin that can be initialised, started and
destroyed along with the MuleContext itself. |
Uses of Stoppable in org.mule.api.component |
---|
Subinterfaces of Stoppable in org.mule.api.component | |
---|---|
interface |
LifecycleAdapter
LifecycleAdapter is a wrapper around a pojo service that adds
Lifecycle methods to the pojo. |
Uses of Stoppable in org.mule.api.endpoint |
---|
Subinterfaces of Stoppable in org.mule.api.endpoint | |
---|---|
interface |
InboundEndpoint
|
Uses of Stoppable in org.mule.api.lifecycle |
---|
Subinterfaces of Stoppable in org.mule.api.lifecycle | |
---|---|
interface |
Lifecycle
DefaultLifecyclePhase adds lifecycle methods start ,
stop and dispose . |
Constructors in org.mule.api.lifecycle with parameters of type Stoppable | |
---|---|
StopException(Message message,
Stoppable component)
|
|
StopException(Message message,
Throwable cause,
Stoppable component)
|
|
StopException(Throwable cause,
Stoppable component)
|
Uses of Stoppable in org.mule.api.model |
---|
Subinterfaces of Stoppable in org.mule.api.model | |
---|---|
interface |
Model
The Model encapsulates and manages the runtime behaviour of a
Mule Server instance. |
Uses of Stoppable in org.mule.api.routing |
---|
Subinterfaces of Stoppable in org.mule.api.routing | |
---|---|
interface |
OutboundRouter
OutboundRouter is used to control outbound routing behaviour for an
event. |
Uses of Stoppable in org.mule.api.service |
---|
Subinterfaces of Stoppable in org.mule.api.service | |
---|---|
interface |
Service
Service is the internal representation of a Mule Managed service. |
Uses of Stoppable in org.mule.api.transport |
---|
Subinterfaces of Stoppable in org.mule.api.transport | |
---|---|
interface |
Connectable
Interface for objects that should connect to a resource. |
interface |
Connector
Connector is the mechanism used to connect to external systems
and protocols in order to send and receive data. |
interface |
MessageDispatcher
Combine MessageDispatching with
various lifecycle methods for the actual instances doing message sending. |
interface |
MessageReceiver
MessageReceiver is used to receive data from an external system. |
interface |
MessageRequester
Combine MessageRequesting with
various lifecycle methods for the actual instances doing message sending. |
Uses of Stoppable in org.mule.component |
---|
Classes in org.mule.component that implement Stoppable | |
---|---|
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 |
DefaultComponentLifecycleAdapter
DefaultComponentLifecycleAdapter is a default implementation of
LifecycleAdapter for use with JavaComponent that expects component
instances to implement Mule lifecycle interfaces in order to receive lifecycle. |
class |
DefaultJavaComponent
Default implementation of JavaComponent . |
class |
NullLifecycleAdapter
NullLifecycleAdapter is a lifecycle adaptor implementation that
performs no Mule lifecycle propagation to Mule service component implementations. |
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 Stoppable in org.mule.component.simple |
---|
Classes in org.mule.component.simple that implement Stoppable | |
---|---|
class |
PassThroughComponent
PassThroughComponent will simply return the payload back as the
result. |
Uses of Stoppable in org.mule.config.dsl.routers |
---|
Classes in org.mule.config.dsl.routers that implement Stoppable | |
---|---|
class |
ContentBasedRouter
TODO |
Uses of Stoppable in org.mule.config.support |
---|
Classes in org.mule.config.support that implement Stoppable | |
---|---|
class |
InheritedModel
TODO |
Uses of Stoppable in org.mule.construct |
---|
Classes in org.mule.construct that implement Stoppable | |
---|---|
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 |
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 Stoppable in org.mule.endpoint |
---|
Classes in org.mule.endpoint that implement Stoppable | |
---|---|
class |
DefaultInboundEndpoint
|
class |
DynamicURIInboundEndpoint
Allow's EndpointURI to be set and changed dynamically by wrapping up an immutable endpoint instance. |
Uses of Stoppable in org.mule.endpoint.dynamic |
---|
Classes in org.mule.endpoint.dynamic that implement Stoppable | |
---|---|
class |
NullConnector
A placeholder for a connector that has not been created yet. |
Uses of Stoppable in org.mule.enricher |
---|
Classes in org.mule.enricher that implement Stoppable | |
---|---|
class |
MessageEnricher
The Message Enricher allows the current message to be augmented using data from a seperate
resource. |
Uses of Stoppable in org.mule.example.loanbroker.routers |
---|
Classes in org.mule.example.loanbroker.routers that implement Stoppable | |
---|---|
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 Stoppable in org.mule.example.notifications |
---|
Classes in org.mule.example.notifications that implement Stoppable | |
---|---|
class |
HeartbeatAgent
A simple agent that fire HeartbeatNotification events at a given frequency to
notify that the server is alive and well. |
Uses of Stoppable in org.mule.exception |
---|
Classes in org.mule.exception that implement Stoppable | |
---|---|
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 |
RollbackMessagingExceptionStrategy
|
class |
TemplateMessagingExceptionStrategy
|
Uses of Stoppable in org.mule.model |
---|
Classes in org.mule.model that implement Stoppable | |
---|---|
class |
AbstractModel
MuleModel is the default implementation of the Model. |
Uses of Stoppable in org.mule.model.seda |
---|
Classes in org.mule.model.seda that implement Stoppable | |
---|---|
class |
SedaModel
A mule service service model that uses SEDA principals to achieve high throughput by Queuing events for components and processing them concurrently. |
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. |
Uses of Stoppable in org.mule.module.atom |
---|
Classes in org.mule.module.atom that implement Stoppable | |
---|---|
class |
AbderaServiceComponent
This component receives requests from Mule and passes them off to Abdera. |
Uses of Stoppable in org.mule.module.bpm |
---|
Classes in org.mule.module.bpm that implement Stoppable | |
---|---|
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 Stoppable in org.mule.module.client.remoting |
---|
Classes in org.mule.module.client.remoting that implement Stoppable | |
---|---|
class |
RemoteDispatcherAgent
RemoteDispatcherAgent manages the server endpoint that receives Admin and
remote client requests |
Uses of Stoppable in org.mule.module.cxf |
---|
Classes in org.mule.module.cxf that implement Stoppable | |
---|---|
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. |
Uses of Stoppable in org.mule.module.cxf.component |
---|
Classes in org.mule.module.cxf.component that implement Stoppable | |
---|---|
class |
AbstractWebServiceWrapperComponent
|
class |
WebServiceWrapperComponent
Deprecated. |
Uses of Stoppable in org.mule.module.cxf.config |
---|
Classes in org.mule.module.cxf.config that implement Stoppable | |
---|---|
class |
FlowConfiguringMessageProcessor
Wraps a MessageProcessorBuilder and configures it lazily so it can
be injected with the FlowConstruct . |
Uses of Stoppable in org.mule.module.ibeans.config |
---|
Classes in org.mule.module.ibeans.config that implement Stoppable | |
---|---|
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 Stoppable in org.mule.module.ibeans.spi.support |
---|
Classes in org.mule.module.ibeans.spi.support that implement Stoppable | |
---|---|
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 Stoppable in org.mule.module.jca |
---|
Classes in org.mule.module.jca that implement Stoppable | |
---|---|
class |
JcaComponent
|
class |
JcaModel
Creates a model suitable for Jca execution |
class |
JcaService
JcaService Is the type of service used in Mule when embedded inside
an app server using JCA. |
Uses of Stoppable in org.mule.module.jersey |
---|
Classes in org.mule.module.jersey that implement Stoppable | |
---|---|
class |
JerseyResourcesComponent
Wraps a set of components which can get invoked by Jersey. |
Uses of Stoppable in org.mule.module.management.agent |
---|
Classes in org.mule.module.management.agent that implement Stoppable | |
---|---|
class |
DefaultJmxSupportAgent
|
class |
JdmkAgent
JdmkAgent configures an Jdmk Http Adaptor for Jmx management,
statistics and configuration viewing of a Mule instance. |
class |
JmxAgent
JmxAgent registers Mule Jmx management beans with an MBean server. |
class |
JmxServerNotificationAgent
An agent that propergates Mule Server notifications to Jmx. |
class |
Log4jAgent
Log4jAgent exposes the configuration of the Log4J instance running
in Mule for Jmx management |
class |
Mx4jAgent
Mx4jAgent configures an Mx4J Http Adaptor for Jmx management,
statistics and configuration viewing of a Mule instance. |
class |
RmiRegistryAgent
Binds to an existing RMI registry or creates a new one on a defined URI. |
class |
WrapperManagerAgent
This agent integrates Java Service Wrapper into Mule. |
class |
YourKitProfilerAgent
|
Uses of Stoppable in org.mule.module.management.mbean |
---|
Subinterfaces of Stoppable in org.mule.module.management.mbean | |
---|---|
interface |
ServiceServiceMBean
ServiceServiceMBean defines the management interface for a mule
managed service. |
Classes in org.mule.module.management.mbean that implement Stoppable | |
---|---|
class |
ServiceService
ServiceService exposes service information about a Mule Managed
service. |
Uses of Stoppable in org.mule.module.scripting.component |
---|
Classes in org.mule.module.scripting.component that implement Stoppable | |
---|---|
class |
ScriptComponent
A Script service backed by a JSR-223 compliant script engine such as Groovy, JavaScript, or Rhino. |
Uses of Stoppable in org.mule.module.sxc |
---|
Classes in org.mule.module.sxc that implement Stoppable | |
---|---|
class |
SxcFilteringOutboundRouter
FilteringRouter is a router that accepts events based on a filter
set. |
Uses of Stoppable in org.mule.module.ws.construct |
---|
Classes in org.mule.module.ws.construct that implement Stoppable | |
---|---|
class |
WSProxy
This class is implemented to act as a Proxy for a Web Service. |
Uses of Stoppable in org.mule.module.xml.routing |
---|
Classes in org.mule.module.xml.routing that implement Stoppable | |
---|---|
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 Stoppable in org.mule.processor |
---|
Classes in org.mule.processor that implement Stoppable | |
---|---|
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 |
AsyncInterceptingMessageProcessor
Processes MuleEvent 's asynchronously using a MuleWorkManager to
schedule asynchronous processing of the next MessageProcessor . |
class |
IdempotentRedeliveryPolicy
Implement a retry policy for Mule. |
class |
LaxAsyncInterceptingMessageProcessor
|
class |
LaxSedaStageInterceptingMessageProcessor
Processes MuleEvent 's asynchronously using a MuleWorkManager to schedule asynchronous
processing of the next MessageProcessor . |
class |
ResponseMessageProcessorAdapter
|
class |
SedaStageInterceptingMessageProcessor
Processes MuleEvent 's asynchronously using a MuleWorkManager to schedule asynchronous
processing of the next MessageProcessor . |
class |
TransactionalInterceptingMessageProcessor
Wraps the invocation of the next MessageProcessor with a transaction. |
Uses of Stoppable in org.mule.processor.chain |
---|
Classes in org.mule.processor.chain that implement Stoppable | |
---|---|
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 Stoppable in org.mule.routing |
---|
Classes in org.mule.routing that implement Stoppable | |
---|---|
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 |
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 Stoppable in org.mule.routing.correlation |
---|
Classes in org.mule.routing.correlation that implement Stoppable | |
---|---|
class |
EventCorrelator
|
Uses of Stoppable in org.mule.routing.outbound |
---|
Classes in org.mule.routing.outbound that implement Stoppable | |
---|---|
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 Stoppable in org.mule.routing.requestreply |
---|
Classes in org.mule.routing.requestreply that implement Stoppable | |
---|---|
class |
AbstractAsyncRequestReplyRequester
|
class |
SimpleAsyncRequestReplyRequester
|
Uses of Stoppable in org.mule.service |
---|
Classes in org.mule.service that implement Stoppable | |
---|---|
class |
AbstractService
A base implementation for all Services in Mule |
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 Stoppable in org.mule.service.processor |
---|
Classes in org.mule.service.processor that implement Stoppable | |
---|---|
class |
ServiceAsyncRequestReplyRequestor
|
Uses of Stoppable in org.mule.source |
---|
Classes in org.mule.source that implement Stoppable | |
---|---|
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 Stoppable in org.mule.tck.functional |
---|
Classes in org.mule.tck.functional that implement Stoppable | |
---|---|
class |
FunctionalTestComponent
FunctionalTestComponent is a service that can be used by
functional tests. |
class |
QuietExceptionStrategy
Restrict exceptions to debug log messages |
class |
TransactionalFunctionalTestComponent
This service is useful for unit tests involving transactionality because it will roll back the current transaction upon message arrival. |
Uses of Stoppable in org.mule.tck.testmodels.services |
---|
Classes in org.mule.tck.testmodels.services that implement Stoppable | |
---|---|
class |
TestServiceComponent
TestServiceComponent is a test WebServices service. |
Uses of Stoppable in org.mule.transport |
---|
Classes in org.mule.transport that implement Stoppable | |
---|---|
class |
AbstractConnector
AbstractConnector provides base functionality for all connectors
provided with Mule. |
class |
AbstractJndiConnector
This class acts as common baseclass for both Rmi & EjbConnector Resolves Jndi root for connector usage |
class |
AbstractMessageDispatcher
Abstract implementation of an outbound channel adaptors. |
class |
AbstractMessageReceiver
AbstractMessageReceiver provides common methods for all Message
Receivers provided with Mule. |
class |
AbstractMessageRequester
The Message Requester is used to explicitly request messages from a message channel or resource rather than subscribing to inbound events or polling for messages. |
class |
AbstractPollingMessageReceiver
AbstractPollingMessageReceiver implements a base class for polling
message receivers. |
class |
AbstractTransportMessageHandler<O>
Provide a default dispatch (client) support for handling threads lifecycle and validation. |
class |
TransactedPollingMessageReceiver
The TransactedPollingMessageReceiver is an abstract receiver that handles polling and transaction management. |
class |
UnsupportedMessageDispatcher
|
class |
UnsupportedMessageRequester
|
Uses of Stoppable in org.mule.transport.ajax |
---|
Classes in org.mule.transport.ajax that implement Stoppable | |
---|---|
class |
AjaxMessageDispatcher
Will dispatch Mule events to ajax clients available in Bayeux that are listening to this endpoint. |
class |
AjaxMessageReceiver
Registers a receiver service with Bayeux. |
Uses of Stoppable in org.mule.transport.ajax.container |
---|
Classes in org.mule.transport.ajax.container that implement Stoppable | |
---|---|
class |
AjaxServletConnector
A servlet connector that binds to the container and makes a configured Bayeux available to dispatchers and receivers. |
Uses of Stoppable in org.mule.transport.ajax.embedded |
---|
Classes in org.mule.transport.ajax.embedded that implement Stoppable | |
---|---|
class |
AjaxConnector
Creates an 'embedded' Ajax server using Jetty and allows Mule to receiver and send events to browsers. |
Uses of Stoppable in org.mule.transport.ejb |
---|
Classes in org.mule.transport.ejb that implement Stoppable | |
---|---|
class |
EjbConnector
Provides Connection configurstion for EJB endpoints |
class |
EjbMessageDispatcher
Invokes a method on an EJB object stored in Jndi. |
class |
EjbMessageReceiver
Will repeatedly call a method on an EJB object. |
Uses of Stoppable in org.mule.transport.email |
---|
Classes in org.mule.transport.email that implement Stoppable | |
---|---|
class |
AbstractMailConnector
Abstract superclass for mail connectors. |
class |
AbstractRetrieveMailConnector
Support for connecting to and receiving email from a mailbox (the exact protocol depends on the subclass). |
class |
AbstractTlsRetrieveMailConnector
Support for connecting to and receiving email from a secure mailbox (the exact protocol depends on the subclass). |
class |
GmailSmtpConnector
This class just sets some extra SMTP properties so it works with GMail. |
class |
ImapConnector
Receives messages from an IMAP mailbox |
class |
ImapsConnector
Creates a secure IMAP connection |
class |
Pop3Connector
Pop3Connector is used to connect and receive mail from a POP3
mailbox. |
class |
Pop3sConnector
Creates a secure connection to a POP3 mailbox |
class |
RetrieveMessageReceiver
Poll a mailbox for messages, remove the messages and route them as events into Mule. |
class |
RetrieveMessageRequester
This dispatcher can only be used to receive message (as opposed to listening for them). |
class |
SmtpConnector
SmtpConnector is used to connect to and send data to an SMTP mail
server |
class |
SmtpMessageDispatcher
SmtpMessageDispatcher will dispatch Mule events as Mime email
messages over an SMTP gateway. |
class |
SmtpsConnector
Creates a secure SMTP connection |
Uses of Stoppable in org.mule.transport.file |
---|
Classes in org.mule.transport.file that implement Stoppable | |
---|---|
class |
FileConnector
FileConnector is used for setting up listeners on a directory and
for writing files to a directory. |
class |
FileMessageDispatcher
FileMessageDispatcher is used to read/write files to the filesystem |
class |
FileMessageReceiver
FileMessageReceiver is a polling listener that reads files from a
directory. |
class |
FileMessageRequester
FileMessageRequester is used to read/write files to the filesystem |
Uses of Stoppable in org.mule.transport.ftp |
---|
Classes in org.mule.transport.ftp that implement Stoppable | |
---|---|
class |
FtpConnector
|
class |
FtpMessageDispatcher
|
class |
FtpMessageReceiver
|
class |
FtpMessageRequester
|
Uses of Stoppable in org.mule.transport.http |
---|
Classes in org.mule.transport.http that implement Stoppable | |
---|---|
class |
HttpClientMessageDispatcher
HttpClientMessageDispatcher dispatches Mule events over HTTP. |
class |
HttpClientMessageRequester
Rquests Mule events over HTTP. |
class |
HttpConnector
HttpConnector provides a way of receiving and sending http requests
and responses. |
class |
HttpMessageReceiver
HttpMessageReceiver is a simple http server that can be used to
listen for HTTP requests on a particular port. |
class |
HttpPollingConnector
The HttpPollingConnectors allows for inbound Http endpoints to be configured with an address which it shall use to poll for a result. |
class |
HttpsClientMessageDispatcher
|
class |
HttpsConnector
HttpsConnector provides Secure http connectivity on top of what is
already provided with the Mule HttpConnector . |
class |
HttpsMessageReceiver
|
class |
HttpsPollingConnector
HttpsPollingConnector provides Secure http connectivity on top of what is already provided with the
Mule HttpPollingConnector . |
class |
PollingHttpMessageReceiver
Will poll an http URL and use the response as the input for a service request. |
class |
PollingHttpsMessageReceiver
|
Uses of Stoppable in org.mule.transport.http.components |
---|
Classes in org.mule.transport.http.components that implement Stoppable | |
---|---|
class |
HttpResponseBuilder
|
class |
RestServiceWrapper
This service can used to proxy REST style services as local Mule Components. |
Uses of Stoppable in org.mule.transport.http.construct |
---|
Classes in org.mule.transport.http.construct that implement Stoppable | |
---|---|
class |
HttpProxy
A simple HTTP proxy that supports transformation and caching. |
Uses of Stoppable in org.mule.transport.jdbc |
---|
Classes in org.mule.transport.jdbc that implement Stoppable | |
---|---|
class |
JdbcConnector
|
class |
JdbcMessageDispatcher
The Jdbc Message dispatcher is responsible for executing SQL queries against a database. |
class |
JdbcMessageReceiver
Implements TransactedPollingMessageReceiver reading data from a database. |
class |
JdbcMessageRequester
|
Uses of Stoppable in org.mule.transport.jms |
---|
Classes in org.mule.transport.jms that implement Stoppable | |
---|---|
class |
JmsConnector
JmsConnector is a JMS 1.0.2b compliant connector that can be used
by a Mule endpoint. |
class |
JmsMessageDispatcher
JmsMessageDispatcher is responsible for dispatching messages to JMS
destinations. |
class |
JmsMessageReceiver
Deprecated. use MultiConsumerJmsMessageReceiver (set by default). |
class |
JmsMessageRequester
JmsMessageDispatcher is responsible for dispatching messages to JMS
destinations. |
class |
MultiConsumerJmsMessageReceiver
In Mule an endpoint corresponds to a single receiver. |
class |
SingleJmsMessageReceiver
Registers a single Jms MessageListener for an endpoint |
class |
TransactedSingleResourceJmsMessageReceiver
|
class |
XaTransactedJmsMessageReceiver
|
Uses of Stoppable in org.mule.transport.jms.activemq |
---|
Classes in org.mule.transport.jms.activemq that implement Stoppable | |
---|---|
class |
ActiveMQJmsConnector
ActiveMQ 4.x-specific JMS connector. |
class |
ActiveMQXAJmsConnector
|
Uses of Stoppable in org.mule.transport.jms.jndi |
---|
Subinterfaces of Stoppable in org.mule.transport.jms.jndi | |
---|---|
interface |
JndiNameResolver
Defines a strategy for lookup objects by name using JNDI. |
Classes in org.mule.transport.jms.jndi that implement Stoppable | |
---|---|
class |
AbstractJndiNameResolver
|
class |
CachedJndiNameResolver
Defines a JndiNameResolver that uses a cache in order to store
the already resolved names. |
class |
SimpleJndiNameResolver
Defines a simple JndiNameResolver that maintains a Context
instance opened all the time and always relies on the context to do the look
ups. |
Uses of Stoppable in org.mule.transport.jms.mulemq |
---|
Classes in org.mule.transport.jms.mulemq that implement Stoppable | |
---|---|
class |
MuleMQJmsConnector
|
class |
MuleMQXAJmsConnector
|
Uses of Stoppable in org.mule.transport.jms.weblogic |
---|
Classes in org.mule.transport.jms.weblogic that implement Stoppable | |
---|---|
class |
WeblogicJmsConnector
Weblogic-specific JMS connector. |
Uses of Stoppable in org.mule.transport.jms.websphere |
---|
Classes in org.mule.transport.jms.websphere that implement Stoppable | |
---|---|
class |
WebsphereJmsConnector
Websphere-specific JMS connector. |
class |
WebsphereTransactedJmsMessageReceiver
|
Uses of Stoppable in org.mule.transport.jnp |
---|
Classes in org.mule.transport.jnp that implement Stoppable | |
---|---|
class |
JnpConnector
JnpConnector uses the Java Naming protocol to bind to remote
objects |
Uses of Stoppable in org.mule.transport.multicast |
---|
Classes in org.mule.transport.multicast that implement Stoppable | |
---|---|
class |
MulticastConnector
MulticastConnector can dispatch mule events using ip multicasting |
class |
MulticastMessageReceiver
|
Uses of Stoppable in org.mule.transport.polling |
---|
Classes in org.mule.transport.polling that implement Stoppable | |
---|---|
class |
MessageProcessorPollingConnector
|
class |
MessageProcessorPollingMessageReceiver
|
Uses of Stoppable in org.mule.transport.quartz |
---|
Classes in org.mule.transport.quartz that implement Stoppable | |
---|---|
class |
QuartzConnector
Creates a connection to a Quartz scheduler. |
class |
QuartzMessageDispatcher
Can schedule a Job with the Quartz scheduler. |
class |
QuartzMessageReceiver
Listens for Quartz sheduled events using the Receiver Job and fires events to the service associated with this receiver. |
Uses of Stoppable in org.mule.transport.quartz.jobs |
---|
Classes in org.mule.transport.quartz.jobs that implement Stoppable | |
---|---|
class |
PollEndpointJob
|
Uses of Stoppable in org.mule.transport.rmi |
---|
Classes in org.mule.transport.rmi that implement Stoppable | |
---|---|
class |
RmiCallbackMessageReceiver
TODO |
class |
RmiConnector
RmiConnector can bind or send to a given RMI port on a given host. |
class |
RmiMessageDispatcher
RmiMessageDispatcher will send transformed mule events over
RMI-JRMP. |
class |
RmiMessageReceiver
Will repeatedly call a method on a Remote object. |
Uses of Stoppable in org.mule.transport.servlet |
---|
Classes in org.mule.transport.servlet that implement Stoppable | |
---|---|
class |
ServletConnector
ServletConnector is a channel adapter between Mule and a servlet
engine. |
class |
ServletMessageReceiver
ServletMessageReceiver is a receiver that is invoked from a Servlet
when an event is received. |
Uses of Stoppable in org.mule.transport.servlet.jetty |
---|
Classes in org.mule.transport.servlet.jetty that implement Stoppable | |
---|---|
class |
JettyHttpConnector
The JettyConnector can be using to embed a Jetty server to receive requests on an
http inound endpoint. |
class |
JettyHttpMessageReceiver
JettyHttpMessageReceiver is a simple http server that can be used to
listen for http requests on a particular port |
class |
JettyHttpsConnector
The JettyHttpsConnector can be using to embed a Jetty server to receive requests on an http inbound endpoint. |
class |
JettyWebappServerAgent
A 'proxy' agent that displays info about any webapps deployed together with their entry-point url. |
Uses of Stoppable in org.mule.transport.sftp |
---|
Classes in org.mule.transport.sftp that implement Stoppable | |
---|---|
class |
SftpConnector
SftpConnector sends and receives file messages over sftp using jsch
library Improves on SFTP with VFS Connector in the following ways: 1. |
class |
SftpMessageDispatcher
SftpMessageDispatcher dispatches files via sftp to a remote sftp
service. |
class |
SftpMessageReceiver
SftpMessageReceiver polls and receives files from an sftp service
using jsch. |
class |
SftpMessageRequester
SftpMessageRequester polls files on request (e.g. |
Uses of Stoppable in org.mule.transport.soap.axis |
---|
Classes in org.mule.transport.soap.axis that implement Stoppable | |
---|---|
class |
AxisConnector
AxisConnector is used to maintain one or more Services for Axis
server instance. |
class |
AxisMessageDispatcher
AxisMessageDispatcher is used to make soap requests via the Axis
soap client. |
class |
AxisMessageReceiver
AxisMessageReceiver is used to register a component as a service
with a Axis server. |
class |
AxisMessageRequester
AxisMessageDispatcher is used to make soap requests via the Axis
soap client. |
Uses of Stoppable in org.mule.transport.soap.axis.wsdl |
---|
Classes in org.mule.transport.soap.axis.wsdl that implement Stoppable | |
---|---|
class |
AxisWsdlConnector
TODO document |
class |
AxisWsdlMessageDispatcher
Creates and Axis client services from WSDL and invokes it. |
Uses of Stoppable in org.mule.transport.ssl |
---|
Classes in org.mule.transport.ssl that implement Stoppable | |
---|---|
class |
SslConnector
SslConnector provides a connector for SSL connections. |
class |
SslMessageReceiver
|
class |
TlsConnector
TlsConnector Provides TLS connections |
Uses of Stoppable in org.mule.transport.stdio |
---|
Classes in org.mule.transport.stdio that implement Stoppable | |
---|---|
class |
PromptStdioConnector
PromptStdioConnector connects to the System streams in and out by
default and add some basic fuctionality for writing out prompt messages. |
class |
StdioConnector
StdioConnector can send and receive Mule events over IO streams. |
class |
StdioMessageDispatcher
StdioMessageDispatcher is a simple stream dispatcher that obtains
a stream from the Stream Connector to write to. |
class |
StdioMessageReceiver
StdioMessageReceiver is a listener for events from Mule components
which then simply passes the events on to the target components. |
Uses of Stoppable in org.mule.transport.tcp |
---|
Classes in org.mule.transport.tcp that implement Stoppable | |
---|---|
class |
ExceptionReturnTcpMessageReceiver
Extends TcpMessageReceiver providing managing of protocol error conditions. |
class |
LocalSocketTcpMessageDispatcher
LocalSocketTcpMessageDispatcher will send transformed Mule events
over TCP. |
class |
PollingTcpConnector
PollingTcpMessageReceiver acts as a polling TCP connector. |
class |
PollingTcpMessageReceiver
PollingTcpMessageReceiver acts like a TCP client polling for new
messages. |
class |
TcpConnector
TcpConnector can bind or sent to a given TCP port on a given host. |
class |
TcpMessageDispatcher
Send transformed Mule events over TCP. |
class |
TcpMessageReceiver
TcpMessageReceiver acts like a TCP server to receive socket
requests. |
class |
TcpMessageRequester
Request transformed Mule events from TCP. |
Uses of Stoppable in org.mule.transport.udp |
---|
Classes in org.mule.transport.udp that implement Stoppable | |
---|---|
class |
UdpConnector
UdpConnector can send and receive Mule events as Datagram packets. |
class |
UdpMessageDispatcher
UdpMessageDispatcher is responsible for dispatching MuleEvents as
UDP packets on the network |
class |
UdpMessageReceiver
UdpMessageReceiver receives UDP message packets. |
class |
UdpMessageRequester
Responsible for requesting MuleEvents as UDP packets on the network |
Uses of Stoppable in org.mule.transport.vm |
---|
Classes in org.mule.transport.vm that implement Stoppable | |
---|---|
class |
VMConnector
VMConnector A simple endpoint wrapper to allow a Mule service to
be accessed from an endpoint |
class |
VMMessageDispatcher
VMMessageDispatcher is used for providing in memory interaction between components. |
class |
VMMessageReceiver
VMMessageReceiver is a listener for events from a Mule service which then simply passes
the events on to the target service. |
class |
VMMessageRequester
VMMessageDispatcher is used for providing in memory interaction
between components. |
Uses of Stoppable in org.mule.transport.xmpp |
---|
Classes in org.mule.transport.xmpp that implement Stoppable | |
---|---|
class |
XmppConnector
XmppConnector represents a connection to a Jabber server. |
class |
XmppMessageDispatcher
Allows Mule events to be sent over Xmpp |
class |
XmppMessageReceiver
XmppMessageReceiver is responsible for receiving Mule events over XMPP. |
class |
XmppMessageRequester
Allows Mule messages to be received over XMPP |
class |
XmppPollingMessageReceiver
|
Uses of Stoppable in org.mule.util.pool |
---|
Subinterfaces of Stoppable in org.mule.util.pool | |
---|---|
interface |
LifecyleEnabledObjectPool
An ObjectPool that allows Start and Stop life-cycle to be propagated pooled object. |
Classes in org.mule.util.pool that implement Stoppable | |
---|---|
class |
DefaultLifecycleEnabledObjectPool
A LifecyleEnabledObjectPool implementation for pooling LifecycleAdapter
instances for implementations of JavaComponent that require
LifecycleAdapter pooling such as PooledJavaComponent . |
Uses of Stoppable in org.mule.util.queue |
---|
Subinterfaces of Stoppable in org.mule.util.queue | |
---|---|
interface |
QueueManager
A Queue manager is responsible for managing one or more Queue resources and providing common support for transactions and persistence. |
Classes in org.mule.util.queue that implement Stoppable | |
---|---|
class |
TransactionalQueueManager
The Transactional Queue Manager is responsible for creating and Managing transactional Queues. |
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |