Symfony Messenger (Symfony Live San Francisco)

Symfony Messenger
Bus, Queues, workers and more !

Samuel Rozé
VP Engineering @ Birdie
Symfony
Con(nuousPipe
Tolerance

What's Symfony Messenger about?
1. Messages. Any serialisable PHP object.
2. Message bus. Where you dispatch your messages.
3. Message handlers. Will execute your business logic when the
message arrives to them.
4. Transports. Allow to send and receive messages through 3rd
party systems.
5. Worker. To consume messages from transports.

$ composer req symfony/messenger
or composer req messenger

A message
No speciﬁc requirement.
namespace AppMessage;
class SendNotification
{
// ...properties
public function __construct(string $message, array $users)
{
$this->message = $message;
$this->users = $users;
}
// ...getters
}

As a component
use SymfonyComponentMessengerMessageBus;
use SymfonyComponentMessengerHandlerLocator;
use SymfonyComponentMessengerMiddlewareHandleMessageMiddleware;
$handler = function(SendNotification $message) {
// ...
};
$messageBus = new MessageBus([
new HandleMessageMiddleware(new HandlerLocator([
SendNotification::class => $handler,
])),
]);

In your Symfony applica0on
Nothing to do...

Dispatching a message
namespace AppController;
use AppMessageSendNotification;
// ...
use SymfonyComponentMessengerMessageBusInterface;
class DefaultController
{
public function index(MessageBusInterface $bus, Request $request)
{
$users = ['samuel', 'christelle'];
$bus->dispatch(new SendNotification(
$request->query->get('message', 'Hello London.'),
$users
));
return new Response('<html><body>OK.</body></html>');
}
}

A message handler
namespace AppMessageHandler;
class SendNotificationHandler
{
public function __invoke(SendNotification $message)
{
foreach ($message->getUsers() as $user) {
echo "Send notification to... ".$user."n";
}
}
}

Register your handler
# config/services.yaml
services:
AppMessageHandlerSendNotificationHandler:
tags: ['messenger.message_handler']

Register your handlers (op3on 2)
services:
AppMessageHandler:
resource: '../src/MessageHandler/*'
tags: ['messenger.message_handler']

use SymfonyComponentMessengerHandlerMessageHandlerInterface;
class SendNotificationHandler implements MessageHandlerInterface
{
public function __invoke(SendNotification $message)
{
foreach ($message->getUsers() as $user) {
echo "Send notification to... ".$user."n";
}
}
}

Yay, dispatched !
Handler is called. Done.

Now, imagine your handler takes
ages to run.

What's a transport?
1. Has a sender & receiver
Guess what. They send and receive messages.
2. Is conﬁgurable via a DSN
So we have a unique and common way of conﬁguring them.
3. Use a Messenger Serializer
By defaut, uses Symfony Serializer. Replace as you wish.

Transports
1. Built-in AMQP.
You don't need anything more than the component and the PHP
extension.
2. More with Enqueue. (10+ other transports)
h>ps://github.com/php-enqueue/messenger-adapter
3. Fully extensible.
Create your own very easily by registering your implementaIon
of the TransportFactory interface.

Conﬁgure your transport(s)
# config/packages/messenger.yaml
framework:
messenger:
transports:
default: '%env(MESSENGER_DSN)%'
# .env
MESSENGER_DSN=amqp://guest:guest@localhost:5672/%2f/messages

Route your message(s)
framework:
messenger:
routing:
'AppMessageSendNotification': default

$ bin/console messenger:consume-messages

Mul$ple buses?
framework:
messenger:
default_bus: command_bus
buses:
command_bus: ~
event_bus: ~

Auto-wiring trick
services:
_defaults:
autowire: true
autoconfigure: true
public: false
bind:
$eventBus: '@event_bus'

Auto-wiring trick
use SymfonyComponentMessengerMessageBusInterface;
class MyController
{
public function __construct(
MessageBusInterface $commandBus,
MessageBusInterface $eventBus
) {
// ...
}
// ...
}

use SymfonyComponentMessengerHandlerMessageSubscriberInterface;
class SendNotificationHandler implements MessageSubscriberInterface
{
public static function getHandledMessages(): iterable
{
yield SendNotification::class => [
'method' => 'doSomething',
'bus' => 'command_bus'
];
}
public function doSomething(SendNotification $message)
{
// ...
}
}

Register your handlers (yield !!)
use SymfonyComponentMessengerHandlerMessageSubscriberInterface;
class SendNotificationHandler implements MessageSubscriberInterface
{
public static function getHandledMessages(): iterable
{
yield MyMessage::class => ['bus' => 'first_bus'];
yield MyMessage::class => ['bus' => 'second_bus'];
}
public function __invoke(MyMessage $message)
{
// ...
}
}

Middleware
namespace AppMiddleware;
use SymfonyComponentMessengerMiddlewareMiddlewareInterface;
class AuditMiddleware implements MiddlewareInterface
{
public function handle($message, callable $next)
{
try {
echo sprintf('Started with message "%s"'."n", get_class($message));
return $next($message);
} finally {
echo sprintf('Ended with message "%s"'."n", get_class($message));
}
}
}

Add your middleware
framework:
messenger:
buses:
command_bus:
middleware:
- 'AppMiddlewareAuditMiddleware'
event_bus: ~

Envelopes
For non-domain logic...

Envelopes
namespace AppMiddleware;
use SymfonyComponentMessengerEnvelopeAwareInterface;
use SymfonyComponentMessengerAsynchronousTransportReceivedMessage;
class AuditMiddleware implements MiddlewareInterface,
EnvelopeAwareInterface
{
public function handle($envelope, callable $next)
{
try {
if (null !== $envelope->get(ReceivedMessage::class)) {
echo sprintf('Consumed message "%s"'."n", get_class($message));
} else {
echo sprintf('Dispatched message "%s"'."n", get_class($message));
}
return $next($envelope);
} finally {
echo sprintf('Ended with message "%s"'."n", get_class($message));
}
}
}

Your own Envelope item
use SymfonyComponentMessengerEnvelopeAwareInterface;
class AuditMiddleware implements MiddlewareInterface,
EnvelopeAwareInterface
{
public function handle($envelope, callable $next)
{
$message = $envelope->getMessage();
if (null === $auditEnvelope = $envelope->get(AuditEnvelopeItem::class)) {
$envelope = $envelope->with(
$auditEnvelope = new AuditEnvelopeItem(uniqid())
);
}
try {
echo sprintf('[%s] Started with message "%s"' . "n", $auditEnvelope->getUuid(), get_class($message));
return $next($envelope);
} finally {
echo sprintf('[%s] Ended with message "%s"'."n", $auditEnvelope->getUuid(), get_class($message));
}
}
}

Your own Envelope item
use SymfonyComponentMessengerEnvelopeItemInterface;
class AuditEnvelopeItem implements EnvelopeItemInterface
{
private $uuid;
public function __construct(string $uuid)
{
$this->uuid = $uuid;
}
public function getUuid()
{
return $this->uuid;
}
}

Envelopes: also for "conﬁgura3on"
use SymfonyComponentMessengerEnvelope;
use SymfonyComponentMessengerTransport
SerializationSerializerConfiguration;
$bus->dispatch(
(new Envelope($message))->with(new SerializerConfiguration([
'groups' => ['my_serialization_groups'],
]))
);

What can you do?
1. Try it!
It has arrived in Symfony 4.1. Stable in 4.2.
2. Help us make it great again.
Open an issue, a pull-request, create another transport, a set of
middleware, ...
3. Enjoy.

Thank you.
h"ps://symfony.com/messenger
@samuelroze

Symfony Messenger (Symfony Live San Francisco)

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Symfony Messenger (Symfony Live San Francisco)

Similar to Symfony Messenger (Symfony Live San Francisco) (20)

More from Samuel ROZE

More from Samuel ROZE (14)

Recently uploaded

Recently uploaded (20)

Symfony Messenger (Symfony Live San Francisco)