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

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

Packages that use Disposable
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.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.object |
org.mule.api.registry |
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.spring | Support claases for Load Mule from Spring.
org.mule.config.spring.factories |
org.mule.config.spring.util |
org.mule.config.support |
org.mule.context.notification | Internal server notification types fired via the MuleManager.
org.mule.example.loanbroker.routers |
org.mule.example.notifications |
org.mule.interceptor |
org.mule.model |
org.mule.model.direct |
org.mule.model.pipeline |
org.mule.model.seda |
org.mule.module.client | Simple interface for Mule clients to send and receive events from local or remote Mule Servers.
org.mule.module.client.remoting |
org.mule.module.guice |
org.mule.module.guice.config |
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.management.agent | Management agents including agents for Jdmk, MX4J, and Log4J
org.mule.module.ognl.expression |
org.mule.module.scripting.component | Base classes for script based components such as BeanShell or Groovy.
org.mule.module.scripting.expression |
org.mule.module.sxc |
org.mule.module.xml.expression |
org.mule.module.xml.routing |
org.mule.module.xml.transformer | Xml and Xslt Transformer implementations.
org.mule.object |
org.mule.registry |
org.mule.routing | Defines the core routing patterns supported by mule.
org.mule.routing.binding |
org.mule.routing.inbound | Inbound router implementation as described in the Enterprise Integration Patterns book.
org.mule.routing.outbound | Outbound router implementation as described in the Enterprise Integration Patterns book.
org.mule.routing.response | Response router implementations that enable asynchronous event processing in request /response messaging requests.
org.mule.service |
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.bpm |
org.mule.transport.cxf |
org.mule.transport.cxf.component |
org.mule.transport.cxf.wsdl |
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.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.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.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.soap.component |
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.monitor | Various resource monitor implementations.
org.mule.util.pool |
org.mule.util.store |
org.mule.work | A javax.resource.spi.WorkManager implementation.

Uses of Disposable in org.mule

Classes in org.mule that implement Disposable
`class` | `AbstractAgent` Implements common methods for all Agents.
`class` | `AbstractExceptionListener` `AbstractExceptionListener` is a base implementation that custom Exception Listeners can override.
`class` | `DefaultExceptionStrategy` `DefaultExceptionStrategy` provides a default exception handling strategy.
`class` | `DefaultMuleContext`

Uses of Disposable in org.mule.agent

Classes in org.mule.agent that implement Disposable
`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 Disposable in org.mule.api

Subinterfaces of Disposable in org.mule.api
`interface` | `MuleContext`

Uses of Disposable in org.mule.api.agent

Subinterfaces of Disposable 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 Disposable in org.mule.api.component

Subinterfaces of Disposable in org.mule.api.component
`interface` | `Component` A `Component` is a invoked by a `Service` for each incoming `MuleEvent` routed on by the `InboundRouterCollection`.
`interface` | `JavaComponent` `JavaComponent` is a Java `Component` implementation used to invoke Java component implementations.
`interface` | `LifecycleAdapter` `LifecycleAdapter` is a wrapper around a pojo service that adds Lifecycle methods to the pojo.

Uses of Disposable in org.mule.api.context

Subinterfaces of Disposable in org.mule.api.context
`interface` | `WorkManager` `WorkManager` extends the standard JCA WorkManager with lifecycle methods and util.concurrent bridging.

Uses of Disposable in org.mule.api.lifecycle

Subinterfaces of Disposable 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 Disposable
`DisposeException(Message message, Disposable component)`
`DisposeException(Message message, Throwable cause, Disposable component)`
`DisposeException(Throwable cause, Disposable component)`

Uses of Disposable in org.mule.api.model

Subinterfaces of Disposable in org.mule.api.model
`interface` | `Model` The `Model` encapsulates and manages the runtime behaviour of a Mule Server instance.

Uses of Disposable in org.mule.api.object

Subinterfaces of Disposable in org.mule.api.object
`interface` | `ObjectFactory` `ObjectFactory` is a generic Factory interface.

Uses of Disposable in org.mule.api.registry

Subinterfaces of Disposable in org.mule.api.registry
`interface` | `MuleRegistry` Adds lookup/register/unregister methods for Mule-specific entities to the standard Registry interface.
`interface` | `Registry`
`interface` | `RegistryBroker` A RegistryBroker delegates calls to a collection of Registries.

Uses of Disposable in org.mule.api.routing

Subinterfaces of Disposable in org.mule.api.routing
`interface` | `BindingCollection` `BindingCollection` manages a collection of component bindings.
`interface` | `InboundRouter` `InboundRouter` defines an interface for an inbound Message router.
`interface` | `InboundRouterCollection` `DefaultInboundRouterCollection` manages a collection of inbound routers.
`interface` | `InterfaceBinding`
`interface` | `OutboundRouter` `OutboundRouter` is used to control outbound routing behaviour for an event.
`interface` | `OutboundRouterCollection` `OutboundRouterCollection` is responsible for holding all outbound routers for a service service.
`interface` | `ResponseRouter` `ResponseRouter` is a router that handles response flow.
`interface` | `ResponseRouterCollection` `ResponseRouterCollection` is a router that can be used to control how the response in a request/response message flow is created.
`interface` | `Router` `Router` is a base interface for all routers.
`interface` | `RouterCollection` `RouterCollection` defines the interface for a MessageRouter that manages more than one router.

Uses of Disposable in org.mule.api.service

Subinterfaces of Disposable in org.mule.api.service
`interface` | `Service` `Service` is the internal representation of a Mule Managed service.

Uses of Disposable in org.mule.api.transport

Subinterfaces of Disposable 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 Disposable in org.mule.component

Classes in org.mule.component that implement Disposable
`class` | `AbstractComponent` Abstract `Component` to be used by all `Component` implementations.
`class` | `AbstractJavaComponent` Abstract implementation of JavaComponent adds JavaComponent specific's: `EntryPointResolverSet`, `BindingCollection` and `ObjectFactory`.
`class` | `DefaultJavaComponent` Default implementation of `JavaComponent`.
`class` | `DefaultLifecycleAdapter` `DefaultLifecycleAdapter` provides lifecycle methods for all Mule managed components.
`class` | `NullLifecycleAdapter` `NullLifecycleAdapter` is a lifecycle adaptor implementation that performs no Mule lifecycle propagation to Mule service component implementations.
`class` | `PooledJavaComponent` `PooledJavaComponent` implements pooling.
`protected class` | `PooledJavaComponent.LifeCycleAdaptorFactory` `LifeCycleAdaptorFactory` wraps the Component' s `ObjectFactory`.
`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 Disposable in org.mule.component.simple

Classes in org.mule.component.simple that implement Disposable
`class` | `PassThroughComponent` `PassThroughComponent` will simply return the payload back as the result.

Uses of Disposable in org.mule.config.spring

Classes in org.mule.config.spring that implement Disposable
`class` | `SpringRegistry`

Uses of Disposable in org.mule.config.spring.factories

Classes in org.mule.config.spring.factories that implement Disposable
`class` | `ScopedObjectFactory` This class is a bastardization of the the exising factories.

Uses of Disposable in org.mule.config.spring.util

Classes in org.mule.config.spring.util that implement Disposable
`class` | `SpringBeanLookup` This is an implementation of the ObjectFactory interface which simply delegates to the Spring ApplicationContext.

Uses of Disposable in org.mule.config.support

Classes in org.mule.config.support that implement Disposable
`class` | `InheritedModel` TODO

Uses of Disposable in org.mule.context.notification

Classes in org.mule.context.notification that implement Disposable
`class` | `ServerNotificationManager` A reworking of the event manager that allows efficient behaviour without global on/off switches in the config.

Uses of Disposable in org.mule.example.loanbroker.routers

Classes in org.mule.example.loanbroker.routers that implement Disposable
`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 Disposable in org.mule.example.notifications

Classes in org.mule.example.notifications that implement Disposable
`class` | `HeartbeatAgent` A simple agent that fire `HeartbeatNotification` events at a given frequency to notify that the server is alive and well.

Uses of Disposable in org.mule.interceptor

Classes in org.mule.interceptor that implement Disposable
`class` | `InterceptorStack` Maintains a list of interceptors that can be applied to components.

Uses of Disposable in org.mule.model

Classes in org.mule.model that implement Disposable
`class` | `AbstractModel` `MuleModel` is the default implementation of the Model.

Uses of Disposable in org.mule.model.direct

Classes in org.mule.model.direct that implement Disposable
`class` | `DirectModel`
`class` | `DirectService` A direct service invokes the service service directly without any threading, even when the invocation is asynchronous

Uses of Disposable in org.mule.model.pipeline

Classes in org.mule.model.pipeline that implement Disposable
`class` | `PipelineModel`
`class` | `PipelineService`

Uses of Disposable in org.mule.model.seda

Classes in org.mule.model.seda that implement Disposable
`class` | `SedaModel` A mule service service model that uses Seda principals to achieve high throughput by Quing events for compoonents 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 Disposable in org.mule.module.client

Classes in org.mule.module.client that implement Disposable
`class` | `MuleClient` `MuleClient` is a simple interface for Mule clients to send and receive events from a Mule Server.
`class` | `RemoteDispatcher` `RemoteDispatcher` is used to make and receive requests to a remote Mule instance.

Uses of Disposable in org.mule.module.client.remoting

Classes in org.mule.module.client.remoting that implement Disposable
`class` | `RemoteDispatcherAgent` `RemoteDispatcherAgent` manages the server endpoint that receives Admin and remote client requests

Uses of Disposable in org.mule.module.guice

Classes in org.mule.module.guice that implement Disposable
`class` | `GuiceRegistry` The internal Mule interface for retreiving objects from a Guice injector.

Uses of Disposable in org.mule.module.guice.config

Classes in org.mule.module.guice.config that implement Disposable
`class` | `GuiceLookupObjectFactory` A Componet object factory that is configured from Guice

Uses of Disposable in org.mule.module.jca

Classes in org.mule.module.jca that implement Disposable
`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 Disposable in org.mule.module.management.agent

Classes in org.mule.module.management.agent that implement Disposable
`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 Disposable in org.mule.module.ognl.expression

Classes in org.mule.module.ognl.expression that implement Disposable
`class` | `OgnlExpressionEvaluator` An expression evaluator that uses OGNL as the expression language

Uses of Disposable in org.mule.module.scripting.component

Classes in org.mule.module.scripting.component that implement Disposable
`class` | `ScriptComponent` A Script service backed by a JSR-223 compliant script engine such as Groovy, JavaScript, or Rhino.

Uses of Disposable in org.mule.module.scripting.expression

Classes in org.mule.module.scripting.expression that implement Disposable
`class` | `AbstractScriptExpressionEvaluator` An abstract `ExpressionEvaluator` that can be used for any JSR-233 script engine.
`class` | `GroovyExpressionEvaluator` An `ExpressionEvaluator` that allows the user to define Groovy expressions to extract data from the current message.

Uses of Disposable in org.mule.module.sxc

Classes in org.mule.module.sxc that implement Disposable
`class` | `SxcFilteringOutboundRouter` `FilteringRouter` is a router that accepts events based on a filter set.

Uses of Disposable in org.mule.module.xml.expression

Classes in org.mule.module.xml.expression that implement Disposable
`class` | `AbstractXPathExpressionEvaluator` Provides a base class for XPath property extractors.
`class` | `BeanPayloadExpressionEvaluator` TODO
`class` | `XPathExpressionEvaluator` Will select the text of a single node based on the property name
`class` | `XPathNodeExpressionEvaluator` Will select the text of a single node based on the property name

Uses of Disposable in org.mule.module.xml.routing

Classes in org.mule.module.xml.routing that implement Disposable
`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 Disposable in org.mule.module.xml.transformer

Classes in org.mule.module.xml.transformer that implement Disposable
`class` | `XQueryTransformer` The XQuery Module gives users the ability to perform XQuery transformations on XML messages in Mule

Uses of Disposable in org.mule.object

Classes in org.mule.object that implement Disposable
`class` | `AbstractObjectFactory` Creates object instances based on the class and sets any properties.
`class` | `JndiObjectFactory`
`class` | `PrototypeObjectFactory` Creates a new instance of the object on each call.
`class` | `SingletonObjectFactory` Creates an instance of the object once and then always returns the same instance.

Uses of Disposable in org.mule.registry

Classes in org.mule.registry that implement Disposable
`class` | `AbstractRegistry`
`class` | `AbstractRegistryBroker`
`class` | `DefaultRegistryBroker`
`class` | `ExpressionEvaluatorProcessor` Registers ExpressionEvaluators with the `DefaultExpressionManager` so that they will be resolved at run-time.
`class` | `MuleRegistryHelper` Adds lookup/register/unregister methods for Mule-specific entities to the standard Registry interface.
`class` | `TransientRegistry` Use synchronized(registry) when reading/writing/iterating over the contents of the registry hashmap.
`class` | `TypeBasedTransformerResolver` Will discover transformers based on type information only.

Uses of Disposable in org.mule.routing

Classes in org.mule.routing that implement Disposable
`class` | `AbstractRouter` Implements the shared methods that all routers have.
`class` | `AbstractRouterCollection` `AbstractRouterCollection` provides common method implementations of router collections for in and outbound routers.

Uses of Disposable in org.mule.routing.binding

Classes in org.mule.routing.binding that implement Disposable
`class` | `DefaultBindingCollection` TODO
`class` | `DefaultInterfaceBinding`

Uses of Disposable in org.mule.routing.inbound

Classes in org.mule.routing.inbound that implement Disposable
`class` | `AbstractCorrelationAggregator` `CorrelationAggregator` uses the CorrelationID and CorrelationGroupSize properties of the `MuleMessage` to manage message groups.
`class` | `AbstractEventAggregator` `AbstractEventAggregator` will aggregate a set of messages into a single message.
`class` | `CorrelationEventResequencer` `CorrelationEventResequencer` is used to resequence events according to their dispatch sequence in the correlation group.
`class` | `DefaultInboundRouterCollection` `DefaultInboundRouterCollection` is a collection of routers that will be invoked when an event is received.
`class` | `ForwardingConsumer` `ForwardingConsumer` is used to forward an incoming event over another transport without invoking a service.
`class` | `IdempotentReceiver` `IdempotentReceiver` ensures that only unique messages are received by a service.
`class` | `IdempotentSecureHashReceiver` `IdempotentSecureHashReceiver` ensures that only unique messages are received by a service.
`class` | `InboundPassThroughRouter` `InboundPassThroughRouter` allows inbound routing over all registered endpoints without any filtering.
`class` | `MessageChunkingAggregator`
`class` | `SelectiveConsumer` `SelectiveConsumer` is an inbound router used to filter out unwanted events.
`class` | `SimpleCollectionAggregator` This router will return all aggregated events as a `MuleMessageCollection`.
`class` | `WireTap` An inbound router that can forward every message to another destination as defined in the "endpoint" property.

Uses of Disposable in org.mule.routing.outbound

Classes in org.mule.routing.outbound that implement Disposable
`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 endpoints using the result of the first as the input for the second.
`class` | `DefaultOutboundRouterCollection` `DefaultOutboundRouterCollection` is a container of routers.
`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` `StaticRecipientList` is used to dispatch a single event to multiple recipients over the same transport.
`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` | `TemplateEndpointRouter` The TemplateEndpointRouter allows endpoints to be altered at runtime based on properties set on the current event or fallback values set on the endpoint properties.
`class` | `TransformerRouter` Simply applies a transformer before continuing on to the next router.

Uses of Disposable in org.mule.routing.response

Classes in org.mule.routing.response that implement Disposable
`class` | `AbstractResponseAggregator` `AbstractResponseAggregator` provides a base class for implementing response aggregator routers.
`class` | `AbstractResponseCallbackAggregator` TODO
`class` | `AbstractResponseRouter` `AbstractResponseRouter` is a base class for all Response Routers
`class` | `CollectionResponseWithCallbackRouter` The router configured to handle reply messages when the `Reply` annotation is used and the "aggregate" flag is set on the annotation.
`class` | `DefaultResponseRouterCollection` `DefaultResponseRouterCollection` is a router that can be used to control how the response in a request/response message flow is created.
`class` | `ResponseCorrelationAggregator` `ResponseCorrelationAggregator` Correlates one or more events on a response flow using the Correlation Id to group events.
`class` | `SimpleCollectionResponseAggregator` A simple aggregator that will keep collecting events until a timeout is reached.
`class` | `SingleResponseRouter` Handles single event responses from a replyTo address.
`class` | `SingleResponseWithCallbackRouter` The router configured to handle reply messages when the `Reply` annotation is used.

Uses of Disposable in org.mule.service

Classes in org.mule.service that implement Disposable
`class` | `AbstractService` A base implementation for all Services in Mule
`class` | `DefaultServiceExceptionStrategy` `DefaultServiceExceptionStrategy` is the default exception handler for components.

Uses of Disposable in org.mule.tck.functional

Classes in org.mule.tck.functional that implement Disposable
`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 Disposable in org.mule.tck.testmodels.services

Classes in org.mule.tck.testmodels.services that implement Disposable
`class` | `TestServiceComponent` `TestServiceComponent` is a test WebServices service.

Uses of Disposable in org.mule.transport

Classes in org.mule.transport that implement Disposable
`class` | `AbstractConnectable` 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` Provide a default dispatch (client) support for handling threads lifecycle and validation.
`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 Disposable in org.mule.transport.ajax

Classes in org.mule.transport.ajax that implement Disposable
`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 Disposable in org.mule.transport.ajax.container

Classes in org.mule.transport.ajax.container that implement Disposable
`class` | `AjaxServletConnector` A servlet connector that binds to the container and makes a configured Bayeux available to dispatchers and receivers.

Uses of Disposable in org.mule.transport.ajax.embedded

Classes in org.mule.transport.ajax.embedded that implement Disposable
`class` | `AjaxConnector` Creates an 'embedded' Ajax server using Jetty and allows Mule to receiver and send events to browsers.

Uses of Disposable in org.mule.transport.bpm

Classes in org.mule.transport.bpm that implement Disposable
`class` | `ProcessComponent`
`class` | `ProcessConnector` The BPM provider allows Mule events to initiate and/or advance processes in an external or embedded Business Process Management System (BPMS).
`class` | `ProcessMessageDispatcher` Initiates or advances a workflow process from an outgoing Mule event.
`class` | `ProcessMessageReceiver` Generates an incoming Mule event from an executing workflow process.

Uses of Disposable in org.mule.transport.cxf

Classes in org.mule.transport.cxf that implement Disposable
`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` | `CxfConnector` Connects Mule to a CXF bus instance.
`class` | `CxfMessageDispatcher` The CxfMessageDispatcher is used for making Soap client requests to remote services.
`class` | `CxfMessageReceiver` Create a CXF service.
`class` | `CxfMessageRequester` `AxisMessageDispatcher` is used to make soap requests via the Axis soap client.
`class` | `CxfServiceComponent` The CXF receives messages from Mule, converts them into CXF messages and dispatches them into the receiving CXF destination.

Uses of Disposable in org.mule.transport.cxf.component

Classes in org.mule.transport.cxf.component that implement Disposable
`class` | `WebServiceWrapperComponent`

Uses of Disposable in org.mule.transport.cxf.wsdl

Classes in org.mule.transport.cxf.wsdl that implement Disposable
`class` | `CxfWsdlConnector` TODO document
`class` | `CxfWsdlMessageDispatcher` TODO document

Uses of Disposable in org.mule.transport.ejb

Classes in org.mule.transport.ejb that implement Disposable
`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 Disposable in org.mule.transport.email

Classes in org.mule.transport.email that implement Disposable
`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 Disposable in org.mule.transport.file

Classes in org.mule.transport.file that implement Disposable
`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` `FileMessageDispatcher` is used to read/write files to the filesystem

Uses of Disposable in org.mule.transport.ftp

Classes in org.mule.transport.ftp that implement Disposable
`class` | `FtpConnector`
`class` | `FtpMessageDispatcher`
`class` | `FtpMessageReceiver`
`class` | `FtpMessageRequester`

Uses of Disposable in org.mule.transport.http

Classes in org.mule.transport.http that implement Disposable
`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 Disposable in org.mule.transport.http.components

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

Uses of Disposable in org.mule.transport.jdbc

Classes in org.mule.transport.jdbc that implement Disposable
`class` | `JdbcConnector`
`class` | `JdbcMessageDispatcher` The Jdbc Message dispatcher is responsible for executing SQL queries against a database.
`class` | `JdbcMessageReceiver` TODO
`class` | `JdbcMessageRequester`

Uses of Disposable in org.mule.transport.jms

Classes in org.mule.transport.jms that implement Disposable
`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 Disposable in org.mule.transport.jms.activemq

Classes in org.mule.transport.jms.activemq that implement Disposable
`class` | `ActiveMQJmsConnector` ActiveMQ 4.x-specific JMS connector.
`class` | `ActiveMQXAJmsConnector`

Uses of Disposable in org.mule.transport.jms.weblogic

Classes in org.mule.transport.jms.weblogic that implement Disposable
`class` | `WeblogicJmsConnector` Weblogic-specific JMS connector.

Uses of Disposable in org.mule.transport.jms.websphere

Classes in org.mule.transport.jms.websphere that implement Disposable
`class` | `WebsphereJmsConnector` Websphere-specific JMS connector.
`class` | `WebsphereTransactedJmsMessageReceiver`

Uses of Disposable in org.mule.transport.jnp

Classes in org.mule.transport.jnp that implement Disposable
`class` | `JnpConnector` `JnpConnector` uses the Java Naming protocol to bind to remote objects

Uses of Disposable in org.mule.transport.multicast

Classes in org.mule.transport.multicast that implement Disposable
`class` | `MulticastConnector` `MulticastConnector` can dispatch mule events using ip multicasting
`class` | `MulticastMessageReceiver`
`class` | `MulticastMessageReceiver.MulticastWorker`

Uses of Disposable in org.mule.transport.quartz

Classes in org.mule.transport.quartz that implement Disposable
`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 Disposable in org.mule.transport.rmi

Classes in org.mule.transport.rmi that implement Disposable
`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 Disposable in org.mule.transport.servlet

Classes in org.mule.transport.servlet that implement Disposable
`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 Disposable in org.mule.transport.servlet.jetty

Classes in org.mule.transport.servlet.jetty that implement Disposable
`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 Disposable in org.mule.transport.soap.axis

Classes in org.mule.transport.soap.axis that implement Disposable
`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 Disposable in org.mule.transport.soap.axis.wsdl

Classes in org.mule.transport.soap.axis.wsdl that implement Disposable
`class` | `AxisWsdlConnector` TODO document
`class` | `AxisWsdlMessageDispatcher` Creates and Axis client services from WSDL and invokes it.

Uses of Disposable in org.mule.transport.soap.component

Classes in org.mule.transport.soap.component that implement Disposable
`class` | `AbstractWebServiceWrapperComponent`

Uses of Disposable in org.mule.transport.ssl

Classes in org.mule.transport.ssl that implement Disposable
`class` | `SslConnector` `SslConnector` provides a connector for SSL connections.
`class` | `SslMessageReceiver`
`protected class` | `SslMessageReceiver.SslWorker`
`class` | `TlsConnector` `TlsConnector` Provides TLS connections

Uses of Disposable in org.mule.transport.stdio

Classes in org.mule.transport.stdio that implement Disposable
`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 Disposable in org.mule.transport.tcp

Classes in org.mule.transport.tcp that implement Disposable
`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.
`protected class` | `TcpMessageReceiver.TcpWorker`
`class` | `TcpMessageRequester` Request transformed Mule events from TCP.

Uses of Disposable in org.mule.transport.udp

Classes in org.mule.transport.udp that implement Disposable
`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.
`protected class` | `UdpMessageReceiver.UdpWorker`
`class` | `UdpMessageRequester` Responsible for requesting MuleEvents as UDP packets on the network

Uses of Disposable in org.mule.transport.vm

Classes in org.mule.transport.vm that implement Disposable
`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 Disposable in org.mule.transport.xmpp

Classes in org.mule.transport.xmpp that implement Disposable
`class` | `XmppConnector` `XmppConnector` TODO
`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 events to be received over Xmpp
`class` | `XmppsConnector`

Uses of Disposable in org.mule.util.monitor

Classes in org.mule.util.monitor that implement Disposable
`class` | `ExpiryMonitor` `ExpiryMonitor` can monitor objects beased on an expiry time and can invoke a callback method once the object time has expired.

Uses of Disposable in org.mule.util.pool

Subinterfaces of Disposable in org.mule.util.pool
`interface` | `LifecyleEnabledObjectPool` An ObjectPool that allows Start and Stop life-cycle to be propagated pooled object.
`interface` | `ObjectPool` `ObjectPool` is a simple pooling interface for objects

Classes in org.mule.util.pool that implement Disposable
`class` | `CommonsPoolObjectPool` `CommonsPoolProxyPool` is an implementation of `ObjectPool` that internally uses the commons-pool `GenericObjectPool` and uses a `ObjectFactory` for creating new pooled instances.
`class` | `DefaultLifecycleEnabledObjectPool` A LifecyleEnabledObjectPool implementation for pooling `LifecycleAdapter` instances for implementations of `JavaComponent` that require `LifecycleAdapter` pooling such as `PooledJavaComponent`.

Uses of Disposable in org.mule.util.store

Classes in org.mule.util.store that implement Disposable
`class` | `AbstractMonitoredObjectStore` TODO
`class` | `InMemoryObjectStore` `InMemoryObjectStore` implements an optionally bounded in-memory store for message IDs with periodic expiry of old entries.
`class` | `TextFileObjectStore` A Simple object store that stores String objects by key to a text file.

Uses of Disposable in org.mule.work

Classes in org.mule.work that implement Disposable
`class` | `MuleWorkManager` `MuleWorkManager` is a JCA Work manager implementation used to manage thread allocation for Mule components and connectors.

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

Copyright © 2003-2009 MuleSource, Inc.. All Rights Reserved.