Contact Free trial Login

Configuring Components

MuleSoft recommends against deployments to Mule 3.8. Standard Support for this version ended on November 16, 2018, and Mule 3.8 will reach its End of Life on November 16, 2021, when Extended Support ends.

Components contain the business logic for working with the messages passed through Mule Runtime. A component can be any type of object, including a Spring bean, POJO, script, web service, or REST call.

Because they are highly specific to your implementation, you typically create your own custom components, or simply use an existing POJO. Mule also ships with some standard components you can use or extend as needed. This page describes how to configure the different types of components.

For detailed information on the elements you configure for components, see Component Configuration Reference.

Simple Components

There are several simple components included with Mule that are useful for testing or bypassing component execution.

Configuration Element Description


Logs component invocations, outputting the received message as a string. This component does not return a response.


Extends the log component to log and echo the incoming message. The message is transformed before being returned, so transformations on inbound endpoints will be applied.


Throws an exception when invoked. This is useful for testing use cases that use a forwarding consumer inbound router.


Configures the Mule FunctionalTestComponent, which allows more complex testing scenarios to be created. For more information, see Functional Testing.

Java Components

Java components specify a Java class to be used as the component or configure a reference to an implementation in a container such as Spring. They also configure the way in which Mule should manage the Java component’s life-cycle, invoke it, and (if pooled) manage the pool of instances.

Java components can be configured quickly and easily by simply specifying the component implementation class name on the <component> or <pooled-component> element. The <pooled-component> element allows you to establish a pooling profile for the flow (see Tuning Performance). In both cases, the PrototypeObjectFactory is used by default and a new object instance is created for each request or (for pooled components) for each new object in the pool.

<component class=""/>
<pooled-component class=""/>

Alternatively, you can explicitly specify object factories, such as the SingletonObjectFactory that creates a single instance of the object:

     <singleton-object class=""/>

The explicit syntax is required instead of the shortcut <component class> syntax if you add interceptors to the component. For further configuration options and information on the default settings that are applied, see Configuring Java Components.

Customizing Behavior with Interceptors

Mule interceptors are useful for attaching behaviors to multiple components. The interceptor pattern is often referred to as practical AOP (Aspect Oriented Programming), as it allows the developer to intercept processing on an object and potentially alter the processing and outcome. For complete information, see Using Interceptors.


Components have a lifecycle like any other object in the Mule registry. Lifecycle can be configured by adding one or more lifecycle interfaces to your component. Since Mule 3.0 JSR-250 annotations can be used to configure initialize and destroy methods. The following list describes in order the lifecycle phases for component objects.

Lifecycle Description Interface Annotation


The first lifecycle method called once any injectors on the component have been called. This means any properties on the component are set before the initialize lifecycle is called.




This is called when the MuleContext is started.



This is called when the MuleContext is stopped.



Called as the object is being disposed off. Typically this happens because either the MuleContext is shutting down.



Lifecycle examples

Full Lifecycle implements, org.mule.api.lifecycle.Lifecycle
    public void initialise() throws InitialisationException { }

    public void start() throws MuleException { }

    public void stop() throws MuleException { }

    public void dispose() { }

Initialise-Only Lifecycle implements, org.mule.api.lifecycle.Initialisable
    public void initialise() throws InitialisationException { }

Initialise/Dispose Lifecycle

Use JSR-250 annotations: implements
    public void init() { }

    public void destroy() { }

Was this article helpful?

💙 Thanks for your feedback!

Edit on GitHub