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

## Uses of Interface
org.mule.api.lifecycle.Stoppable

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.notifications |
org.mule.exception |
org.mule.model |
org.mule.model.seda |
org.mule.module.atom |
org.mule.module.atom.endpoint |
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.rss.endpoint |
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.outbound | Outbound router implementation as described in the Enterprise Integration Patterns book.
org.mule.routing.requestreply |
org.mule.service |
org.mule.source |
org.mule.tck.functional | Helper classes and interfaces used by Mule fnctional tests.
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.ibean |
org.mule.transport.jdbc | Provides jdbc transport.
org.mule.transport.jms | Provides Jms transport connectivity with support for all Jms features.
org.mule.transport.jms.activemq | Provides Jms connectivity with ActiveMQ-specific workarounds and improvements.
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.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`
`class` | `RouteableExceptionStrategy` `RouteableExceptionStrategy` allows transforming and routing exceptions to outbound routers.

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 specific's: `EntryPointResolverSet`, `org.mule.api.routing.BindingCollection` 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` | `AbstractFlowConstruct` Abstract implementation of `FlowConstruct` that: Is constructed with unique name and `MuleContext`.
`class` | `Bridge` A simple bridge between a single inbound endpoint and a single outbound endpoint.
`class` | `SimpleFlowConstruct` Simple implementation of `AbstractFlowConstruct` that allows a list of `MessageProcessor`s that will be used to process messages to be configured.
`class` | `SimpleService` In-out SOA-style simple service, with no outbound router.
`class` | `Validator`

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`

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` `AbstractExceptionListener` is a base implementation that custom Exception Listeners can override.
`class` | `AbstractMessagingExceptionStrategy` `DefaultExceptionStrategy` provides a default exception handling strategy.
`class` | `DefaultServiceExceptionStrategy` `DefaultServiceExceptionStrategy` is the default exception handler for components.
`class` | `DefaultSystemExceptionStrategy` Log exception, fire a notification, and clean up transaction if any.

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.atom.endpoint

Classes in org.mule.module.atom.endpoint that implement Stoppable
`class` | `AtomInboundEndpoint` An ATOM endpoint is used for polling an ATOM feed and processing the feed entries

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.

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` This exception strategy forces the exception thrown from a web service invocation to be passed as-is, not wrapped in a Mule exception object.
`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`

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.rss.endpoint

Classes in org.mule.module.rss.endpoint that implement Stoppable
`class` | `RssInboundEndpoint` TODO

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/shoutdown events to them
`class` | `AsyncInterceptingMessageProcessor` Processes `MuleEvent`'s asynchronously using a `MuleWorkManager` to schedule asynchronous processing of the next `MessageProcessor`.
`class` | `OptionalAsyncInterceptingMessageProcessor` Implementation of `AsyncInterceptingMessageProcessor` which continues processing in the same thread if the inbound endpoint has an exchange pattern that has a response or if a transaction is present.
`class` | `ResponseMessageProcessorAdapter`
`class` | `SedaStageInterceptingMessageProcessor` Processes `MuleEvent`'s asynchronously using a `MuleWorkManager` to schedule asynchronous processing of the next `MessageProcessor`.

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.

Uses of Stoppable in org.mule.routing

Classes in org.mule.routing that implement Stoppable
`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` | `MessageFilter` Implementation of `InterceptingMessageProcessor` that filters message flow using a `Filter`.
`class` | `MessageProcessorFilterPair` A holder for a pair of MessageProcessor and Filter.
`class` | `RoundRobin` RoundRobin divides the messages it receives among its target routes in round-robin fashion.
`class` | `WireTap` The `WireTap` MessageProcessor allows inspection of messages in a flow.

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` | `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 registed with the router.
`class` | `OutboundPassThroughRouter` `OutboundPassThroughRouter` allows outbound routing over a single endpoint without any filtering.
`class` | `StaticRecipientList` `StaticRecipientList` is used to dispatch a single event to multiple recipients over the same transport.
`class` | `TransformerRouter` Deprecated.

Uses of Stoppable in org.mule.routing.requestreply

Classes in org.mule.routing.requestreply that implement Stoppable
`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.source

Classes in org.mule.source that implement Stoppable
`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` | `QuietExceptionStrategy` Restrict exceptions to debug log messages

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.

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

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

Uses of Stoppable in org.mule.transport.ibean

Classes in org.mule.transport.ibean that implement Stoppable
`class` | `IBeansConnector` `IBeansConnector` TODO document
`class` | `IBeansMessageDispatcher` `IBeansMessageDispatcher` TODO document
`class` | `IBeansMessageReceiver` `IBeansMessageReceiver` TODO document

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.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.

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 manageing one or more Queue resources and providing common support fot 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.

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

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