Hexagonal architecture

Symfony and  
Hexagonal Architecture

Software Developer, father, geek, PHP and
Node.js expert. Open-source enthusiast,
active contributor on GitHub and
StackOverflow.
Who am I?
Alessandro Minoccheri
Software developer @Flowing
@minompi
@AlessandroMinoccheri

How do you usually start a new Symfony Project
• Install Symfony skeleton project
• Remove demo code
• Autogenerate entities
• Start coding from controllers or autogenerate those
• Ready to develop the application

How many points inside the code
do you need to change to replace
that service?
◆

42 different places in all over the
code-base.
◆

class PaymentController
{
public function payAction(Request $request, YourBankGateway $gateway)
{
$gateway->pay($request->get('amount'), false, false, 0, 'EUR');
}
}

class Payment
{
public function pay(Request $request)
{
$gateway = new YourBankGateway();
$gateway->pay($request->get('amount'), false, false, 0);
}
}

class User
{
public function pay(Request $request)
{
$gateway->pay($request->get('amount'));
}
}

Why does this situation exists?
◆

Problems when you are guided from the framework
• Impossible to upgrade framework and vendors.
• Cost of maintenance
• Developers are not motivated because the stack it's very old for the
reason of point 1.
• Not maintainable application because everything is coupled.
• A lot of technical debt
• Impossible to change implementation easily.

So, what really matters in
software?
◆

What really brings value in
software is the solution to the
specific problem in the domain
◆

Hexagonal Architecture history
◆

The hexagonal architecture divides a system into several
loosely-coupled interchangeable components, such as the
application core, the database, the user interface, test
scripts, and interfaces with other systems.  
This approach is an alternative to the traditional layered
architecture. (Wikipedia)
◆

Is it an over-engineer strategy?
◆

Coupled code
namespace AppService;
use SymfonyComponentHttpFoundationRequest;
class Payment
{
public function doPayment(Request $request)
{
$gateway->pay($request->get('amount'), false, false, 0);
}
}

Decoupled code
interface GatewayProvider
{
public function pay(Money $amount): void;
}

Decoupled code
use AppValueObjectMoney;
class YourBankGateway implements GatewayProvider {
public function pay(Money $amount): void
{
//do stuff..
}
}

Decoupled code
class Payment
{
/**
* @var GatewayProvider
*/
private GatewayProvider $gatewayProvider;
public function __construct(GatewayProvider $gatewayProvider)
{
$this->gatewayProvider = $gatewayProvider;
}
public function doPayment(Money $amount)
{
$this->gatewayProvider->pay($amount);
}
}

Why is it important to decouple
your code?
◆

Maintainable application
• Changes in one part of an application should affect as few other
places as possible
• Adding features shouldn't require to touch any part of the code-
base
• Adding new ways to interact with the application should require as
few changes as possible
• Debugging should require as few workarounds
• Testing should be relatively easy

Single responsibility for
architecture: 
What changes for the same reason,
should be grouped together
◆

Examples
• Code related to the framework
• Code related to the specific service
• Code related to the domain

The important distinction from domain and infrastructure
Domain
• Models: entities, value object or others
• interfaces for boundary objects
Infrastructure
• framework
• implementations for boundary objects
• Web controllers, CLI commands
Application
• Use cases

Why is it so important to have
maintainable software?
◆

Ports are like contracts
They will not have any representation in the codebase.
There is a port for every way a use case of the application can be
invoked .
There are input and output ports.

Input ports
interface PayOrderHandler
{
public function handle(PayOrderCommand $command): void;
}

Output ports
interface UserRepository
{
public function save(User $user): void;
public function findAll(): UserCollection;
}

Adapters definition
Adapters are the implementation of the ports because for each of
these abstract ports we need some code to make the connection
work.

Adapter example
class MysqlUserRepository implements UserRepository
{
/**
* @var Connection
*/
private $connection;
public function __construct(Connection $connection)
{
$this->connection = $connection;
}
public function save(User $user): void
{//do stuff...}
public function findById(UserId $userId): User
{//do stuff...}
public function findAll(): UserCollection
{//do stuff...}
}

Directories structure example
Src
Payment
Domain 
Application
Infrastructure
Cart
Domain
Application
Infrastructure

Dependency inversion principle

Advantages of using hexagonal
architecture
◆

You can replace an implementation without affecting the domain
3

You can postpone the choice of  
vendors, databases, servers, etc...
4

you can update vendors and framework without touching your
domain code.
5

So you can create maintainable application
6

namespace AppUserInfrastructureController;
use AppUserApplicationCreateUserService;
use AppUserApplicationDTOCreateUserRequest;
use SymfonyComponentHttpFoundationJsonResponse;
use SymfonyComponentHttpFoundationRequest;
class UserController
{
public function saveAction(Request $request, CreateUserService $createUserService)
{
$createUserRequest = CreateUserRequest::create($request->request->all());
$createUserService->createUser($createUserRequest);
return new JsonResponse();
}
}

namespace AppUserApplication;
use …
class CreateUserService
{
private UserRepository $userRepository;
public function __construct(UserRepository $userRepository)
{
$this->userRepository = $userRepository;
}
public function createUser(CreateUserRequest $createUserRequest): CreateUserResponse
{
$user = User::create(
$createUserRequest->getName(),
$createUserRequest->getPassword()
);
$this->userRepository->save($user);
return CreateUserResponse::createFromUser($user);
}
}

When to use it?
• When you have a new project
• When you need to develop a new context into a legacy application
• always? When to use it

How about legacy code without
hexagonal architecture?
◆

Golden rule
Boy scout rule:
Leave your code better than you found it.
When to use it

Where can you start from?
• Using more interfaces
• Using dependency injection
• Practice with kata projects
• Apply the architecture into a real project
When to use it

Next improvements
- DDD: Domain driven design
- CQRS pattern (Command Query Responsibility Segregation)
- Event sourcing
- TDD
- BDD
When to use it

Thank you!
@minompi https://joind.in/talk/f6069

Hexagonal architecture

More Related Content

What's hot (20)

Similar to Hexagonal architecture (20)

More from Alessandro Minoccheri (9)

Recently uploaded (20)

Hexagonal architecture