Documentation

**Note:** this documentation is to be moved to symfony.com when merging the Component.


1. **Sender**

Responsible for serializing and sending the message to _something_. This something can be a message broker or a 3rd

party API for example.

2. **Receiver**

Responsible for deserializing and forwarding the messages to handler(s). This can be a message queue puller or an API

endpoint for example.

3. **Handler**

Given a received message, contains the user business logic related to the message. In practice, that is just a PHP

callable.

The bus is used to dispatch messages. MessageBus' behaviour is in its ordered middleware stack. When using

the message bus with Symfony's FrameworkBundle, the following middlewares are configured for you:

1. `LoggingMiddleware` (log the processing of your messages)

2. `SendMessageMiddleware` (enable asynchronous processing)

3. `HandleMessageMiddleware` (call the registered handle)

use App\Message\MyMessage;

$result = $this->get('message_bus')->handle(new MyMessage(/* ... */));

Once dispatched to the bus, messages will be handled by a "message handler". A message handler is a PHP callable

(i.e. a function or an instance of a class) that will do the required processing for your message. It _might_ return a

result.

namespace App\MessageHandler;

use App\Message\MyMessage;

class MyMessageHandler

{

public function __invoke(MyMessage $message)

{

// Message processing...

}

}

<service id="App\Handler\MyMessageHandler">

<tag name="message_handler" />

</service>

**Note:** If the message cannot be guessed from the handler's type-hint, use the `handles` attribute on the tag.

Using the Message Component is useful to decouple your application but it also very useful when you want to do some

asychronous processing. This means that your application will produce a message to a queuing system and consume this

message later in the background, using a _worker_.

The communication with queuing system or 3rd parties is for delegated to libraries for now. You can use one of the

following adapters:

- [PHP Enqueue bridge](https://github.com/sroze/enqueue-bridge) to use one of their 10+ compatible queues such as

RabbitMq, Amazon SQS or Google Pub/Sub.

- [Swarrot adapter](https://github.com/sroze/swarrot-bridge) to use Swarrot, a library specialised in consuming

messages from AMQP brokers such as RabbitMq.

- [HTTP adapter](https://github.com/sroze/message-http-adapter) to receive and send messages through HTTP APIs.

When doing asynchronous processing, the key is to route the message to the right sender. As the routing is

application-specific and not message-specific, the configuration can be made within the `framework.yaml`

configuration file as well:

framework:

message:

routing:

'My\Message\MessageAboutDoingOperationalWork': my_operations_queue_sender

If you want to do route all the messages to a queue by default, you can use such configuration:

Note that you can also route a message to multiple senders at the same time:

`WrapIntoReceivedMessage` received. It will wrap the received messages into `ReceivedMessage` objects and the

`SendMessageMiddleware` middleware will know it should not send these messages.

`ImportantAction` message going through the message bus and handled by a handler. Now, you also want to send this