This document discusses the key building blocks of Mule flows: - Messages entering flows can be validated, enriched, transformed, processed by custom logic, logged, and used to determine a response. - The main building blocks are optional message sources, message processors, message processing blocks, and endpoints. - Message sources receive incoming messages to trigger flow instances. Message processors perform actions like validation and transformation. Processing blocks combine multiple processors. Endpoints implement transport channels to insert and extract data.

1. Working with
Components

2. At the simplest level, Flows are sequences of message-processing
events. As the following schematic illustrates, a message that
enters a flow may be:
validated (filtered)
enriched (appended)
transformed into a new format
processed by custom-coded business logic
logged to a database
evaluated to determine what sort of response gets returned to
party that submitted the original message
Prudhvi

3. Sample Mule Flow :
Prudhvi

4. Flow Building Blocks :
The following sub-sections detail the various types of building
blocks (and processing blocks) that can populate a Mule Flow.
a. Message Source (Optional)
b. Message Processors
c. Message Processing Blocks
d. End Points
Prudhvi

5. Message Source (Optional)
The first building block in most Flows is a Message Source,
which receives messages from one or more external sources,
thus triggering a Flow instance. Each time it receives another
message, the Message Source triggers another Flow instance.
Prudhvi

6. Message Processors
Typically, these are pre-packaged units of functionality that process
messages in various ways. Except for Message Sources, all the building
blocks in a Flow qualify as Message Processors. Unlike the Mule Services
they have largely supplanted, Message Processors offer the following
advantages:
They don’t have to be connected to each other with routers, endpoints,
and VM queues in the rigid fashion required for Services
Multiple Message Processors can be combined into various structures that
provide the exact functionality you need for your application
Prudhvi

7. Message Processing Blocks
Mule provides several ways to combine multiple message
processors into functional processing blocks.
For instance, the Composite Source scope allows you to
embed into a single message source two or more inbound
endpoints, each one listening to a different transport channel.
Whenever one of these listeners receives an incoming
message, it triggers a flow instance and starts the message
through the message processing sequence.
Prudhvi

8. Endpoints
As previously mentioned, Endpoints implement transport
channels that facilitate the insertion or extraction of data
from Flows. Endpoints serve a diverse variety of roles,
depending on how they are configured. For example, they
can, as previously mentioned, serve as Inbound or Outbound
conduits. They can implement one-way or request-response
exchange patterns. And, in certain situations, you can embed
other types of message processors, such as transformers or
filters, into endpoints.
Prudhvi

9. THANK YOU
Prudhvi