DTOs in Laravel are used to organize, validate, and transfer data between application layers, improving predictability and testability. 2. Install the recommended spatie/laravel-data package via Composer for robust DTO functionality. 3. Create a DTO using the Artisan command make:data, defining data structure with type hints and optional nesting. 4. Use DTOs in controllers either via manual instantiation from validated request data or through automatic binding by implementing FromRequest. 5. Apply casting and naming mapping using attributes like WithCast and MapName to transform and normalize data. 6. DTOs can be easily converted to arrays or JSON for API responses, enhancing frontend compatibility. 7. Optionally integrate DTOs with API resources or map them directly from Eloquent models using FromModel, ensuring consistent data formatting across the app. Always keep DTOs free of business logic, use clear naming conventions, and leverage type safety to maintain clean, scalable code.

Using Data Transfer Objects (DTOs) in Laravel helps you organize, validate, and transfer data between different layers of your application—like from a request to a service or from a service to the frontend. While Laravel doesn’t include DTOs out of the box, you can implement them effectively using PHP classes, often with the help of third-party packages like spatie/data-transfer-object or livewire-ui/slim-dto.

Here’s how to use DTOs in Laravel effectively:

? 1. What is a DTO and Why Use It?

A Data Transfer Object (DTO) is a simple PHP object used to carry data. It’s especially useful when:

• You want to pass structured data between services.
• You need to normalize input from HTTP requests.
• You're working with APIs and want consistent data formatting.
• You want to enforce type safety and validation.

Instead of passing raw arrays or request objects around, DTOs make your code more predictable and easier to test.

? 2. Install a DTO Package (Recommended: spatie/laravel-data)

While you can create plain PHP classes as DTOs, using spatie/laravel-data (the modern successor to spatie/data-transfer-object) is the most robust approach in Laravel.

Install it via Composer:

composer require spatie/laravel-data

Publish the config (optional):

php artisan vendor:publish --provider="Spatie\LaravelData\LaravelDataServiceProvider"

? 3. Create a DTO

Let’s say you’re handling user creation. Run the Artisan command:

php artisan make:data UserDTO

This creates a class like:

// App/DTOs/UserDTO.php
namespace App\DTOs;

use Spatie\LaravelData\Data;

class UserDTO extends Data
{
    public function __construct(
        public string $name,
        public string $email,
        public ?string $phone = null,
    ) {}
}

You can also use array syntax or nested data:

public function __construct(
    public string $name,
    public string $email,
    public AddressDTO $address,
    public array $roles,
)

? 4. Use DTO in a Request or Controller

Option A: From a Form Request

// In your controller
use App\DTOs\UserDTO;
use Illuminate\Http\Request;

public function store(Request $request)
{
    $dto = UserDTO::from($request->validated());

    // Pass to service
    UserService::create($dto);

    return response()->json(['message' => 'User created']);
}

Or better, use automatic binding with FromRequest:

// In controller method
public function store(UserDTO $dto)
{
    UserService::create($dto);

    return response()->json($dto);
}

?? This works only if you implement Spatie\LaravelData\FromRequest on your DTO or use proper form request mapping.

Option B: With a Form Request DTO

// app/Http/Requests/StoreUserRequest.php
public function rules()
{
    return [
        'name' => 'required|string|max:255',
        'email' => 'required|email',
        'phone' => 'nullable|string',
    ];
}

// In controller
public function store(StoreUserRequest $request)
{
    $dto = UserDTO::from($request->validated());

    // Handle logic
}

? 5. Add Casting and Custom Mapping

Use data transformers and casters to format input:

use Spatie\LaravelData\Attributes\MapName;
use Spatie\LaravelData\Attributes\WithCast;
use Spatie\LaravelData\Casts\DateTimeInterfaceCast;

class UserDTO extends Data
{
    public function __construct(
        public string $name,
        public string $email,
        #[WithCast(DateTimeInterfaceCast::class, format: 'Y-m-d')]
        public ?\DateTimeInterface $dob = null,
        #[MapName('phone_number')]
        public ?string $phone = null,
    ) {}
}

Now it maps phone_number from JSON to phone, and formats the date.

? 6. Transform DTO to Array/JSON

DTOs are easily serializable:

$dto = UserDTO::from([
    'name' => 'John Doe',
    'email' => 'john@example.com'
]);

return $dto->toArray();
// or automatically JSON in response:
return response()->json($dto);

? 7. Use DTOs in API Resources (Optional)

You can use DTOs alongside or instead of API resources:

return new JsonResponse(UserDTO::from($user));

Or map Eloquent models to DTOs:

UserDTO::from([
    'name' => $user->name,
    'email' => $user->email,
]);

You can even make your DTO automatically map from a model using Spatie\LaravelData\FromModel.

? Summary: Best Practices

• ? Use spatie/laravel-data for powerful, clean DTOs.
• ? Name DTOs clearly: UserDTO, CreateUserDTO, UserProfileDTO.
• ? Use them in controllers, services, and APIs to standardize data flow.
• ? Leverage type hints, default values, and casting.
• ? Avoid putting business logic in DTOs—they should be data containers.

Using DTOs keeps your Laravel app clean, type-safe, and easier to maintain—especially as it grows. Once you start using them for forms, APIs, and service layers, you’ll wonder how you lived without them.

Basically, it's a small setup for a big win in code quality.

The above is the detailed content of How to use Data Transfer Objects (DTOs) in Laravel?. For more information, please follow other related articles on the PHP Chinese website!