|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
AbstractEventAggregator will aggregate a set of messages into a
single message.AbstractEndpointSecurityFilter provides a framework to perform inbound
or outbound authentication for messages.RouterCatchAllStrategy is a strategy interface that allows developers to hook in custom code when
an event is being routed on the inbound or outbound but does not match any of the criteria defined for the routing.Component to be used by all Component implementations.AbstractCompressionTransformer is a base class for all transformers
that can compress or uncompress data when they performa message transformation.ConfigurationBuilder implementations
that handles the logic of creating config arrays and Properties
argumentsAbstractConnector provides base functionality for all connectors
provided with Mule.AbstractCorrelationAggregatingMessageProcessor uses the CorrelationID
and CorrelationGroupSize properties of the MuleMessage to
manage message groups.MessageProcessor that dynamically chooses and uses
another MessageProcessorEncryptionTransformer will transform an array of bytes or string
into an encrypted array of bytesImmutableMuleEndpoint describes a Provider in the Mule Server.UrlEndpointURIBuilder is the default endpointUri strategy suitable for
most connectorsEntryPointResolver.EnvelopeInterceptor is an intercepter that will fire before and after
an event is received.InterceptingMessageProcessor that can be easily be extended and
used for filtering message flow through a MessageProcessor chain.FlowConstruct that:
Is constructed with unique name and MuleContext.InterceptingMessageProcessor that simply
provides an implementation of setNext and holds the next message processor as an
attribute.EntryPointResolverSet and ObjectFactory.LifecycleManager interface
and provides almost all the plumbing required to write a LifecycleManager
implementation.AbstractRouterCollection provides common method implementations of router collections for in
and outbound routers.AbstractMessageDispatcherFactory is a base implementation of the
MessageDispatcherFactory interface for managing the lifecycle of
message dispatchers.MessageProcessors and wraps the invocation of the chain in a composite
MessageProcessor.AbstractMessageReceiver provides common methods for all Message
Receivers provided with Mule.MessageRequesterFactory interface for managing the
lifecycle of message requesters.MessageSequence, that does not support
AbstractMessageSequence.remove()MuleMessage splitter, that converts its payload
in a MessageSequence, and process each element of it.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.AbstractMessageTransformer is a transformer that has a reference
to the current message.MuleModel is the default implementation of the Model.AbstractNotificationLoggerAgent Receives Mule server notifications
and logs them and can optionally route them to an endpoint.ObjectStore implementations that conforms to the
contract defined in the interface's javadocs.AbstractOutboundRouter is a base router class that tracks statistics about message processing
through the router.AbstractFlowConstruct that allows a list of MessageProcessors
that will be used to process messages to be configured.AbstractPollingMessageReceiver implements a base class for polling
message receivers.MessageReceiver implementations.AbstractRecipientList is used to dispatch a single event to
multiple recipients over the same transport.ConfigurationBuilder implementation used for
ConfigurationBuider's that use one of more configuration resources of the same
type that are defined using strings or ConfigResource objects.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.AbstractSecurityFilter provides basic initialisation for
all security filters, namely configuring the SecurityManager for this instanceConnectException.HtmlTablePrinter prints event processing stats as a HTML tableAbstractTransformer is a base class for all transformers.AnnotationInfo object be
accepted
MessageDispatching methods are invoked.
MessageDispatcherFactory.create(OutboundEndpoint).
MessageDispatching methods are invoked.
MessageRequesterFactory.create(org.mule.api.endpoint.InboundEndpoint).
MuleMessage.addOutboundAttachment(java.lang.String, javax.activation.DataHandler)
instead
MuleMessage.addProperties(java.util.Map, org.mule.api.transport.PropertyScope) instead
Agent is a server plugin that can be initialised, started and
destroyed along with the MuleContext itself.AllStatistics TODOAndFilter accepts only if all the filters
accept.#getName method to an objectMuleEvent's asynchronously using a MuleWorkManager to schedule asynchronous
processing of MessageProcessor delegate configured the next MessageProcessor.WorkManager to schedule the processing of the pipeline of message processors
in a single worker thread.RetryPolicyTemplate and will execute any retry work within a separate thread.MuleEvent's asynchronously using a MuleWorkManager to
schedule asynchronous processing of the next MessageProcessor.Authentication represents an authentication request and contains
authentication information if the request was successfulAuthenticationFilter is a base filter for authenticating messages.SecurityProviderInfo.Base64.InputStream will read data from another InputStream,
given in the constructor, and encode/decode to/from Base64 notation on the
fly.Base64.InputStream in DECODE mode.
Base64.InputStream in either ENCODE or DECODE mode.
Base64.OutputStream will write data to another OutputStream,
given in the constructor, and encode/decode to/from Base64 notation on the
fly.Base64.OutputStream in ENCODE mode.
Base64.OutputStream in either ENCODE or DECODE mode.
Base64Encoder transforms Base64 encoded data into strings or byte
arrays.Base64Encoder transforms strings or byte arrays into Base64 encoded
string.BatchConstraint is a filter that counts on every execution and
returns true when the batch size value equals the execution count.BeanUtils provides functions for altering the way commons BeanUtils
worksBlockingServerEvent is a marker interface that tells the server
event manager to publish this event in the current thread, thus blocking the
current thread of execution until all listeners have been processedMuleContext instance using configured builder instance.
MuleContext instance using configured builder instance.
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.ByteArrayToSerializable converts a serialized object to its object
representationMuleEvent using a CachingStrategy.MuleEvent using a cache.Callable is used to provide a Service with an interface that supports
event calls.Map.ChainedReader allows Reader objects to be chained together.ThreadingProfile.DEFAULT_THREADING_PROFILE
ChainingRouter is used to pass a Mule event through multiple
targets using the result of the first as the input for the second.MessageProcessor using a Filter
to evaluate the event being processed and find the first route that can be used.ClasspathScanner know if there was a
match on the class and whan the class was.MuleMessage.clearProperties(org.mule.api.transport.PropertyScope) instead
PropertyScope.INVOCATION and
PropertyScope.OUTBOUND.
Channel.
MessageSequence that retrieves elements from a Collection.CommonsPoolProxyPool is an implementation of ObjectPool
that internally uses the commons-pool GenericObjectPool and uses a
ObjectFactory for creating new pooled instances.Component component processes a MuleEvent by invoking the
component instance that has been configured, optionally returning a result.ComponentException should be thrown when some action on a component
fails, such as starting or stoppingComponentMessageNotificationListener is an observer interface that objects
can use to receive notifications about messages being processed by componentsMessageSources.CompressionStrategy implementation class to use, if no other
can be found.
CompressionException TODO documentCompressionHelper a static class that provides facilities for
compressing and uncompressing byte arraysCompressionStrategy is a base interface for Different compression
strategiesKeyedObjectPool.ConfigurableKeyedObjectPool instances.ConfigurationBuilder is used to configure a Mule instance,
represented by a MuleContext instance.ConnectionNotificationListener is an observer interface that
objects can implement and then register themselves with the Mule manager to be
notified when a Connection event occurs.ConnectionNotification each time a retry attempt is made.Connector is the mechanism used to connect to external systems
and protocols in order to send and receive data.ConnectorException Is thrown in the context of a Connector,
usually some sort of transport level error where the connection has failed.Throwable that
matches the specified class or subclass in the exception chain.
CorrelationPropertiesExpressionEvaluator is a default implementation used for
getting the Correlation information from a message.CorrelationSequenceComparator is a Comparator for
MuleEvents using their respective correlation sequences.CouldNotRouteOutboundMessageException thrown if Mule fails to route
the current outbound event.MuleMessage instance from transportMessage by extracting
its payload and, if available, any relevant message properties and attachments.
MuleMessage instance by extracting the payload from
transportMessage.
MuleMessage.getCorrelationGroupSize().
CreateException is thrown when creating an object inside Mule wasn't possible due
to inconsistent internal state or wrong input.DataType object from an object instance.
Message instance that is filled with the formatted
message with id code from the resource bundle bundlePath.
Message instance that is filled with the formatted
message with id code from the resource bundle bundlePath.
Message instance that is filled with the formatted
message with id code from the resource bundle bundlePath.
Message instance that is filled with the formatted
message with id code from the resource bundle bundlePath.
Message instance that is filled with the formatted
message with id code from the resource bundle bundlePath.
MuleContext is one exists, otherwise a
new MuleContext instance is created with defaults.
MuleContextBuilder provided.
MuleContextBuilder provided and
configures it with the list of configuration builder and c onfigures it with
configurationBuilder
MuleContextBuilder provided and
configures it with the list of configuration builders.
MuleContextBuilder provided and
configures it with the list of configuration builders.
MuleContextBuilder provided and
configures it with the list of configuration builder and c onfigures it with
configurationBuilder
MuleContext instance from the resource provided.
MuleContext instance from the resource provided.
MuleMessageFactory to create a new MuleMessage instance.
MuleMessageFactory to create a new MuleMessage instance.
MuleMessageFactory to create a new MuleMessage instance.
MuleMessageFactory using what's defined in the connector's
transport service descriptor.
MuleMessageFactory from this connector's configuration,
typically through the transport descriptor.
createMuleMessageFactory method to create
a new MuleMessageFactory.
MuleMessageFactory to create a new MuleMessage instance.
MessageProcessor that will process messages from the configured MessageSource
.
Message instance that is not read from a resource bundle.
Credentials holds credentials information for a user.CredentialsAccessor is a template for obtaining user credentials
from the current message and writing the user credentials to an outbound messageCredentialsNotSetException is thrown when user credentials cannot
be obtained from the current messageCryptoFailureException is a generic exception thrown by an
CryptoStrategy if encryption or decryption fails.CSVPrinter prints service stats in CSV formatCustomNotification Custom notifications can be used by components
and other objects such as routers, transformers, agents, etc to communicate a
change of state to each other.CustomNotificationListener is an observer interface that can be
used to listen for Custom notifications using
MuleContext.fireCustomEvent(..).DataType objects based on the parameter types passed into
the factory methods.DateUtils contains some useful methods dealing date/time
conversion, formatting etc.EncryptionTransformer will transform an encrypted array of bytes or
string into an decrypted array of bytesReloadControl.Always.
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.DefaultComponentLifecycleAdapterFactory creates a DefaultComponentLifecycleAdapter.ConfigurableKeyedObjectPool as a delegate of a KeyedPoolableObjectFactory
instance.ConfigurableKeyedObjectPoolFactory creating instances
of DefaultConfigurableKeyedObjectPool.EntryPointResolverSet
It resolves a method to call on the given service when an event is received.DefaultExceptionPayload TODOJavaComponent.LifecycleAdapter
instances for implementations of JavaComponent that require
LifecycleAdapter pooling such as PooledJavaComponent.MuleMessage type that manages a collection of MuleMessage Objects.MessageProcessors and wraps the invocation of the chain in a composite
MessageProcessor.MuleContextBuilder that uses DefaultMuleContext
as the default MuleContext implementation and builds it with defaults
values for MuleConfiguration, LifecycleManager, WorkManager,
WorkListener and ServerNotificationManager.DefaultMuleContextBuilder to build new
MuleContext instances.DefaultMuleEvent represents any data event occurring in the Mule environment.DefaultMuleEventContext is the context object for the current
request.MuleException Is the base exception type for the Mule application
any other exceptions thrown by Mule code will be based on this exception.DefaultMuleMessage is a wrapper that contains a payload and properties
associated with the payload.DefaultMuleSession manages the interaction and distribution of events for
Mule Services.DefaultOutboundRouterCollection is a container of routers.DefaultReplyToHandler is responsible for processing a message
replyTo header.ResponseGenerator creating a new MuleEvent
for each request.SecurityContext implementation which simply holds the Authentication object.StreamCloser's
from the Mule registry.BeanUtils.describe(Object) except that it will only populate bean properties where there is a valid
getter and setter method.
false for
MessageDispatcherFactory.validate(OutboundEndpoint, MessageDispatcher).
false for
MessageRequesterFactory.validate(org.mule.api.endpoint.InboundEndpoint, org.mule.api.transport.MessageRequester).
DispatchException is thrown when an endpoint dispatcher fails to
send, dispatch or receive a message.Disposable is a lifecycle interface that gets called at the dispose
lifecycle stage of the implementing service as the service is being destroyed.Disposable interface.
DisposeException TODO (document class)EchoComponent will log the message and return the payload back as
the result.EncryptionNotSupportedException is thrown if an algorithm is set in
the MULE_USER header but it doesn't match the algorithm set on the security filterEncryptionStrategy can be used to provide different types of
Encryption strategy objects.EncryptionStrategyNotFoundException is thrown by the
SecurityManager when an encryption scheme is set in a property or header that
has not been registered witrh the managerEncryptionTransformer will transform an array of bytes or string
into an encrypted array of bytesEndpointException is an abstract exception extended by endpoint
specific exceptions.ImmutableEndpoint.EndpointMessageNotificationListener is an observer interface that objects
can use to receive notifications about messages being sent and received from endpointsEndpointNotFoundException is thrown when an endpoint name or
protocol is specified but a matching endpoint is not registered with the Mule
serverEndpointAbstractEventLoggerAgent will forward server notifications
to a configurered endpoint uri.EndpointSelector selects the outgoing endpoint based on a
an expression evaluator ("header:endpoint" by default).EndpointURI is used to determine how a message is sent or
received.EndpointBuilder determines how a uri is translated to a
MuleEndpointURI Connectors can override the default behaviour to suit their needsEntryPoint defines the current entry method on a service.DefaultEntryPointResolverSet if after trying
all entrypointResolvers it cannot fin the entrypoint on the service serviceEntryPointResolver resolves a method to call on the given
Component when an event is received for the service.EntryPointResolver resolves a method to call on the given
service object when an event is received.EqualsFilter is a filter for comparing two objects using the
equals() method.EventGroup is a holder over events grouped by a common group Id.EventListener is a marker interface that is implemented by
objects wishing to receive Mule events in managed environments, such as an EJB
container.EventTimerTask is a task that causes TimeEvent to be fired to
listening objects when a specific number of milliseconds have passed.ExceptionBasedRouter Will send the current event to the first
endpoint that doesn't throw an exception.ExceptionHelper provides a number of helper functions that can be
useful for dealing with Mule exceptions.ExceptionMessage is used by the DefaultServiceExceptionStrategy
for wrapping an exception with a message to send via an endpointUri.ExceptionNotificationListener is an observer interface that
objects can implement and then register themselves with the Mule manager to be
notified when a Exception event occurs.ExceptionPayload is a message payload that contains exception
information that occurred during message processing.Expirable implementing classes can be notified when they expireExpiryMonitor can monitor objects beased on an expiry time and can
invoke a callback method once the object time has expired.ExpressionEnricher enriches a message using the extensible mule
expression framework allowing the contribution of additional enrichers.DefaultExpressionManager so that they will
be resolved at run-time.ExpressionEvaluator extracts a property from the message in a generic
way.DefaultExpressionManager so that they will
be resolved at run-time.KeyGenerator using the Mule expression language to
generate the cache keys.DefaultExpressionManager if an expression returns null
and failIfNull was set when ExpressionManager.evaluate(String,org.mule.api.MuleMessage,boolean)
was called.ExternalTransactionAwareTransactionFactory creates a transaction, possibly representing a transaction
started outside Mule.ExternalXaTransaction represents an external XA transaction in Mule.FailedToQueueEventException is thrown when an event cannot be put on
an internal service queue.FatalException can be thrown during initialisation or during
execution to indicate that something fatal has occurred and the MuleManager must
shutdown.FileUtils contains useful methods for dealing with files &
directories.Filter interface allows MuleMessage filtering.FilteringRouter is a router that accepts events based on a filter
set.CustomNotificationListener notificationManager.
ExceptionNotificationListener
eventManager.
TransactionNotificationListeners.
AbstractPipeline adds the following functionality:
Rejects inbound events when Flow is not started
Gathers statistics and processing time data
Implements MessagePorcessor allowing direct invocation of the pipeline
Supports the optional configuration of a ProcessingStrategy that determines how message
processors are processed.FlowConstruct that once implemented and configured defines a construct
through which messages are processed using MessageSource and MessageProcessor building
blocks.FlowConstruct to be injected.FlowConstructNotification is fired when an event such as the flow
construct starting occurs.ForwardingCatchAllStrategy acts as a catch and forward router for
any events not caught by the router this strategy is associated with.FutureMessageResult is an MuleMessage result of a remote invocation
on a Mule Server.RetryContext to be used when a RetryPolicyTemplate is
executed in a separate thread via the AsynchronousRetryTemplate.MuleMessage.getInboundAttachment(String) instead
MuleMessage.getInboundAttachmentNames()
MuleMessage.getInboundProperty(String, Object) instead
META-INF/services/org/mule/i18n/<bundleName>-messages.properties) from
bundleName.
Service for each incoming
MuleEvent routed on by the inbound routers.
MuleMessage.getInboundProperty(String, Object) instead
EndpointFactory for creation/lookup of individual endpoints instead
JavaComponent can have a custom entry-point resolver for its own
object.
ReflectionEntryPointResolver.addIgnoredMethod(String)
MuleMessage.getInboundProperty(String, Object) instead
MuleMessage.getInboundProperty(String, Object) instead
KeyedObjectPool.borrowObject(java.lang.Object) method should block before throwing
an exception when the pool is exhausted and the
"when exhausted" action is
ConfigurableKeyedObjectPool.WHEN_EXHAUSTED_BLOCK.
SplitMessage instance and for
each part can associate an endpoint.
URI of the MessageSource that recieved or generated the message being processed.
InvocationResult.State.SUCCESSFUL
MuleMessageFactory lazily and holds a reference to it for
others to use.
AbstractConnector.isCreateMultipleTransactedReceivers() returns true.
null if they cannot be determined.
null if they cannot be determined.
MuleMessage.getPayload(Class) call to every message in the collection and returns a
List of results.
MuleMessage.getPropertyNames(org.mule.api.transport.PropertyScope)
DefaultMuleMessage.getPropertyNames(org.mule.api.transport.PropertyScope)
MessagePropertiesContext.getPropertyNames(org.mule.api.transport.PropertyScope)
Transformer.getReturnDataType() instead.
TransportServiceDescriptor for this connector.
Transformer.getSourceDataTypes() instead
code from the resource bundle.
code from the resource bundle.
code from the resource bundle.
MuleMessage.getInboundProperty(String, Object) instead
KeyedObjectPool.borrowObject(java.lang.Object) method
is invoked when the pool is exhausted.
GZipCompression is a CompressionStrategy implementation using the
GZip library included in the JDK java.util.zip.GZipCompressTransformer is a transformer compressing objects into
byte arrays.GZipCompressTransformer will uncompress a byte[] or InputStreamEventGroup.getGroupId().
HtmlTablePrinter prints event processing stats as a HTML tableIdempotentMessageFilter ensures that only unique messages are passed
on.IdempotentSecureHashMessageFilter ensures that only unique messages are
received by a service.ObjectUtils.identityToString(Object) but without the object's full package
name.
IllegalTransactionStateException TODO (document class)ImmutableEndpoint describes a Message endpoint where data is
sent or received.MuleProperties.MULE_ORIGINATING_ENDPOINT_PROPERTY.EndpointMessageNotification's when a message is received.TransportServiceDescriptor This
will be called before the AbstractConnector.doInitialise() method is called.
Initialisable is a lifecycle interface that gets called at the
initialise lifecycle stage of the implementing service.InitialisationCallback is used to provide customised initialiation
for more complex components.InitialisationException is thrown by the initialise method defined
in the org.mule.api.lifecycle.Initialisable interface.Initialisable interface.
TransportFactory the endpoint used to
determine the connector type is passed to this method so that any properties
set on the endpoint that can be used to initialise the connector are made
available.
MuleMessageFactory instead
of re-using the instance from the connector.
AbstractConnector.start() is called.
MuleContextAware
InMemoryObjectStore implements an optionally bounded
in-memory store for message IDs with periodic expiry of old entries.MuleEvent's intercepting another listener
MessageProcessor.Interceptor is based on a similar concept of servlet filters and
works much the same way.EntryPointResolverEntryPointResolver instances registered on this set until
a match is found
InvokerMessageProcessor invokes a specified method of an object.MessageDispatcherFactory.isCreateDispatcherPerRequest() returns
false, which means that dispatchers are pooled according to
their lifecycle as described in MessageDispatcher.
AbstractConnector.getNumberOfConcurrentTransactedReceivers().
MessageDispatcherFactory.isCreateDispatcherPerRequest() returns
false, which means that dispatchers are pooled according to
their lifecycle as described in MessageRequester.
AbstractConnector.start() is called.
RetryContext.getLastFailure() may return null.
TlsConfiguration) then this flag will
control whether client authenticatin is required.
Transformer.isSourceDataTypeSupported(org.mule.api.transformer.DataType) instead
AbstractTransformer.isSourceDataTypeSupported(org.mule.api.transformer.DataType, boolean)
MessageSequence that delegates its IteratorMessageSequence.hasNext() and
IteratorMessageSequence.next() methods to an Iterator, and has no estimated sizeJavaComponent is a Java Component implementation used to
invoke Java component implementations.KeyedPoolMessageDispatcherFactoryAdapter adapts a
MessageDispatcherFactory with methods from commons-pool
KeyedPoolableObjectFactory.KeyedPoolMessageRequesterFactoryAdapter adapts a
MessageRequesterFactory with methods from commons-pool
KeyedPoolableObjectFactory.MuleEvent instances.MuleEvent's asynchronously using a MuleWorkManager to schedule asynchronous
processing of the next MessageProcessor.EntryPointResolverSet that mimics the behaviour of the Mule 1.x
DynamicEntryPointResolver.SerializeAndEncodeSessionHandler or SerializeOnlySessionHandler instead.DefaultLifecyclePhase adds lifecycle methods start,
stop and dispose.Registry.registerObject(String, Object, Object) method to have lifecycle
method calls on the registered objects omitted.
LifecycleAdapter is a wrapper around a pojo service that adds
Lifecycle methods to the pojo.LifecycleAdapterFactory TODO (document class)LifecycleManager
The callback is used so that transitions can be managed consistently outside of an objectLifecycleException TODOService or
Connector should implement this interface so that the registry lifecycle
manager can introspect the lifecycle state of an object.TransientRegistry where the object registered
implements MuleContextAware.MessageProcessor chain used to process messages once the transport
specific MessageReceiver has received transport message and created
the MuleEvent
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.LocaleMessageHandler is essentially a merging of the Message
and Messages classes, since there is no good reason to have them separate.MuleClient adding methods that allow the use of an endpoint
instance.AbstractNotificationLoggerAgent Receives Mule server notifications
and logs them and can optionally route them to an endpointLogComponent simply logs the content (or content length if it is a
large message)LoggingCatchAllStrategy is a simple strategy that only logs any
events not caught by the router associated with this strategy.LoggingInterceptor is a simple interceptor that logs a message before
and after the event processing.MuleContext.getEndpointFactory() instead
MuleRegistry.lookupTransformer(org.mule.api.transformer.DataType, org.mule.api.transformer.DataType) instead
MuleRegistryHelper.lookupTransformer(org.mule.api.transformer.DataType, org.mule.api.transformer.DataType) instead. This
method should only be used internally to discover transformers, typically a user does not need ot do this
directly
MuleRegistry.lookupTransformers(org.mule.api.transformer.DataType, org.mule.api.transformer.DataType) instead
Transformer objects that accept the given
input and return the given output type of object
MuleRegistryHelper.lookupTransformer(org.mule.api.transformer.DataType, org.mule.api.transformer.DataType) instead. This
method should only be used internally to discover transformers, typically a user does not need ot do this
directly
Transformer objects that accept the given
input and return the given output type of object
MalformedEndpointException is thrown by the MuleEndpointURI class
if it fails to parse a UrlManagementNotification is fired when monitored resources such as
internal queues reach capacityManagementNotificationListener is an observer interface that
objects can use to receive notifications about the state of the Mule instance and
its resourcesManualConstraint always returns false, meaning that the transaction
should be committed manually.MapLookup looks up and returns an object from a Map based on a key.AbstractTransformer.getReturnClass() and populates values of a
Map as bean properties on the object.PropertiesUtils.registerMaskedPropertyName(String).
MatchableMessageProcessors.KeyGenerator applying an MD5 digest to the event's
message payload.MessageDispatching with
various lifecycle methods for the actual instances doing message sending.MessageDispatcherFactory is a factory interface for managing the
lifecycles of a transport's message dispatchers.InterceptingMessageProcessor that filters message flow using a Filter.MuleEvent's.MessageProcessor instances.MessageProcessorChain instances.MessagePropertyFilter can be used to filter against properties on
an event.MessageReceiver is used to receive data from an external system.MessageRequesting with
various lifecycle methods for the actual instances doing message sending.MessageProcessor that routes messages to zero or more destination
message processors.MessageProcessor.MessageTypeNotSupportedException is thrown when a MuleMessage instance is
to be created with an payload type that is not of supported type by that
MuleMessageFactory.MessagingException is a general message exception thrown when
errors specific to Message processing occur..MuleProperties.MULE_METHOD_PROPERTY
property on the incoming event to determine which method to invoke Users can customise the name
of the property used to look up the method name on the eventModel encapsulates and manages the runtime behaviour of a
Mule Server instance.Model implementationsModelNotification is fired when an event such as the model starting
occurs.ModelNotificationListener is an observer interface that objects can
implement and then register themselves with the Mule manager to be notified when a
Model event occurs.ModelServiceDescriptor describes the necessery information for
creating a model from a service descriptor.MuleContext.MuleContextException is thrown when an exception occurs with Mule Context
objectsMuleContext.RegistryLifecycleManager and will
invoke lifecycle on the registry instance for the MuleContext.MuleContextNotification is fired when an event such as the mule
context starting occurs.MuleContextNotificationListener is an observer interface that objects
can implement and then register themselves with the Mule manager to be notified
when a Manager event occurs.TransientRegistry where the object registered
implements MuleContextAware.MuleCredentials can be used to read and set Mule user information
that can be stored in a message header.MuleEncryptionEndpointSecurityFilter provides password-based
encryptionMuleEndpointURI is used to determine how a message is sent or received.MuleEvent represents any data event occuring in the Mule
environment.MuleEventContext is the context object for the current request.MuleException is the base exception type for the Mule server any
other exceptions thrown by Mule code will be based on this exception,MuleHeaderCredentialsAccessor obtains and sets the user credentials
as Mule property headers.Log wrapper that supports boilerplate logging for high impact messagesMuleMessage represents a message payload.MuleMessage available through it.MuleMessageFactory is a factory for creating a MuleMessage from a transport's
native message format (e.g.MuleMessage instances
MessageInfoMapping that simply
grabs the message information from the MuleMessage untouched.MuleProperties is a set of constants pertaining to Mule properties.MuleRuntimeException Is the base runtime exception type for the
Mule Server any other runtimes exceptions thrown by Mule code will use or be based
on this exception.MuleSecurityManager is a default implementation security manager
for a Mule instance.MuleServer is a simple application that represents a local Mule
Server daemon.MuleSession is the context in which a request is executed.MuleTransactionConfig defines transaction configuration for a
transactional endpoint.MuleWorkManager is a JCA Work manager implementation used to manage
thread allocation for Mule components and connectors.Multicaster is a utility that can call a given method on a
collection of objects that implement one or more common interfaces.MulticastingRouter will broadcast the current message to every endpoint
registered with the router.NamedObject.getName() and NameableObject.setName(java.lang.String) methods to an objectNamedObject.getName() method to an objectNoReceiverForEndpointException is thrown when an enpoint is
specified for a receiver but no such receiver exists.NoSatisfiableMethodsException is thrown by EntryPointResolvers when
the service passed has no methods that meet the criteria of the configured
EntryPointResolver.NotFilter accepts if the filter does not accept.ServerNotificationListener instances with the MuleContext
to receive notificationsNotPermittedException is thrown if the user isn't authorized
to perform an action.NullComponent is a service that is used as a placeholder.NullLifecycleAdapter is a lifecycle adaptor implementation that
performs no Mule lifecycle propagation to Mule service component implementations.NullPayload represents a null event payloadNumberToString converts a Number to a String.NumberUtils contains useful methods for manipulating numbers.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).ObjectFactory is a generic Factory interface.ObjectPool is a simple pooling interface for objectsCachingStrategy using an ObjectStore as a cache.ObjectStore.ObjectStore's system fails.ObjectToByteArray converts serilaizable object to a byte array but
treats java.lang.String differently by converting to bytes using
the String.getBytrs() method.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.ObjectToOutputHandler converts a byte array into a String.ObjectToString transformer is useful for debugging.OrFilter accepts if any of the filters accept the messageMuleMessage instance to allow access to outbound
attachments from within components and transformers without the these objects needing access to the Mule MessageMuleProperties.MULE_ENDPOINT_PROPERTY.MuleMessage instance to allow access to outbound
headers from within components and transformers without the these objects needing access to the Mule MessageEndpointMessageNotification's when a message is sent or dispatched.OutboundPassThroughRouter allows outbound routing over a single
endpoint without any filtering.OutboundEndpoint.getResponseProperties().OutboundRouter is used to control outbound routing behaviour for an
event.RouterCatchAllStrategy is a strategy interface that allows developers to hook in custom code when
an event is being routed on the inbound or outbound but does not match any of the criteria defined for the routing.RouterCollection defines the interface for a MessageRouter that
manages more than one router.-Dkey=value
format.
PassThroughComponent will simply return the payload back as the
result.Pausable.pause() method on an object.PayloadTypeFilter filters based on the type of the object received.MessageProcessor's that are invoked in order to processor new
messages received from it's MessageSourcePooledJavaComponent implements pooling.LifeCycleAdaptorFactory wraps the Component' s
ObjectFactory.PoolingProfile is a configuration object used to define the object
pooling parameters for the service it is associated with.AbstractReceiverWorker.handleResults(java.util.List))
Preferred annotation.MessageExchangePattern
MessageExchangePattern
MuleEvent using a caching schema.
MapUtils.toString(Map, boolean) instead
PropertiesHelper is a utility class for manipulating and filtering
property Maps.PropertyEditorTextToValueTransformer adapts a PropertyEditor
instance allowing it to be used to transform from a String to another type in MulePropertyEditorValueToTextTransformer adapts a PropertyEditor
instance allowing it to be used to transform from a specific type to a String.PropertyFactory is used to create objects from the property file.PropertyScope instances in a map.Queue TODOQueueManager to decouple receipt and processing of messages.QueueManager to decouple the processing of each message processor.ObjectStore implementation that is to be used to persist
messages on Mule's internal queues.QueueProfile determines how an internal queue for a service will
behaveBase64.InputStream.read() repeatedly until the end of stream is reached or
len bytes are read.
ReceiveException is specifically thrown by the Provider receive
method if something fails in the underlying transportRecoverableException can be thrown during initialisation to
indicate that the error occurred is not fatal and a reactive action can be
performed to try and remedy the error.ReflectEntryPointResolver is used to determine the entry point on a service
after an event has been received for it.RegExFilter is used to match a String argument against a regular expression.HashMap view of values stored in the registryRegistryNotification is fired when an event such as a Registry
being started occurs.RegistryNotificationListener is an observer interface that objects
can implement and then register themselves with the MuleContext to be notified
when a Registry event occurs.MuleMessage.removeOutboundAttachment(java.lang.String) instead
MuleMessage.removeProperty(String, org.mule.api.transport.PropertyScope)
StringUtils.repeat(String, int) but with a single character as argument.
ReplyToHandler is used to handle routing where a replyTo endpointUri is
set on the messageRequestContext is a thread context where components can get the
current event or set response properties that will be sent on the outgoing
message.MuleEvent's by invoking the next MessageProcessor and
then rather than returning the result to this processors MessageSource
sending it via a seperate reply MessageProcessor,MuleEvent by invoking the next MessageProcessor but
receiving the reply, which is turn is returned from this MessageProcessor from a
seperate MessageSource rather than using the return value of the
next MessageProcessor invocation.ResequenceMessagesCorrelatorCallback.aggregateEvents(org.mule.routing.EventGroup) method only resequences
the events and returns an MuleEvent[] wrapped in a MuleMessage impl.Resequencer is used to resequence events according to their dispatch
sequence in the correlation group.ResourceNameEndpointBuilder extracts a resource name from a uri
endpointUriMuleEvent responses from an request event and a previously
cached response.ResponseOutputStream is an output stream associated with the
currently received event.ResponseTimeoutException is thrown when a response is not received
in a given timeout in the Response Router.SimpleRetryPolicyTemplate but will retry an infinite amount of times.PolicyStatus
which indicates whether the policy is exhausted or should continue to retry.RetryPolicy instance each time the retry goes into effect,
thereby resetting any state the policy may have (counters, etc.)
A RetryNotifier may be set in order to take action upon each retry attempt.Work implementation used when executing a RetryPolicyTemplate in a separate
thread.AbstractTransformer.transform(java.lang.Object) method is
called
RoutePathNotFoundException is thrown if a routing path for an event
cannot be found.RouterStatistics TODORoutingException is a base class for all routing exceptions.RoutingNotificationListener is an observer interface that objects
can use to receive notifications about routing events such as async-reply misses.AbstractReceiverWorker.release() once AbstractReceiverWorker.doRun() completes.
SecretKeyEncryptionStrategy.SecurityContext holds security information and is associated
with the MuleSession.SecurityContextFactory is responsible for creating a
SecurityContext instance.SecurityException is a generic security exceptionSecurityFilter is a base filter for secure filtering of
inbound and outbound event flow.SecurityFilter.SecurityManager is responsible for managing one or more
security providers.SecurityNotification is fired when a request for authorisation failed.MuleContextNotificationListener is an observer interface that objects
can implement to receive notifications about secure access requests.SecurityProvider is a target security provider that actually does the work of authenticating
credentials and populating the Authentication object.SecurityProviderNotFoundException is thrown by the
SecurityManager when an authentication request is made but no suitable security
provider can be found to process the authenticationMuleEvent's asynchronously using a MuleWorkManager to schedule asynchronous
processing of the next MessageProcessor.Iterator.
MessageProcessors using a Filter to
evaluate the event being processed and determine if a given route should be used.AbstractSequenceRouter that stops the routing of a given
message when a synchronous endpoint has returned a null or an exception
message.SerializableToByteArray converts a serializable object or a String
to a byte array.ServerNotification is an event triggered by something happening in
the Server itself such as the server starting or a service being registered.ServerNotificationListener is an observer interface that ojects
can implement and register themselves with the Mule Server to receive
notifications when the server, model and components stop, start, initialise, etc.Service is the internal representation of a Mule Managed service.StartableCompositeMessageSource which adds message processors between the composite
source and the target listenerServiceAware is an injector interface that will supply a
Service to the object.StartableCompositeMessageSource which adds message processors between the composite
source and the target listenerServiceFinder can be used as a hook into the service lookup process to
return the correct Service Descriptor for a given service name.ServiceNotification is fired when an event such as the service
starting occurs.ServiceNotificationListener is an observer interface that objects
can implement and then register themselves with the Mule manager to be notified
when a Service event occurs.SessionException is thrown when errors occur in the DefaultMuleSession or
Seession ManagerMuleMessage.setOutboundProperty(String, Object) instead
Service for each incoming
MuleEvent routed on by the inbound routers.
GenericKeyedObjectPool.setMaxWait(long)
GenericKeyedObjectPool.setWhenExhaustedAction(byte)
MuleMessage.setOutboundProperty(String, Object) instead
JavaComponent can have a custom entry-point resolver for its own
object.
InvocationResult.State.SUCCESSFUL
AbstractConnector.start() is called.
MuleMessage.setOutboundProperty(String, Object) instead
MuleMessage.setOutboundProperty(String, Object) instead
KeyedObjectPool.borrowObject(java.lang.Object) method should block before throwing
an exception when the pool is exhausted and the
"when exhausted" action is
ConfigurableKeyedObjectPool.WHEN_EXHAUSTED_BLOCK.
MuleMessage.setProperty(String, Object, org.mule.api.transport.PropertyScope) or
preferrably any of the scope-specific set methods.
DefaultMuleMessage.setProperty(String, Object, org.mule.api.transport.PropertyScope) or
preferrably any of the scope-specific set methods.
MessagePropertiesContext.setProperty(String, Object, org.mule.api.transport.PropertyScope)
GenericKeyedObjectPool.setMaxWait(long)
GenericKeyedObjectPool.setWhenExhaustedAction(byte)
TlsConfiguration) then this flag will
control whether client authenticatin is required.
Transformer.setReturnDataType(DataType) instead
MuleMessage.setOutboundProperty(String, Object) instead
KeyedObjectPool.borrowObject(java.lang.Object) method
is invoked when the pool is exhausted.
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.ObjectFactory can be set but must return object
instances that implement Callable.Callable
MuleMessageCollection.LifecycleManager implementation is designed to track the lifecycle of objects
that support the Initialisable.PHASE_NAME, Startable.PHASE_NAME,
Stoppable.PHASE_NAME and Disposable.PHASE_NAME phases and
adds convenience methods for firing these phases by callbacks.SimplePrinter Default stats printerregistry-bootstrap.properties into the local registry.SocketEndpointBuilder builds an endpointUri based on host and port
onlyobjects before the
lifecycle method is applied to them.
StringUtils.split(String, String), but
additionally trims whitespace from the result tokens.
MessageSequence that will retrieve each of
the event elements
Startable interface.
AbstractTransportMessageHandler.connect() if it is
needed.
Startable provides an object with a Startable.start() method
which gets called when the Mule instance gets started.CompositeMessageSource that propagates both injection of FlowConstruct
and lifecycle to nested MessageSources.DisposeException TODO (document class)StaticRecipientList is used to dispatch a single event to multiple
recipients over the same transport.Statistics TODOStoppable interface.
MuleContext which stops all sessions and
connectors
DisposeException TODO (document class)Stoppable is a lifecycle interfaqce that introduces a Stoppable.stop() method to an object.ByteArrayToSerializable converts a serialized object to its object
representationStringToNumber converts a String to a Number.StringToObjectArray converts a String into an object array.StringUtils contains useful methods for manipulating Strings.TemplateParser is a simple string parser that will substitute
tokens in a string with values supplied in a Map.WorkManager to schedule the processing of each message processors in a new
worker thread.TimeEvent TODO is an event that occurs at a specified number of
milliseconds.TimeEventListener provides a method to pass timer events to
implementing objects.TimerInterceptor simply times and displays the time taken to process
an event.TlsConfiguration to and from Properties (typically System Properties).TlsConfiguration
that has been stored via TlsPropertiesMapper.Class as
element type.
Class as element type.
IOUtils' toByteArray(InputStream)
method but catches any IOException and wraps it into a RuntimeException.
TooManySatisfiableMethodsException is thrown by EntryPointResolvers
when the service passed has more than one method that meets the criteria of the
configured EntryPointResolver.ArrayUtils.toString(Object) but considers at most maxElements
values; overflow is indicated by an appended "[..]" ellipsis.
CollectionUtils.toString(Collection, int, boolean) with false
for newline.
IOUtils' toString(InputStream)
method but catches any IOException and wraps it into a RuntimeException.
TransactedPollingMessageReceiver.TransactedPollingMessageReceiver(Connector, FlowConstruct, InboundEndpoint)
instead
MessageProcessor with a transaction.TransactionConfig defines transaction configuration for a
transactional endpoint.TransactionException is thrown when an exception occurs while
trying to create, start commit or rollback an exceptionTransactionFactory creates a transaction.TransactionInProgressException is thrown if a new transaction is
started when there is one already in progress.TranactionManagerFactory is a factory class for creating a
transaction manager for the MuleServer.TransactionNotificationListener is an observer interface that objects
can implement and then register themselves with the Mule manager to be notified
when a Transaction event occurs.TransactionNotInProgressException TODO (document class)Transformer can be chained together to covert message payloads
from one object type to another.TransformerException is a simple exception that is thrown by
transformers.TransformerResolver.transformerChange(Transformer, RegistryAction) method.Transformer instance, an input class and output class
this object will create a weighting for a transformer.MuleEvent.transformMessage(org.mule.api.transformer.DataType) instead
MuleEventContext.transformMessage(org.mule.api.transformer.DataType) instead
DefaultMuleEvent.transformMessage(org.mule.api.transformer.DataType) instead
DefaultMuleEventContext.transformMessage(org.mule.api.transformer.DataType) instead
TransportFactory can be used for generically creating endpoints
from an url.TransportFactoryException is thrown by the endpoint factory if the
endpoint service cannot be found in the META-INF/services directory or if any part
of the endpoint cannot be instanciated.TransportServiceDescriptor describes the necessary information for
creating a connector from a service descriptor.TransportServiceException is thrown if a ProviderServicedescriptor
has a service error set.TransportServiceNotFoundException is thorown if no matching service
endpoint descriptor is found for the connector protocol.MessageProcessor that should be used to handle messages that are not accepted by the filter.
UnauthorisedException is thrown if authentication failsUnknownAuthenticationTypeException is thrown if a security context
request is make with an unrecognised Authentication type.AbstractPollingMessageReceiver.schedule().
UnsupportedAuthenticationSchemeException is thrown when a
authentication scheme is being used on the message that the Security filter does
not understandEndpointURIBuilderUrlEndpointURIBuilder is the default endpointUri strategy suitable for
most connectorsUserInfoEndpointBuilder builds an endpoint with the userinfo and
host details.UUID Generates a UUID using the Safehaus UUID generator
rather than the built-in version of JDK5.MessageDispatcherFactory.passivate(OutboundEndpoint, MessageDispatcher).
MessageRequesterFactory.passivate(org.mule.api.endpoint.InboundEndpoint, org.mule.api.transport.MessageRequester).
WildcardFilter is used to match Strings against wildcards.WireTap MessageProcessor allows inspection of messages in a flow.WorkerContext TODOWorkExecutor TODOWorkManager extends the standard JCA WorkManager with lifecycle
methods and util.concurrent bridging.Base64.OutputStream.write(int) repeatedly until len bytes are
written.
XaTransaction represents an XA transaction in Mule.XaTransactionFactory Is used to create/retrieve a Transaction from
a transaction manager configured on the MuleManager.XMLPrinter prints event processing stats as a XML document
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||