|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use Startable | |
---|---|
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.context | Mule Context APIs, including the MuleContext, agent and server event interfaces |
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.example.notifications | |
org.mule.lifecycle.processor | |
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.builder | |
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.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.bpm | |
org.mule.transport.bpm.jbpm | |
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.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. |
org.mule.work | A javax.resource.spi.WorkManager implementation. |
Uses of Startable in org.mule |
---|
Classes in org.mule that implement Startable | |
---|---|
class |
AbstractAgent
Implements common methods for all Agents. |
class |
DefaultMuleContext
|
Uses of Startable in org.mule.agent |
---|
Classes in org.mule.agent that implement Startable | |
---|---|
class |
AbstractNotificationLoggerAgent
AbstractNotificationLoggerAgent Receives Mule server notifications
and logs them and can optionally route them to an endpoint. |
class |
ConfigScannerAgent
EXPERIMENTAL!!! This agent scans a defined directory for dropped configuration files. |
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 Startable in org.mule.api |
---|
Subinterfaces of Startable in org.mule.api | |
---|---|
interface |
MuleContext
|
Uses of Startable in org.mule.api.agent |
---|
Subinterfaces of Startable 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 Startable in org.mule.api.component |
---|
Subinterfaces of Startable in org.mule.api.component | |
---|---|
interface |
LifecycleAdapter
LifecycleAdapter is a wrapper around a pojo service that adds
Lifecycle methods to the pojo. |
Uses of Startable in org.mule.api.context |
---|
Subinterfaces of Startable in org.mule.api.context | |
---|---|
interface |
WorkManager
WorkManager extends the standard JCA WorkManager with lifecycle
methods and util.concurrent bridging. |
Uses of Startable in org.mule.api.endpoint |
---|
Subinterfaces of Startable in org.mule.api.endpoint | |
---|---|
interface |
InboundEndpoint
|
Uses of Startable in org.mule.api.lifecycle |
---|
Subinterfaces of Startable 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 Startable | |
---|---|
StartException(Message message,
Startable component)
|
|
StartException(Message message,
java.lang.Throwable cause,
Startable component)
|
|
StartException(java.lang.Throwable cause,
Startable component)
|
Uses of Startable in org.mule.api.model |
---|
Subinterfaces of Startable in org.mule.api.model | |
---|---|
interface |
Model
The Model encapsulates and manages the runtime behaviour of a
Mule Server instance. |
Uses of Startable in org.mule.api.routing |
---|
Subinterfaces of Startable in org.mule.api.routing | |
---|---|
interface |
OutboundRouter
OutboundRouter is used to control outbound routing behaviour for an
event. |
Uses of Startable in org.mule.api.service |
---|
Subinterfaces of Startable in org.mule.api.service | |
---|---|
interface |
Service
Service is the internal representation of a Mule Managed service. |
Uses of Startable in org.mule.api.transport |
---|
Subinterfaces of Startable 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 Startable in org.mule.component |
---|
Classes in org.mule.component that implement Startable | |
---|---|
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 Startable in org.mule.component.simple |
---|
Classes in org.mule.component.simple that implement Startable | |
---|---|
class |
PassThroughComponent
PassThroughComponent will simply return the payload back as the
result. |
Uses of Startable in org.mule.config.dsl.routers |
---|
Classes in org.mule.config.dsl.routers that implement Startable | |
---|---|
class |
ContentBasedRouter
TODO |
Uses of Startable in org.mule.config.support |
---|
Classes in org.mule.config.support that implement Startable | |
---|---|
class |
InheritedModel
TODO |
Uses of Startable in org.mule.construct |
---|
Classes in org.mule.construct that implement Startable | |
---|---|
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 Startable in org.mule.endpoint |
---|
Classes in org.mule.endpoint that implement Startable | |
---|---|
class |
DefaultInboundEndpoint
|
class |
DynamicURIInboundEndpoint
Allow's EndpointURI to be set and changed dynamically by wrapping up an immutable endpoint instance. |
Uses of Startable in org.mule.endpoint.dynamic |
---|
Classes in org.mule.endpoint.dynamic that implement Startable | |
---|---|
class |
NullConnector
A placeholder for a connector that has not been created yet. |
Uses of Startable in org.mule.example.notifications |
---|
Classes in org.mule.example.notifications that implement Startable | |
---|---|
class |
HeartbeatAgent
A simple agent that fire HeartbeatNotification events at a given frequency to
notify that the server is alive and well. |
Uses of Startable in org.mule.lifecycle.processor |
---|
Fields in org.mule.lifecycle.processor declared as Startable | |
---|---|
protected Startable |
ProcessIfStartedMessageProcessor.startable
|
Methods in org.mule.lifecycle.processor with parameters of type Startable | |
---|---|
protected java.lang.String |
ProcessIfStartedMessageProcessor.getStartableName(Startable startableObject)
|
Constructors in org.mule.lifecycle.processor with parameters of type Startable | |
---|---|
ProcessIfStartedMessageProcessor(Startable startable,
LifecycleState lifecycleState)
|
|
ProcessIfStartedWaitIfPausedMessageProcessor(Startable startable,
LifecycleState lifecycleState)
|
|
ProcessIfStartedWaitIfSyncPausedMessageProcessor(Startable startable,
LifecycleState lifecycleState)
|
Uses of Startable in org.mule.model |
---|
Classes in org.mule.model that implement Startable | |
---|---|
class |
AbstractModel
MuleModel is the default implementation of the Model. |
Uses of Startable in org.mule.model.seda |
---|
Classes in org.mule.model.seda that implement Startable | |
---|---|
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 Startable in org.mule.module.atom |
---|
Classes in org.mule.module.atom that implement Startable | |
---|---|
class |
AbderaServiceComponent
This component receives requests from Mule and passes them off to Abdera. |
Uses of Startable in org.mule.module.atom.endpoint |
---|
Classes in org.mule.module.atom.endpoint that implement Startable | |
---|---|
class |
AtomInboundEndpoint
An ATOM endpoint is used for polling an ATOM feed and processing the feed entries |
Uses of Startable in org.mule.module.bpm |
---|
Classes in org.mule.module.bpm that implement Startable | |
---|---|
class |
ProcessComponent
A service backed by the execution of a business process such as jBPM. |
Uses of Startable in org.mule.module.client.remoting |
---|
Classes in org.mule.module.client.remoting that implement Startable | |
---|---|
class |
RemoteDispatcherAgent
RemoteDispatcherAgent manages the server endpoint that receives Admin and
remote client requests |
Uses of Startable in org.mule.module.cxf |
---|
Classes in org.mule.module.cxf that implement Startable | |
---|---|
class |
CxfInboundMessageProcessor
The CxfInboundMessageProcessor performs inbound CXF processing, sending an event through the CXF service, then on to the next MessageProcessor. |
Uses of Startable in org.mule.module.cxf.component |
---|
Classes in org.mule.module.cxf.component that implement Startable | |
---|---|
class |
AbstractWebServiceWrapperComponent
|
class |
WebServiceWrapperComponent
|
Uses of Startable in org.mule.module.cxf.config |
---|
Classes in org.mule.module.cxf.config that implement Startable | |
---|---|
class |
FlowConfiguringMessageProcessor
Wraps a MessageProcessorBuilder and configures it lazily so it can
be injected with the FlowConstruct . |
Uses of Startable in org.mule.module.ibeans.config |
---|
Classes in org.mule.module.ibeans.config that implement Startable | |
---|---|
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 Startable in org.mule.module.ibeans.spi.support |
---|
Classes in org.mule.module.ibeans.spi.support that implement Startable | |
---|---|
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 Startable in org.mule.module.jca |
---|
Classes in org.mule.module.jca that implement Startable | |
---|---|
class |
DelegateWorkManager
DelegateWorkManager is a wrapper around a WorkManager provided by a
JCA container. |
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 Startable in org.mule.module.jersey |
---|
Classes in org.mule.module.jersey that implement Startable | |
---|---|
class |
JerseyResourcesComponent
Wraps a set of components which can get invoked by Jersey. |
Uses of Startable in org.mule.module.management.agent |
---|
Classes in org.mule.module.management.agent that implement Startable | |
---|---|
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 Startable in org.mule.module.management.mbean |
---|
Subinterfaces of Startable 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 Startable | |
---|---|
class |
ServiceService
ServiceService exposes service information about a Mule Managed
service. |
Uses of Startable in org.mule.module.rss.endpoint |
---|
Classes in org.mule.module.rss.endpoint that implement Startable | |
---|---|
class |
RssInboundEndpoint
TODO |
Uses of Startable in org.mule.module.scripting.component |
---|
Classes in org.mule.module.scripting.component that implement Startable | |
---|---|
class |
ScriptComponent
A Script service backed by a JSR-223 compliant script engine such as Groovy, JavaScript, or Rhino. |
Uses of Startable in org.mule.module.sxc |
---|
Classes in org.mule.module.sxc that implement Startable | |
---|---|
class |
SxcFilteringOutboundRouter
FilteringRouter is a router that accepts events based on a filter
set. |
Uses of Startable in org.mule.module.ws.construct |
---|
Classes in org.mule.module.ws.construct that implement Startable | |
---|---|
class |
WSProxy
This class is implemented to act as a Proxy for a Web Service. |
Uses of Startable in org.mule.module.xml.routing |
---|
Classes in org.mule.module.xml.routing that implement Startable | |
---|---|
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 Startable in org.mule.processor |
---|
Classes in org.mule.processor that implement Startable | |
---|---|
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 |
SedaStageInterceptingMessageProcessor
Processes MuleEvent 's asynchronously using a MuleWorkManager to
schedule asynchronous processing of the next MessageProcessor . |
Uses of Startable in org.mule.processor.builder |
---|
Classes in org.mule.processor.builder that implement Startable | |
---|---|
class |
InterceptingChainCompositeMessageProcessor
Builder needs to return a composite rather than the first MessageProcessor in the chain. |
Uses of Startable in org.mule.routing |
---|
Classes in org.mule.routing that implement Startable | |
---|---|
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 |
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. |
Uses of Startable in org.mule.routing.outbound |
---|
Classes in org.mule.routing.outbound that implement Startable | |
---|---|
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 Startable in org.mule.routing.requestreply |
---|
Classes in org.mule.routing.requestreply that implement Startable | |
---|---|
class |
SimpleAsyncRequestReplyRequester
|
Uses of Startable in org.mule.service |
---|
Classes in org.mule.service that implement Startable | |
---|---|
class |
AbstractService
A base implementation for all Services in Mule |
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 Startable in org.mule.source |
---|
Classes in org.mule.source that implement Startable | |
---|---|
class |
StartableCompositeMessageSource
Implementation of CompositeMessageSource that propagates both injection of FlowConstruct
and lifecycle to nested MessageSource s. |
Uses of Startable in org.mule.transport |
---|
Classes in org.mule.transport that implement Startable | |
---|---|
class |
AbstractConnectable<O>
Provide a default dispatch (client) support for handling threads lifecycle and validation. |
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 |
TransactedPollingMessageReceiver
The TransactedPollingMessageReceiver is an abstract receiver that handles polling and transaction management. |
class |
UnsupportedMessageDispatcher
|
class |
UnsupportedMessageRequester
|
Uses of Startable in org.mule.transport.ajax |
---|
Classes in org.mule.transport.ajax that implement Startable | |
---|---|
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 Startable in org.mule.transport.ajax.container |
---|
Classes in org.mule.transport.ajax.container that implement Startable | |
---|---|
class |
AjaxServletConnector
A servlet connector that binds to the container and makes a configured Bayeux available to dispatchers and receivers. |
Uses of Startable in org.mule.transport.ajax.embedded |
---|
Classes in org.mule.transport.ajax.embedded that implement Startable | |
---|---|
class |
AjaxConnector
Creates an 'embedded' Ajax server using Jetty and allows Mule to receiver and send events to browsers. |
Uses of Startable in org.mule.transport.bpm |
---|
Classes in org.mule.transport.bpm that implement Startable | |
---|---|
class |
ProcessConnector
Deprecated. It is recommended to configure BPM as a component rather than a transport for 3.x |
class |
ProcessMessageDispatcher
Deprecated. It is recommended to configure BPM as a component rather than a transport for 3.x |
class |
ProcessMessageReceiver
Deprecated. It is recommended to configure BPM as a component rather than a transport for 3.x |
Uses of Startable in org.mule.transport.bpm.jbpm |
---|
Classes in org.mule.transport.bpm.jbpm that implement Startable | |
---|---|
class |
JBpmConnector
Deprecated. It is recommended to configure BPM as a component rather than a transport for 3.x |
Uses of Startable in org.mule.transport.ejb |
---|
Classes in org.mule.transport.ejb that implement Startable | |
---|---|
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 Startable in org.mule.transport.email |
---|
Classes in org.mule.transport.email that implement Startable | |
---|---|
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 Startable in org.mule.transport.file |
---|
Classes in org.mule.transport.file that implement Startable | |
---|---|
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 Startable in org.mule.transport.ftp |
---|
Classes in org.mule.transport.ftp that implement Startable | |
---|---|
class |
FtpConnector
|
class |
FtpMessageDispatcher
|
class |
FtpMessageReceiver
|
class |
FtpMessageRequester
|
Uses of Startable in org.mule.transport.http |
---|
Classes in org.mule.transport.http that implement Startable | |
---|---|
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 Startable in org.mule.transport.http.components |
---|
Classes in org.mule.transport.http.components that implement Startable | |
---|---|
class |
RestServiceWrapper
This service can used to proxy REST style services as local Mule Components. |
Uses of Startable in org.mule.transport.ibean |
---|
Classes in org.mule.transport.ibean that implement Startable | |
---|---|
class |
IBeansConnector
IBeansConnector TODO document |
class |
IBeansMessageDispatcher
IBeansMessageDispatcher TODO document |
class |
IBeansMessageReceiver
IBeansMessageReceiver TODO document |
Uses of Startable in org.mule.transport.jdbc |
---|
Classes in org.mule.transport.jdbc that implement Startable | |
---|---|
class |
JdbcConnector
|
class |
JdbcMessageDispatcher
The Jdbc Message dispatcher is responsible for executing SQL queries against a database. |
class |
JdbcMessageReceiver
TODO |
class |
JdbcMessageRequester
|
Uses of Startable in org.mule.transport.jms |
---|
Classes in org.mule.transport.jms that implement Startable | |
---|---|
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 Startable in org.mule.transport.jms.activemq |
---|
Classes in org.mule.transport.jms.activemq that implement Startable | |
---|---|
class |
ActiveMQJmsConnector
ActiveMQ 4.x-specific JMS connector. |
class |
ActiveMQXAJmsConnector
|
Uses of Startable in org.mule.transport.jms.mulemq |
---|
Classes in org.mule.transport.jms.mulemq that implement Startable | |
---|---|
class |
MuleMQJmsConnector
|
class |
MuleMQXAJmsConnector
|
Uses of Startable in org.mule.transport.jms.weblogic |
---|
Classes in org.mule.transport.jms.weblogic that implement Startable | |
---|---|
class |
WeblogicJmsConnector
Weblogic-specific JMS connector. |
Uses of Startable in org.mule.transport.jms.websphere |
---|
Classes in org.mule.transport.jms.websphere that implement Startable | |
---|---|
class |
WebsphereJmsConnector
Websphere-specific JMS connector. |
class |
WebsphereTransactedJmsMessageReceiver
|
Uses of Startable in org.mule.transport.jnp |
---|
Classes in org.mule.transport.jnp that implement Startable | |
---|---|
class |
JnpConnector
JnpConnector uses the Java Naming protocol to bind to remote
objects |
Uses of Startable in org.mule.transport.multicast |
---|
Classes in org.mule.transport.multicast that implement Startable | |
---|---|
class |
MulticastConnector
MulticastConnector can dispatch mule events using ip multicasting |
class |
MulticastMessageReceiver
|
Uses of Startable in org.mule.transport.quartz |
---|
Classes in org.mule.transport.quartz that implement Startable | |
---|---|
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 Startable in org.mule.transport.quartz.jobs |
---|
Classes in org.mule.transport.quartz.jobs that implement Startable | |
---|---|
class |
PollEndpointJob
|
Uses of Startable in org.mule.transport.rmi |
---|
Classes in org.mule.transport.rmi that implement Startable | |
---|---|
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 Startable in org.mule.transport.servlet |
---|
Classes in org.mule.transport.servlet that implement Startable | |
---|---|
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 Startable in org.mule.transport.servlet.jetty |
---|
Classes in org.mule.transport.servlet.jetty that implement Startable | |
---|---|
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 Startable in org.mule.transport.soap.axis |
---|
Classes in org.mule.transport.soap.axis that implement Startable | |
---|---|
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 Startable in org.mule.transport.soap.axis.wsdl |
---|
Classes in org.mule.transport.soap.axis.wsdl that implement Startable | |
---|---|
class |
AxisWsdlConnector
TODO document |
class |
AxisWsdlMessageDispatcher
Creates and Axis client services from WSDL and invokes it. |
Uses of Startable in org.mule.transport.ssl |
---|
Classes in org.mule.transport.ssl that implement Startable | |
---|---|
class |
SslConnector
SslConnector provides a connector for SSL connections. |
class |
SslMessageReceiver
|
class |
TlsConnector
TlsConnector Provides TLS connections |
Uses of Startable in org.mule.transport.stdio |
---|
Classes in org.mule.transport.stdio that implement Startable | |
---|---|
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 Startable in org.mule.transport.tcp |
---|
Classes in org.mule.transport.tcp that implement Startable | |
---|---|
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 Startable in org.mule.transport.udp |
---|
Classes in org.mule.transport.udp that implement Startable | |
---|---|
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 Startable in org.mule.transport.vm |
---|
Classes in org.mule.transport.vm that implement Startable | |
---|---|
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 Startable in org.mule.transport.xmpp |
---|
Classes in org.mule.transport.xmpp that implement Startable | |
---|---|
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 Startable in org.mule.util.pool |
---|
Subinterfaces of Startable 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 Startable | |
---|---|
class |
DefaultLifecycleEnabledObjectPool
A LifecyleEnabledObjectPool implementation for pooling LifecycleAdapter
instances for implementations of JavaComponent that require
LifecycleAdapter pooling such as PooledJavaComponent . |
Uses of Startable in org.mule.util.queue |
---|
Subinterfaces of Startable 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 Startable | |
---|---|
class |
TransactionalQueueManager
The Transactional Queue Manager is responsible for creating and Managing transactional Queues. |
Uses of Startable in org.mule.work |
---|
Classes in org.mule.work that implement Startable | |
---|---|
class |
MuleWorkManager
MuleWorkManager is a JCA Work manager implementation used to manage
thread allocation for Mule components and connectors. |
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |