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

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

Packages that use Initialisable
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.object |
org.mule.api.registry |
org.mule.api.routing | Interfaces that define inbound and outbound routing API.
org.mule.api.security | Security API for authentication and authorisation.
org.mule.api.service |
org.mule.api.transformer | Contains the interfaces for transformers and exceptions for the Transformer API.
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.bootstrap |
org.mule.config.dsl.routers |
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.config.transformer |
org.mule.construct |
org.mule.endpoint | Implemtation of Mule endpoint uris.
org.mule.endpoint.dynamic |
org.mule.example.bookstore |
org.mule.example.bookstore.transformers |
org.mule.example.errorhandler |
org.mule.example.geomail.transformers |
org.mule.example.hello |
org.mule.example.loanbroker.routers |
org.mule.example.loanbroker.transformers |
org.mule.example.notifications |
org.mule.example.rest |
org.mule.example.scripting |
org.mule.exception |
org.mule.expression.transformers |
org.mule.interceptor |
org.mule.model |
org.mule.model.seda |
org.mule.module.acegi |
org.mule.module.atom |
org.mule.module.atom.transformers |
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.cxf |
org.mule.module.cxf.component |
org.mule.module.cxf.config |
org.mule.module.guice |
org.mule.module.ibeans.config |
org.mule.module.jaas |
org.mule.module.jaas.filters |
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.json.transformers | Transfromers for converting from JavaBeans and collections to JSON and back again.
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.pgp |
org.mule.module.pgp.filters |
org.mule.module.rss.transformers |
org.mule.module.scripting.component | Base classes for script based components such as BeanShell or Groovy.
org.mule.module.scripting.transformer |
org.mule.module.spring.events | A Spring EventMulticaster that allows any Spring bean to send and receive mule events through the ApplicationContext and event listeners.
org.mule.module.spring.remoting |
org.mule.module.spring.security |
org.mule.module.spring.security.filters.http |
org.mule.module.sxc |
org.mule.module.ws.config.spring.factories |
org.mule.module.ws.construct |
org.mule.module.xml.expression |
org.mule.module.xml.filters | Filters that apply specifically to xml using xml querying mechanisms.
org.mule.module.xml.routing |
org.mule.module.xml.transformer | Xml and Xslt Transformer implementations.
org.mule.module.xml.transformer.jaxb |
org.mule.module.xml.util |
org.mule.object |
org.mule.processor |
org.mule.registry |
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.security | Core security implementation including the mule security manager and encryption types
org.mule.security.filters | Core sercurity filter types.
org.mule.service |
org.mule.tck.functional | Helper classes and interfaces used by Mule fnctional tests.
org.mule.tck.security |
org.mule.tck.testmodels.services |
org.mule.tck.transformer |
org.mule.transaction.lookup |
org.mule.transformer | Provides the default transformer base implementations for Mule including compression and encryption support.
org.mule.transformer.codec | Transformers for Base64, UC and UU encoding/decoding.
org.mule.transformer.compression | Transformers for compressing and uncompressing message payloads.
org.mule.transformer.encryption | Transformers for encrypting and decrypting message payloads.
org.mule.transformer.simple | Basic transformer implementations.
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.email.transformers | Contains transformers to convert to and from the java.mail.Message type.
org.mule.transport.file | Provides file transport in the form of a directory listeners and file dispatchers.
org.mule.transport.file.transformers | Transformers for converting to and from the FileMessage type.
org.mule.transport.ftp |
org.mule.transport.http | Provides http transport including proxy support.
org.mule.transport.http.components |
org.mule.transport.http.transformers |
org.mule.transport.ibean |
org.mule.transport.jbpm |
org.mule.transport.jdbc | Provides jdbc transport.
org.mule.transport.jersey |
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.transformers | Contains transformers to convert to and from different javax.jms.Message types
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.servlet.transformers |
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.transport.xmpp.transformers |
org.mule.util.pool |
org.mule.util.store |

Uses of Initialisable in org.mule

Classes in org.mule that implement Initialisable
`class` | `AbstractAgent` Implements common methods for all Agents.
`class` | `DefaultMuleContext`
`class` | `RouteableExceptionStrategy` `RouteableExceptionStrategy` allows transforming and routing exceptions to outbound routers.

Uses of Initialisable in org.mule.agent

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

Subinterfaces of Initialisable in org.mule.api
`interface` | `EncryptionStrategy` `EncryptionStrategy` can be used to provide different types of Encryption strategy objects.
`interface` | `MuleContext`

Uses of Initialisable in org.mule.api.agent

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

Subinterfaces of Initialisable in org.mule.api.component
`interface` | `LifecycleAdapter` `LifecycleAdapter` is a wrapper around a pojo service that adds Lifecycle methods to the pojo.

Uses of Initialisable in org.mule.api.endpoint

Subinterfaces of Initialisable in org.mule.api.endpoint
`interface` | `EndpointURI` `EndpointURI` is used to determine how a message is sent or received.

Uses of Initialisable in org.mule.api.lifecycle

Subinterfaces of Initialisable in org.mule.api.lifecycle
`interface` | `Lifecycle` `DefaultLifecyclePhase` adds lifecycle methods `start`, `stop` and `dispose`.

Method parameters in org.mule.api.lifecycle with type arguments of type Initialisable
`static void` | `LifecycleTransitionResult.initialiseAll(Iterator<? extends Initialisable> children)`

Constructors in org.mule.api.lifecycle with parameters of type Initialisable
`InitialisationException(Message message, Initialisable component)`
`InitialisationException(Message message, Throwable cause, Initialisable component)`
`InitialisationException(Throwable cause, Initialisable component)`
`RecoverableException(Message message, Initialisable object)`
`RecoverableException(Message message, Initialisable object, Throwable cause)`

Uses of Initialisable in org.mule.api.model

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

Uses of Initialisable in org.mule.api.object

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

Uses of Initialisable in org.mule.api.registry

Subinterfaces of Initialisable 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 Initialisable in org.mule.api.routing

Subinterfaces of Initialisable in org.mule.api.routing
`interface` | `OutboundRouter` `OutboundRouter` is used to control outbound routing behaviour for an event.
`interface` | `OutboundRouterCollection` `RouterCollection` defines the interface for a MessageRouter that manages more than one router.

Uses of Initialisable in org.mule.api.security

Subinterfaces of Initialisable in org.mule.api.security
`interface` | `EndpointSecurityFilter` `EndpointSecurityFilter` is a base filter for secure filtering of inbound and outbout event flow
`interface` | `SecurityManager` `SecurityManager` is responsible for managing one or more security providers.
`interface` | `SecurityProvider` `SecurityProvider` is a target security provider that actually does the work of authenticating credentials and populating the Authentication object.

Uses of Initialisable in org.mule.api.service

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

Uses of Initialisable in org.mule.api.transformer

Subinterfaces of Initialisable in org.mule.api.transformer
`interface` | `BaseTransformer` `Transformer` can be chained together to covert message payloads from one object type to another.
`interface` | `MessageTransformer` A transformer intended to transform Mule messages rather than arbitrary objects
`interface` | `StreamingTransformer` TODO
`interface` | `Transformer` `Transformer` can be chained together to covert message payloads from one object type to another.

Uses of Initialisable in org.mule.api.transport

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

Classes in org.mule.component that implement Initialisable
`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.
`protected class` | `PooledJavaComponent.LifeCycleAdapterFactory` `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 Initialisable in org.mule.component.simple

Classes in org.mule.component.simple that implement Initialisable
`class` | `PassThroughComponent` `PassThroughComponent` will simply return the payload back as the result.
`class` | `StaticComponent` A service that will return a static data object as a result.

Uses of Initialisable in org.mule.config.bootstrap

Classes in org.mule.config.bootstrap that implement Initialisable
`class` | `SimpleRegistryBootstrap` This object will load objects defined in a file called `registry-bootstrap.properties` into the local registry.

Uses of Initialisable in org.mule.config.dsl.routers

Classes in org.mule.config.dsl.routers that implement Initialisable
`class` | `ContentBasedRouter` TODO

Uses of Initialisable in org.mule.config.spring

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

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

Classes in org.mule.config.spring.factories that implement Initialisable
`class` | `AbstractEndpointFactoryBean` Abstract spring FactoryBean used to creating endpoints via spring.
`class` | `AbstractFlowConstructFactoryBean`
`class` | `BridgeFactoryBean`
`class` | `EndpointFactoryBean` Endpoint factory bean which uses type attribute to determine endpoint type (Used by 1to2migration module)
`class` | `InboundEndpointFactoryBean` Spring FactoryBean used to create concrete instances of inbound endpoints
`class` | `OutboundEndpointFactoryBean` Spring FactoryBean used to create concrete instances of outbound endpoints
`class` | `SimpleServiceFactoryBean` Builds SimpleService instances by using the SimpleServiceBuilder.

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

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

Uses of Initialisable in org.mule.config.support

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

Uses of Initialisable in org.mule.config.transformer

Classes in org.mule.config.transformer that implement Initialisable
`class` | `AnnotatedTransformerProxy` Creates a Mule `Transformer` proxy around a transform method.

Uses of Initialisable in org.mule.construct

Classes in org.mule.construct that implement Initialisable
`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.

Uses of Initialisable in org.mule.endpoint

Classes in org.mule.endpoint that implement Initialisable
`class` | `MuleEndpointURI` `MuleEndpointURI` is used to determine how a message is sent or received.

Uses of Initialisable in org.mule.endpoint.dynamic

Classes in org.mule.endpoint.dynamic that implement Initialisable
`class` | `NullConnector` A placeholder for a connector that has not been created yet.

Uses of Initialisable in org.mule.example.bookstore

Classes in org.mule.example.bookstore that implement Initialisable
`class` | `CatalogServiceImpl` Bookstore catalog service which implements both the public interface for browsing the catalog and the admin interface for adding books to the catalog.

Uses of Initialisable in org.mule.example.bookstore.transformers

Classes in org.mule.example.bookstore.transformers that implement Initialisable
`class` | `AddBookResponse` A call to addBook() returns a Long representing the number of books in the catalog.
`class` | `HttpRequestToBook` Transforms a Map of HttpRequest parameters into a Book object.
`class` | `OrderToEmailTransformer` Composes an e-mail notification message to be sent based on the Book Order.

Uses of Initialisable in org.mule.example.errorhandler

Classes in org.mule.example.errorhandler that implement Initialisable
`class` | `ErrorMessageToException` The `ErrorMessageToException` transformer extracts and returns the exception encapsulated by the ErrorMessage message payload.
`class` | `ErrorMessageToExceptionBean` The `ErrorMessageToExceptionBean` transformer returns the exception bean encapsulated by the ErrorMessage message payload.
`class` | `ExceptionBeanToErrorMessage`

Uses of Initialisable in org.mule.example.geomail.transformers

Classes in org.mule.example.geomail.transformers that implement Initialisable
`class` | `IPToSender` TODO

Uses of Initialisable in org.mule.example.hello

Classes in org.mule.example.hello that implement Initialisable
`class` | `ChatStringToString` `NameStringToChatString` is a dummy transformer used in the hello world application to transform the ChatString object into a string.
`class` | `ExceptionToString` `ExceptionToString` converts an exception to a String, returning the exception's `getMessage()` result.
`class` | `HttpRequestToNameString`
`class` | `NameStringToChatString` `NameStringToChatString` converts from a NameString object to a ChatString object.
`class` | `StdinToNameString` The transformation removes break-lines and newlines from the string, which potentially could have been added during a `stdin` input operation.
`class` | `StringToNameString` `StringToNameString` converts from a String to a NameString object.

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

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

Classes in org.mule.example.loanbroker.transformers that implement Initialisable
`class` | `CreditProfileXmlToCreditProfile`
`class` | `LoanQuoteRequestToCreditProfileArgs` Extracts the customer information from the request into an array of arguments used to invoke the Credit Agency MuleSession bean
`class` | `RestRequestToCustomerRequest` Converts parameters on the message into a CustomerQuoteRequest object

Uses of Initialisable in org.mule.example.notifications

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

Uses of Initialisable in org.mule.example.rest

Classes in org.mule.example.rest that implement Initialisable
`class` | `RestTester` TODO MULE-3990 This is a bogus class that has been put here so that the Corbertura plugin does not barf, we need to find a way to get this plug in to ignore certain modules

Uses of Initialisable in org.mule.example.scripting

Classes in org.mule.example.scripting that implement Initialisable
`class` | `SimpleMathTransformer` A simple transformer which adds/subtracts/multiplies/divides a constant factor to numeric messages.
`class` | `StringToNumber` Converts a string to a number.

Uses of Initialisable in org.mule.exception

Classes in org.mule.exception that implement Initialisable
`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 Initialisable in org.mule.expression.transformers

Classes in org.mule.expression.transformers that implement Initialisable
`class` | `AbstractExpressionTransformer` This transformer will evaluate one or more expressions on the current message and return the results as an Array.
`class` | `BeanBuilderTransformer` This transformer uses the returnClass to create the return object and then will populate the bean with arguments defined as expressions
`class` | `ExpressionTransformer` This transformer will evaluate one or more expressions on the current message and return the results as an Array.

Uses of Initialisable in org.mule.interceptor

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

Uses of Initialisable in org.mule.model

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

Uses of Initialisable in org.mule.model.seda

Classes in org.mule.model.seda that implement Initialisable
`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 Initialisable in org.mule.module.acegi

Classes in org.mule.module.acegi that implement Initialisable
`class` | `AcegiProviderAdapter` `AcegiProviderAdapter` is a wrapper for an Acegi Security provider to use with the SecurityManager

Uses of Initialisable in org.mule.module.atom

Classes in org.mule.module.atom that implement Initialisable
`class` | `AbderaServiceComponent` This component receives requests from Mule and passes them off to Abdera.

Uses of Initialisable in org.mule.module.atom.transformers

Classes in org.mule.module.atom.transformers that implement Initialisable
`class` | `AtomEntryBuilderTransformer`
`class` | `BaseToOutputHandler` Converts Abdera model elements which extend `Base` to OutputHandlers.
`class` | `ObjectToFeed` `ObjectToInputStream` converts serilaizable object to a input stream but treats `java.lang.String` differently by converting to bytes using the `String.getBytes()` method.

Uses of Initialisable in org.mule.module.client

Classes in org.mule.module.client that implement Initialisable
`class` | `AbstractEventTransformer` `AbstractEventTransformer` adds support for adding method details to the result message.

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

Classes in org.mule.module.client.remoting that implement Initialisable
`class` | `RemoteDispatcherAgent` `RemoteDispatcherAgent` manages the server endpoint that receives Admin and remote client requests
`class` | `RemoteDispatcherComponent` `RemoteDispatcherComponent` is a MuleManager interal server component responsible for receiving remote requests and dispatching them locally.

Uses of Initialisable in org.mule.module.cxf

Classes in org.mule.module.cxf that implement Initialisable
`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` | `CxfConfiguration` Provides global CXF configuration defaults.
`class` | `CxfInboundMessageProcessor` The CxfInboundMessageProcessor performs inbound CXF processing, sending an event through the CXF service, then on to the next MessageProcessor.
`class` | `WSProxyService` This class is implemented to act as a Proxy for a Web Service.

Uses of Initialisable in org.mule.module.cxf.component

Classes in org.mule.module.cxf.component that implement Initialisable
`class` | `AbstractWebServiceWrapperComponent`
`class` | `WebServiceWrapperComponent`

Uses of Initialisable in org.mule.module.cxf.config

Classes in org.mule.module.cxf.config that implement Initialisable
`class` | `FlowConfiguringMessageProcessor` Wraps a `MessageProcessorBuilder` and configures it lazily so it can be injected with the `FlowConstruct`.

Uses of Initialisable in org.mule.module.guice

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

Uses of Initialisable in org.mule.module.ibeans.config

Classes in org.mule.module.ibeans.config that implement Initialisable
`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 Initialisable in org.mule.module.jaas

Classes in org.mule.module.jaas that implement Initialisable
`class` | `JaasSimpleAuthenticationProvider` This is the Provider for Mule's Jaas Security.

Uses of Initialisable in org.mule.module.jaas.filters

Classes in org.mule.module.jaas.filters that implement Initialisable
`class` | `JaasSecurityFilter`

Uses of Initialisable in org.mule.module.jca

Classes in org.mule.module.jca that implement Initialisable
`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 Initialisable in org.mule.module.json.transformers

Classes in org.mule.module.json.transformers that implement Initialisable
`class` | `AbstractJsonTransformer` TODO
`class` | `JsonToObject` A transformer that will convert a JSON encoded object graph to a java object.
`class` | `ObjectToJson` Converts a java object to a JSON encoded object that can be consumed by other languages such as Javascript or Ruby.

Uses of Initialisable in org.mule.module.management.agent

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

Subinterfaces of Initialisable in org.mule.module.management.mbean
`interface` | `ConnectorServiceMBean`

Classes in org.mule.module.management.mbean that implement Initialisable
`class` | `ConnectorService`

Uses of Initialisable in org.mule.module.pgp

Classes in org.mule.module.pgp that implement Initialisable
`class` | `KeyBasedEncryptionStrategy`
`class` | `PGPKeyRingImpl`
`class` | `PGPSecurityProvider`

Uses of Initialisable in org.mule.module.pgp.filters

Classes in org.mule.module.pgp.filters that implement Initialisable
`class` | `PGPSecurityFilter`

Uses of Initialisable in org.mule.module.rss.transformers

Classes in org.mule.module.rss.transformers that implement Initialisable
`class` | `ObjectToRssFeed` Converts an RSS data representation into a SyndFeed object

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

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

Uses of Initialisable in org.mule.module.scripting.transformer

Classes in org.mule.module.scripting.transformer that implement Initialisable
`class` | `ScriptTransformer` Runs a script to perform transformation on an object.

Uses of Initialisable in org.mule.module.spring.events

Classes in org.mule.module.spring.events that implement Initialisable
`class` | `MuleEventMulticaster` `MuleEventMulticaster` is an implementation of a Spring ApplicationeventMulticaster.

Uses of Initialisable in org.mule.module.spring.remoting

Classes in org.mule.module.spring.remoting that implement Initialisable
`class` | `ObjectToRemoteInvocationResultTransformer` Converts an Object to a Spring RemoteInvocationResult and then into a byte[].
`class` | `ObjectToRemoteInvocationTransformer` Transforms a byte[] into an ObjectInputStream and then into a Spring RemoteInvocation instance.
`class` | `SpringRemoteInvokerComponent`

Uses of Initialisable in org.mule.module.spring.security

Classes in org.mule.module.spring.security that implement Initialisable
`class` | `SpringProviderAdapter` `AcegiProviderAdapter` is a wrapper for an Acegi Security provider to use with the SecurityManager

Uses of Initialisable in org.mule.module.spring.security.filters.http

Classes in org.mule.module.spring.security.filters.http that implement Initialisable
`class` | `HttpBasicAuthenticationFilter` `HttpBasicAuthenticationFilter` TODO

Uses of Initialisable in org.mule.module.sxc

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

Uses of Initialisable in org.mule.module.ws.config.spring.factories

Classes in org.mule.module.ws.config.spring.factories that implement Initialisable
`class` | `WSProxyFactoryBean`

Uses of Initialisable in org.mule.module.ws.construct

Classes in org.mule.module.ws.construct that implement Initialisable
`class` | `WSProxy` This class is implemented to act as a Proxy for a Web Service.

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

Classes in org.mule.module.xml.expression that implement Initialisable
`class` | `AbstractXPathExpressionEvaluator` Provides a base class for XPath property extractors.
`class` | `BeanPayloadExpressionEvaluator` TODO
`class` | `JaxpXPathExpressionEvaluator` Uses JAXP XPath processing to evaluate xpath expressions against Xml fragments and documents Note that the Jaxp Expression evaluator differs from the Mule XPATH evaluator slightly since you cna set the JaxP return type as a prefix to the expression i.e.
`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 Initialisable in org.mule.module.xml.filters

Classes in org.mule.module.xml.filters that implement Initialisable
`class` | `JXPathFilter` `JXPathFilter` evaluates an XPath expression against a W3C Document, XML string, or Java bean and returns true if the result is as expected.
`class` | `SchemaValidationFilter` Filter for schema validation.
`class` | `XPathFilter`

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

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

Classes in org.mule.module.xml.transformer that implement Initialisable
`class` | `AbstractXmlTransformer` `AbstractXmlTransformer` offers some XSLT transform on a DOM (or other XML-ish) object.
`class` | `AbstractXStreamTransformer` `AbstractXStreamTransformer` is a base class for all XStream based transformers.
`class` | `DomDocumentToXml` `DomDocumentToXml` Transform a org.w3c.dom.Document to XML String
`class` | `JXPathExtractor` The JXPathExtractor is a simple transformer that evaluates an xpath expression against the given bean and that returns the result.
`class` | `ObjectToXml` `ObjectToXml` converts any object to XML using Xstream.
`class` | `XmlPrettyPrinter`
`class` | `XmlToDomDocument` `XmlToDomDocument` transforms a XML String to org.w3c.dom.Document.
`class` | `XmlToObject` `XmlToObject` converts xml created by the ObjectToXml transformer in to a java object graph.
`class` | `XmlToOutputHandler`
`class` | `XmlToXMLStreamReader`
`class` | `XPathExtractor` Simple transformer for using the JAXP XPath library to extract an XPath value from an XPath expression.
`class` | `XQueryTransformer` The XQuery Module gives users the ability to perform XQuery transformations on XML messages in Mule
`class` | `XsltTransformer` `XsltTransformer` performs an XSLT transform on a DOM (or other XML-ish) object.

Uses of Initialisable in org.mule.module.xml.transformer.jaxb

Classes in org.mule.module.xml.transformer.jaxb that implement Initialisable
`class` | `JAXBMarshallerTransformer` Allows marshaling of Java objects to XML using JAXB 2.
`class` | `JAXBUnmarshallerTransformer` Allows un-marshaling of XML generated by JAXB to a Java object graph.

Uses of Initialisable in org.mule.module.xml.util

Classes in org.mule.module.xml.util that implement Initialisable
`class` | `NamespaceManager` A simple manager that holds a registry of global namespaces that will be recognised by all xml queries and transforms

Uses of Initialisable in org.mule.object

Classes in org.mule.object that implement Initialisable
`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 Initialisable in org.mule.processor

Classes in org.mule.processor that implement Initialisable
`class` | `SedaStageInterceptingMessageProcessor` Processes `MuleEvent`'s asynchronously using a `MuleWorkManager` to schedule asynchronous processing of the next `MessageProcessor`.

Uses of Initialisable in org.mule.registry

Classes in org.mule.registry that implement Initialisable
`class` | `AbstractRegistry`
`class` | `AbstractRegistryBroker`
`class` | `DefaultRegistryBroker`
`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 Initialisable in org.mule.routing

Classes in org.mule.routing that implement Initialisable
`class` | `AbstractAggregator` `AbstractEventAggregator` will aggregate a set of messages into a single message.
`class` | `AbstractCorrelationAggregator` `AbstractCorrelationAggregatingMessageProcessor` uses the CorrelationID and CorrelationGroupSize properties of the `MuleMessage` to manage message groups.
`class` | `ExpressionSplitter` Splits a message using the expression provided invoking the next message processor one for each split part.
`class` | `IdempotentMessageFilter` `IdempotentMessageFilter` ensures that only unique messages are passed on.
`class` | `IdempotentSecureHashMessageFilter` `IdempotentSecureHashMessageFilter` ensures that only unique messages are received by a service.
`class` | `MessageChunkAggregator`
`class` | `Resequencer` `CorrelationEventResequencer` is used to resequence events according to their dispatch sequence in the correlation group.
`class` | `SimpleCollectionAggregator` This router will return all aggregated events as a `MuleMessageCollection`.

Uses of Initialisable in org.mule.routing.outbound

Classes in org.mule.routing.outbound that implement Initialisable
`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` | `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`
`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 Initialisable in org.mule.security

Classes in org.mule.security that implement Initialisable
`class` | `AbstractEndpointSecurityFilter` `AbstractEndpointSecurityFilter` provides basic initialisation for all security filters, namely configuring the SecurityManager for this instance
`class` | `AbstractJCEEncryptionStrategy` A JCE based encryption strategy.
`class` | `AbstractNamedEncryptionStrategy`
`class` | `AbstractSecurityProvider`
`class` | `MuleSecurityManager` `MuleSecurityManager` is a default implementation security manager for a Mule instance.
`class` | `PasswordBasedEncryptionStrategy` Provides password-based encryption using JCE.
`class` | `SecretKeyEncryptionStrategy` SecretKey based encryption using JCE.

Uses of Initialisable in org.mule.security.filters

Classes in org.mule.security.filters that implement Initialisable
`class` | `MuleEncryptionEndpointSecurityFilter` `MuleEncryptionEndpointSecurityFilter` provides password-based encryption

Uses of Initialisable in org.mule.service

Classes in org.mule.service that implement Initialisable
`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 Initialisable in org.mule.tck.functional

Classes in org.mule.tck.functional that implement Initialisable
`class` | `FunctionalTestComponent` `FunctionalTestComponent` is a service that can be used by functional tests.
`class` | `QuietExceptionStrategy` Restrict exceptions to debug log messages
`class` | `StringAppendTestTransformer`
`class` | `TransactionalFunctionalTestComponent` This service is useful for unit tests involving transactionality because it will roll back the current transaction upon message arrival.

Uses of Initialisable in org.mule.tck.security

Classes in org.mule.tck.security that implement Initialisable
`class` | `MockEncryptionStrategy` Empty mock for tests
`class` | `TestMultiuserSecurityProvider` A security provider which holds authentications for multiple users concurrently.
`class` | `TestSingleUserSecurityProvider` A security provider which only authenticates a single user at a time (i.e., authentication of a new user overwrites the previous authentication).

Uses of Initialisable in org.mule.tck.testmodels.services

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

Uses of Initialisable in org.mule.tck.transformer

Classes in org.mule.tck.transformer that implement Initialisable
`class` | `NoActionTransformer` `NoActionTransformer` doesn't do any transformation on the source object and returns the source as the result.
`class` | `ValidateResponse` Throws an exception if the message does not contain "success".

Uses of Initialisable in org.mule.transaction.lookup

Classes in org.mule.transaction.lookup that implement Initialisable
`class` | `GenericTransactionManagerLookupFactory` A factory performing a JNDI lookup for TransactionManager.
`class` | `JBossTransactionManagerLookupFactory`
`class` | `JRunTransactionManagerLookupFactory`
`class` | `Resin3TransactionManagerLookupFactory`
`class` | `WeblogicTransactionManagerLookupFactory`

Uses of Initialisable in org.mule.transformer

Classes in org.mule.transformer that implement Initialisable
`class` | `AbstractDiscoverableTransformer`
`class` | `AbstractMessageAwareTransformer` Deprecated.
`class` | `AbstractMessageTransformer` `AbstractMessageTransformer` is a transformer that has a reference to the current message.
`class` | `AbstractTransformer` `AbstractTransformer` is a base class for all transformers.
`class` | `TransformerChain` A referencable chain of transformers that can be used as a single transformer
`class` | `TransformerTemplate` TODO

Uses of Initialisable in org.mule.transformer.codec

Classes in org.mule.transformer.codec that implement Initialisable
`class` | `Base64Decoder` `Base64Encoder` transforms Base64 encoded data into strings or byte arrays.
`class` | `Base64Encoder` `Base64Encoder` transforms strings or byte arrays into Base64 encoded string.
`class` | `XmlEntityDecoder` Decodes a String or byte[] containing XML entities
`class` | `XmlEntityEncoder` Encodes a string with XML entities

Uses of Initialisable in org.mule.transformer.compression

Classes in org.mule.transformer.compression that implement Initialisable
`class` | `AbstractCompressionTransformer` `AbstractCompressionTransformer` is a base class for all transformers that can compress or uncompress data when they performa message transformation.
`class` | `GZipCompressTransformer` `GZipCompressTransformer` is a transformer compressing objects into byte arrays.
`class` | `GZipUncompressTransformer` `GZipCompressTransformer` will uncompress a byte[] or InputStream

Uses of Initialisable in org.mule.transformer.encryption

Classes in org.mule.transformer.encryption that implement Initialisable
`class` | `AbstractEncryptionTransformer` `EncryptionTransformer` will transform an array of bytes or string into an encrypted array of bytes
`class` | `DecryptionTransformer` `EncryptionTransformer` will transform an encrypted array of bytes or string into an decrypted array of bytes
`class` | `EncryptionTransformer` `EncryptionTransformer` will transform an array of bytes or string into an encrypted array of bytes

Uses of Initialisable in org.mule.transformer.simple

Classes in org.mule.transformer.simple that implement Initialisable
`class` | `AutoTransformer` A transformer that uses the transform discovery mechanism to convert the message payload.
`class` | `BeanToMap` Conversts a simple bean object to a Map.
`class` | `ByteArrayToHexString` Converts a Byte array to a Hex String.
`class` | `ByteArrayToMuleMessage` TODO
`class` | `ByteArrayToObject` `ByteArrayToObject` works in the same way as `ByteArrayToSerializable` but checks if the byte array is a serialised object and if not will return a String created from the bytes as the returnType on the transformer.
`class` | `ByteArrayToSerializable` `ByteArrayToSerializable` converts a serialized object to its object representation
`class` | `GetBeanProperty` Looks up a property from a JavaBean using PropertyUtils.getProperty().
`class` | `HexStringToByteArray` Converts a Hex String to a Byte array
`class` | `MapLookup` `MapLookup` looks up and returns an object from a Map based on a key.
`class` | `MapToBean` Creates and object of type `AbstractTransformer.getReturnClass()` and populates values of a `Map` as bean properties on the object.
`class` | `MessagePropertiesTransformer` A configurable message transformer that allows users to add, overwrite, rename and delete properties on the current message.
`class` | `MuleMessageToByteArray` TODO
`class` | `ObjectArrayToString` `ObjectArrayToString` transformer is the opposite of StringToObjectArray - it simply converts Object[] to a String in which each element is separated by a configurable delimiter (default is a space).
`class` | `ObjectToByteArray` `ObjectToByteArray` converts serilaizable object to a byte array but treats `java.lang.String` differently by converting to bytes using the `String.getBytrs()` method.
`class` | `ObjectToInputStream` `ObjectToInputStream` converts Serializable objects to an InputStream but treats `java.lang.String`, `byte[]` and `org.mule.api.transport.OutputHandler` differently by using their byte[] content rather thqn Serializing them.
`class` | `ObjectToOutputHandler` `ObjectToOutputHandler` converts a byte array into a String.
`class` | `ObjectToString` `ObjectToString` transformer is useful for debugging.
`class` | `SerializableToByteArray` `SerializableToByteArray` converts a serializable object or a String to a byte array.
`class` | `StringAppendTransformer`
`class` | `StringToObjectArray` `StringToObjectArray` converts a String into an object array.

Uses of Initialisable in org.mule.transport

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

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

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

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

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

Uses of Initialisable in org.mule.transport.bpm

Classes in org.mule.transport.bpm that implement Initialisable
`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 Initialisable in org.mule.transport.bpm.jbpm

Classes in org.mule.transport.bpm.jbpm that implement Initialisable
`class` | `JBpmConnector`

Uses of Initialisable in org.mule.transport.ejb

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

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

Classes in org.mule.transport.email.transformers that implement Initialisable
`class` | `EmailMessageToString` `EmailMessageToString` extracts a java mail Message contents and returns a string.
`class` | `MimeMessageToRfc822ByteArray`
`class` | `ObjectToMimeMessage` Transforms a `Message` to a `MuleMessage`, with support for attachments
`class` | `Rfc822ByteArraytoMimeMessage`
`class` | `StringToEmailMessage` `StringToEmailMessage` will convert a String to a JavaMail Message, using the String as the contents.

Uses of Initialisable in org.mule.transport.file

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

Classes in org.mule.transport.file.transformers that implement Initialisable
`class` | `FileToByteArray` `FileToByteArray` reads the contents of a file as a byte array.
`class` | `FileToString` `FileToString` reads file contents into a string.

Uses of Initialisable in org.mule.transport.ftp

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

Uses of Initialisable in org.mule.transport.http

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

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

Uses of Initialisable in org.mule.transport.http.transformers

Classes in org.mule.transport.http.transformers that implement Initialisable
`class` | `HttpClientMethodResponseToObject` `HttpClientMethodResponseToObject` transforms a http client response to a DefaultMuleMessage.
`class` | `HttpRequestBodyToParamMap`
`class` | `HttpResponseToString` Converts an Http Response object to String.
`class` | `MuleMessageToHttpResponse` Converts a `MuleMessage` into an Http response.
`class` | `ObjectToHttpClientMethodRequest` `ObjectToHttpClientMethodRequest` transforms a MuleMessage into a HttpClient HttpMethod that represents an HttpRequest.
`class` | `ServletRequestToOutputHandler` Adds support for converting a `HttpServletRequest` into an `OutputHandler`

Uses of Initialisable in org.mule.transport.ibean

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

Uses of Initialisable in org.mule.transport.jbpm

Classes in org.mule.transport.jbpm that implement Initialisable
`class` | `Jbpm` jBPM's implementation of Mule's generic BPMS interface.

Uses of Initialisable in org.mule.transport.jdbc

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

Uses of Initialisable in org.mule.transport.jersey

Classes in org.mule.transport.jersey that implement Initialisable
`class` | `JerseyResourcesComponent` Wraps a set of components which can get invoked by Jersey.

Uses of Initialisable in org.mule.transport.jms

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

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

Uses of Initialisable in org.mule.transport.jms.mulemq

Classes in org.mule.transport.jms.mulemq that implement Initialisable
`class` | `MuleMQJmsConnector`
`class` | `MuleMQXAJmsConnector`

Uses of Initialisable in org.mule.transport.jms.transformers

Classes in org.mule.transport.jms.transformers that implement Initialisable
`class` | `AbstractJmsTransformer` `AbstractJmsTransformer` is an abstract class that should be used for all transformers where a JMS message will be the transformed or transformee object.
`class` | `JMSMessageToObject` `JMSMessageToObject` Will convert a `javax.jms.Message` or sub-type into an object by extracting the message payload.
`class` | `ObjectToJMSMessage` `ObjectToJMSMessage` will convert any object to a `javax.jms.Message` or sub-type into an object.

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

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

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

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

Uses of Initialisable in org.mule.transport.jnp

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

Uses of Initialisable in org.mule.transport.multicast

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

Uses of Initialisable in org.mule.transport.quartz

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

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

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

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

Classes in org.mule.transport.servlet.transformers that implement Initialisable
`class` | `HttpRequestToByteArray` Converts an `HttpServletRequest` into an array of bytes by extracting the payload of the request.
`class` | `HttpRequestToInputStream` Converts an `HttpServletRequest` into an `InputStream`.
`class` | `HttpRequestToParameter`
`class` | `HttpRequestToParameterMap` Returns a simple Map of the parameters sent with the HTTP Request.

Uses of Initialisable in org.mule.transport.soap.axis

Classes in org.mule.transport.soap.axis that implement Initialisable
`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.
`class` | `AxisServiceComponent` `AxisServiceComponent` is a Mule component implementation of the Axis servlet.

Uses of Initialisable in org.mule.transport.soap.axis.wsdl

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

Uses of Initialisable in org.mule.transport.ssl

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

Uses of Initialisable in org.mule.transport.stdio

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

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

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

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

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

Classes in org.mule.transport.xmpp.transformers that implement Initialisable
`class` | `ObjectToXmppPacket` Creates an Xmpp message packet from a MuleMessage
`class` | `XmppPacketToObject`

Uses of Initialisable in org.mule.util.pool

Subinterfaces of Initialisable 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 Initialisable
`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 Initialisable in org.mule.util.store

Classes in org.mule.util.store that implement Initialisable
`class` | `AbstractMonitoredObjectStore<T extends Serializable>` TODO
`class` | `InMemoryObjectStore<T extends Serializable>` `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.

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

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