DDD in Laravel is not built-in but can be applied to organize complex business logic by structuring code around business domains rather than technical layers. 1. Bounded Contexts divide the application into modules like UserModule or OrderModule, each containing its own models, services, and events, keeping related logic together. 2. Entities represent objects with identity such as UserEntity, while Value Objects like EmailValueObject are defined by their attributes and kept separate from Eloquent models. 3. Aggregates group domain objects into coherent units like Order with its items, and Repositories abstract data access using interfaces in the domain and Eloquent implementations in infrastructure, decoupling business logic from persistence. 4. Domain Events such as UserRegistered are dispatched when key business moments occur, leveraging Laravel’s event system but defining events within the domain to ensure business relevance. Applying DDD in Laravel improves separation of concerns, enhances testability, supports scalability, and is most beneficial for complex applications beyond simple CRUD operations. To adopt DDD, start with a single module, use Laravel’s service container for dependency injection, isolate Eloquent to infrastructure layers, use DTOs for data transfer, and consider DDD scaffolding packages for faster setup. Adopting DDD in Laravel enables maintainable, scalable, and business-focused architecture as applications grow beyond basic MVC patterns.

Domain-Driven Design (DDD) in the context of Laravel isn’t a built-in feature of the framework — Laravel itself follows a more traditional MVC (Model-View-Controller) structure. However, DDD is an architectural approach that you can apply to Laravel applications to better organize complex business logic and make your code more maintainable as your project grows.

What is Domain-Driven Design?

DDD is a software design philosophy that emphasizes modeling your application around the core business domain. Instead of organizing code by technical layers (like controllers, models, or routes), you organize it by business capabilities — such as Users, Orders, Payments, etc. The goal is to keep the domain logic (the "what" and "why" of your app) central and explicit.

In Laravel, adopting DDD means rethinking how you structure your app, even though Laravel doesn’t enforce DDD out of the box.

Key DDD Concepts Applied in Laravel

1. Bounded Contexts (Modules)

Each major part of your business logic becomes a self-contained module. For example:

• UserModule/
• OrderModule/
• PaymentModule/

Each module contains its own models, services, repositories, DTOs, and policies — everything related to that domain.

In Laravel, this often translates to organizing code in folders like:

app/
├── Modules/
│   ├── User/
│   │   ├── Models/
│   │   ├── Services/
│   │   ├── Repositories/
│   │   ├── DTOs/
│   │   └── Events/
│   └── Order/
│       ├── Models/
│       └── ...

This keeps related logic together and reduces coupling.

2. Entities and Value Objects

• Entities are objects with identity (e.g., a User with a unique ID).
• Value Objects are defined by their attributes (e.g., Address, Money).

In Laravel, you might create these as plain PHP classes within your domain:

// app/Modules/User/Entities/UserEntity.php
class UserEntity
{
    public function __construct(
        public string $id,
        public string $name,
        public EmailValueObject $email
    ) {}
}

These are separate from Eloquent models, which become persistence details.

3. Aggregates and Repositories

• An Aggregate is a cluster of domain objects treated as a single unit (e.g., Order OrderItems).
• A Repository abstracts data access. Instead of using Eloquent directly in controllers, you use a repository interface defined in the domain and implemented in the infrastructure layer.

Example:

// Interface in domain
interface OrderRepositoryInterface
{
    public function findById(string $id): ?OrderEntity;
    public function save(OrderEntity $order): void;
}

// Implementation using Eloquent
class EloquentOrderRepository implements OrderRepositoryInterface
{
    public function findById(string $id): ?OrderEntity
    {
        $model = OrderModel::find($id);
        return $model ? OrderEntity::fromModel($model) : null;
    }
}

This way, your domain doesn’t depend on Laravel’s Eloquent.

4. Domain Events

When something important happens (e.g., "UserRegistered"), you fire a domain event. Other parts of the system can listen and react — like sending a welcome email or creating a profile.

In Laravel, you can use Laravel’s event system, but define events in your domain:

// app/Modules/User/Events/UserRegistered.php
class UserRegistered
{
    public function __construct(public UserEntity $user) {}
}

Then use event(new UserRegistered($user)) — and listeners can be in the same or other modules.

Why Apply DDD in Laravel?

• Complex apps benefit most: If your app is mostly CRUD, DDD might be overkill. But if you have complex workflows, rules, and multiple teams, DDD helps manage that complexity.
• Better separation of concerns: Business logic stays in the domain, not scattered across controllers or middleware.
• Easier testing: You can test domain logic without booting the entire Laravel framework.
• Scalability: Modules can evolve independently, making refactoring and team ownership easier.

Practical Tips for DDD in Laravel

• Start small: Apply DDD to one module first (e.g., OrderModule).
• Use Laravel’s service container to inject repository implementations.
• Keep Eloquent models in a sub-layer (like Infrastructure) — they’re just persistence tools.
• Use DTOs to transfer data between layers.
• Consider packages like laravel-shift/laravel-domain or ryangjchandler/laravel-ddd to scaffold DDD structure.

Basically, DDD in Laravel is about structuring your app around business needs, not framework conventions. It’s not required, but it’s powerful when your app outgrows simple MVC.

The above is the detailed content of What is Domain-Driven Design (DDD) in the context of Laravel?. For more information, please follow other related articles on the PHP Chinese website!