Live : Architecture Hexagonale en PHP

Transcribed Jun 15, 2026 Watch on YouTube ↗

Intermediate 30 min read For: PHP developers with basic knowledge of OOP and frameworks like Symfony or Laravel who want to learn about hexagonal architecture and TDD.

23.2K

Views

546

Likes

81

Comments

13

Dislikes

2.7%

📈 Moderate

AI Summary

This live stream explores hexagonal architecture (ports and adapters) in PHP, focusing on its principles and practical implementation. The host demonstrates building a blog post creation feature using domain-driven design, test-driven development, and dependency inversion to decouple business logic from infrastructure concerns.

Chapters

1 Introduction and Context 00:00 2 Key Concepts: UUIDs, DDD, TDD 06:00 3 Hexagonal Architecture Principles 16:00 4 Live Coding: Project Setup 28:00 5 Live Coding: Use Case and Entity 37:00 6 Live Coding: Ports and Adapters 59:00 7 Live Coding: Validation and Controller 88:00 8 Conclusion and Recap 114:00

[00:00]

Introduction to the live stream

The host explains the format: sharing topics he is currently learning, including DDD, TDD, and hexagonal architecture. He acknowledges that his understanding is evolving and welcomes feedback.

[06:00]

UUIDs as identifiers

UUIDs allow generating unique identifiers without a database, enabling testing and development without a persistent store. They are useful in TDD where you start without a database.

[09:00]

Domain-Driven Design (DDD) basics

DDD emphasizes organizing code by business domain rather than technical layers. The host focuses on the concept of grouping code by functionality (e.g., blog, authentication) rather than by controllers, models, etc.

[14:00]

Test-Driven Development (TDD) overview

TDD involves writing a test before any production code, then writing just enough code to pass the test. The host notes that TDD requires a mindset shift and recommends resources like the willdurand community.

[16:00]

Principles of hexagonal architecture

The core idea is separation of concerns and decoupling. Infrastructure (frameworks, databases) should be details; the business logic (the hexagon) should be framework-agnostic and testable.

[21:00]

Benefits of hexagonal architecture

Delaying technical decisions, ease of evolution (changing frameworks or databases without touching business logic), and improved testability.

[28:00]

Live coding setup

The host sets up a PHP project with pest (testing library), phpunit-watchers (auto-test on file save), and creates a domain folder structure organized by feature (blog).

[37:00]

Writing a use case test

The host writes a test for creating a post, defining the expected behavior: a CreatePost use case that takes post data and returns a Post entity.

[44:00]

Implementing the CreatePost use case

The CreatePost class is created in the 'usecases' folder. It receives a PostRepositoryInterface (a port) via constructor injection and uses it to save the post.

[53:00]

Creating the Post entity

The Post entity has properties: title, content, publishedAt (nullable DateTime), and a UUID (generated via uniqid if not provided).

[59:00]

In-memory repository for testing

An InMemoryPostRepository is created in the test folder to simulate a database. It implements PostRepositoryInterface and stores posts in an array.

[64:00]

Introducing the port (interface)

The PostRepositoryInterface is defined in the 'ports' folder inside the domain. It declares save() and findOne() methods. The use case now depends on this interface, not a concrete class.

[71:00]

PDO repository implementation

A PdoPostRepository is created that implements PostRepositoryInterface using MySQL. It uses PDO to insert and select posts, demonstrating that the use case works with a real database.

[88:00]

Validation with lazy assertions

The host adds validation to the CreatePost use case using the 'beberlei/assert' library. If data is invalid, a custom InvalidPostDataException is thrown.

[101:00]

Creating a controller in the infrastructure layer

A CreatePostController is built in the 'infra' folder. It handles HTTP requests, uses the CreatePost use case, and returns a response. This demonstrates the separation between domain and infrastructure.

[114:00]

Conclusion and recap

The host summarizes that the domain folder is the hexagon, and the infra folder is the outside. The architecture allows easy swapping of frameworks and databases.

Hexagonal architecture enables building business logic independently of infrastructure, making code more testable and adaptable to change. The live coding demonstrated a practical implementation with PHP, showing how ports and adapters decouple the core domain from frameworks and databases.

Clickbait Check

90% Legit

"Title accurately describes the content: a live stream about hexagonal architecture in PHP with live coding."

Mentioned in this Video

Thomas Boileau

person

Mickael Azerrad (willdurand)

person

willdurand.com

link

willdurand Slack

link

Romain Cusniaque

person

Cyril Marret

person

Arnaud Lemaire

person

Frédéric Bouchery

person

Pest

tool

phpunit-watchers

tool

beberlei/assert

tool

Symfony HttpFoundation

tool

Tutorial Checklist

1 28:00 Set up a PHP project with Composer and install pest, phpunit-watchers, and symfony/http-foundation.

2 30:00 Create a domain folder structure organized by feature (e.g., blog) with src and test subdirectories.

3 32:00 Configure phpunit-watchers to monitor the domain folder and auto-run tests on file changes.

4 37:00 Write a test for the CreatePost use case: instantiate CreatePost with an in-memory repository, execute with post data, and assert the returned Post is correct.

5 44:00 Implement the CreatePost class in the usecases folder. It should receive a PostRepositoryInterface via constructor injection and call save() in its execute() method.

6 48:00 Create the Post entity with properties: title, content, publishedAt (nullable DateTime), and a UUID (generated via uniqid if not provided).

7 59:00 Create an InMemoryPostRepository in the test folder that implements PostRepositoryInterface, storing posts in an array.

8 64:00 Define the PostRepositoryInterface in a 'ports' folder inside the domain, declaring save(Post $post) and findOne(string $uuid) methods.

9 71:00 Create a PdoPostRepository that implements PostRepositoryInterface using PDO to insert and select posts from a MySQL database.

10 88:00 Add validation in CreatePost using beberlei/assert: ensure title is not empty and content has minimum length. Throw InvalidPostDataException on failure.

11 101:00 Create a CreatePostController in the infra folder that handles HTTP requests, uses the CreatePost use case, and returns a response.

Study Flashcards (10)

What is the main purpose of using UUIDs as identifiers?

easy Click to reveal answer

UUIDs allow generating unique identifiers without a database, enabling testing and development without a persistent store.