Forem: Marcelo Chiaretto

DTOs and PHP: Simplifying Data Transfer Between Application Layers

Marcelo Chiaretto — Mon, 29 Dec 2025 02:03:04 +0000

The DTO Pattern

The DTO (Data Transfer Object) is a design pattern aimed at creating objects used exclusively for transferring data between different layers of an application. It is typically an "anemic" object, meaning the class contains only attributes and lacks methods for data manipulation — focusing solely on object construction.

Why not use an array to receive data in a method?

Consider the following CreateProduct class:

<?php 

namespace App\Actions\Product;

use App\Product\Contracts\ProductRepository;

class CreateProduct 
{
    public function __construct(private ProductRepository $repository) {}

    public function execute(array $data): Product 
    {
        // ...
    }
}

Since the execute() method receives an associative array, anyone instantiating this class would need to look inside the method's implementation to understand which keys are required in the array.

Replacing the array with a DTO

In PHP, we can build a DTO class using the readonly modifier (introduced in PHP 8.1) to ensure that the object's attributes remain immutable.

<?php

namespace App\Dto;

readonly class ProductDto 
{
    public function __construct(
        public string $name,
        public string $description,
        public float $price,
        public int $quantity,
        public int $categoryId,
        public int $brandId,
        public string $sku,
        public string $ean
    ) {}
}

Now, we can refactor the execute() method in the CreateProductclass:

public function execute(ProductDto $data): Product 
{
    // ...
}

IDE Benefits

By using a DTO class instead of an associative array, your IDE provides better support by identifying the required attributes:

And also in the use of this data:

Going further with static methods

To simplify the creation of these objects, we can implement static factory methods:

public static function fromRequest(Request $request): self 
{
    return new self(
        name: $request->name,
        description: $request->description,
        price: $request->price,
        quantity: $request->quantity,
        categoryId: $request->category_id,
        brandId: $request->brand_id,
        sku: $request->sku,
        ean: $request->ean
    );
}

public static function fromArray(array $data): self 
{
    return new self(
        name: $data['name'],
        description: $data['description'],
        price: $data['price'],
        quantity: $data['quantity'],
        categoryId: $data['categoryId'],
        brandId: $data['brandId'],
        sku: $data['sku'],
        ean: $data['ean']
    );
}

Usage:

$data = ProductDto::fromRequest($request);

When not to use DTOs

I don't see the need to use a DTO as a parameter in public methods that already clearly indicate the expected data. For example, a method that fetches a list of products by their IDs:

class FindProducts 
{
    public function execute(array $productsIds): Product 
    {
        // ...
    }
}

DTOs e PHP: simplificando a transferência de dados entre as camadas da aplicação

Marcelo Chiaretto — Tue, 09 Jul 2024 12:44:00 +0000

O padrão DTO

O DTO (Data Transfer Object) é um padrão de projeto que visa ter objetos usados exclusivamente para a transferência de dados entre camadas de uma aplicação. É um objeto anêmico, ou seja, a classe tem apenas atributos e sem métodos que manipulem dados, apenas de construção do objeto.

Porque não um utilizar um array para receber dados em método?

Observe a classe CreateProduct:



<?php

namespace App\Actions\Product;

use App\Product\Contracts\ProductRepository;

class CreateProduct
{
    public function __construct(private ProductRepository $repository) {}

    public function execute(array $data): Product
    {
        //
    }
}

Como o método execute() recebe um array associativo, quem instanciar essa classe precisará abrir o método e ver quais chaves do array será necessário informar.

Substituindo o array pelo DTO

Podemos construir uma classe DTO no PHP utilizando o modificador readonly para que os atributos dos objetos não sejam alterados.

PHP 8.1:



<?php

namespace App\Dto;

readonly class ProductDto
{
    public function __construct(
        public string $name,
        public string $description,
        public float $price,
        public int $quantity,
        public int $categoryId,
        public int $brandId,
        public string $sku,
        public string $ean
    ) {}
}

E na classe CreateProduct podemos alterar o método execute():



public function execute(ProductDto $data): Product
{
    //
}

Benefícios para a IDE

Ao utilizar a classe DTO no lugar do array associativo a IDE irá ajudar a identificar os atributos necessários:

E também na utilização desses dados:

Indo além com métodos estáticos

Para facilitar a criação desses objetos podemos criar métodos estáticos:



public static function fromRequest(Request $request): self
{
    return new self(
        name: $request->name,
        description: $request->description,
        price: $request->price,
        quantity: $request->quantity,
        categoryId: $request->category_id,
        brandId: $request->brand_id,
        sku: $request->sku,
        ean: $request->ean
    );
}

public static function fromArray(array $data): self
{
    return new self(
        name: $data['name'],
        description: $data['description'],
        price: $data['price'],
        quantity: $data['quantity'],
        categoryId: $data['categoryId'],
        brandId: $data['brandId'],
        sku: $data['sku'],
        ean: $data['ean']
    );
}

E utilizando dessa forma:



$data = ProductDto::fromRequest($request);

Quando não utilizar

Não vejo a necessidade de utilizar um DTO como parâmetro em métodos públicos que já indicam o dado que espera receber, como por exemplo um método que buscará uma lista de produtos pelos IDs informados:



class FindProducts
{
    public function execute(array $productsIds): Product
    {
        //
    }
}

Estilo de código no PHP: as recomendações da PSR-1 e PSR-12

Marcelo Chiaretto — Sun, 03 Apr 2022 15:44:55 +0000

As PSRs, ou PHP Standards Recommendations, são uma série de especificações para o PHP elaboradas pela PHP-FIG (PHP Framework Interop Group), visando criar um padrão de código para os diferentes frameworks da linguagem, como autoloading, interfaces, requisições e respostas HTTP e estilo de códigos. Neste artigo falarei das PSR-1 e PSR-12, que tratam dos padrões de estilo de código.

PSR-1 - Basic Coding Standard

Como o próprio nome dessa PSR diz, ela aborda o padrão básico para escrever um código PHP.

O arquivo PHP

As tags que indicam que é um arquivo PHP devem ser somente <?php ?> e <?= ?> (em arquivos somente com código PHP o fechamento da tag ?> não deve ser realizado, conforme especificado na PSR-12).

Um arquivo PHP não deve misturar declarações de classes, funções constantes etc, com lógica externa a esses (side effects), como conectar a um serviço externo, alterar configurações, fazer require ou include de arquivos, ler e escrever arquivos etc. O exemplo abaixo mostra um código PHP misturando a declaração de classes com side effects, não recomendado:

<?php
// side effect: alteração de configuração ini do PHP
ini_set('error_reporting', E_ALL);

// side file: carregando um arquivo
include "file.php";

// side effect: gerando saída HTML
echo "<html>\n";

// declaração de função
function myFunction()
{
    // corpo da função
}

Nomes de classes e namespaces

O namespace deve seguir o padrão determinado na PSR-4 e os nomes de classes devem seguir o padrão StudlyCaps (também conhecido como PascalCase, UpperCamelCase):

<?php
namespace Project\Model;

class MyClass
{
    // corpo da classe
}

Propriedades, métodos e constantes de classes

As constantes de classes devem seguir o padrão SCREAMING_SNAKE_CASE:

<?php
namespace Project\Model;

class MyClass
{
    const DATE_APPROVED = '2022-04-03';
}

A PSR-1 não define que o nome da propriedade seja no estilo StudlyCaps, camelCase or $under_score, ela apenas reforça que um único estilo seja usado em todo o escopo do projeto. Por convenção, o mais adotado é o camelCase: private string $firstName.

Já os nomes dos métodos devem seguir o estilo camelCase: private function myFunction().

PSR-12: Extended Coding Style

A PSR-12 é uma recomendação bem mais longa, estendendo a PSR-1 e substituindo a PSR-2. Falarei aqui sobre como essa PSR trata do tamanho de linhas, indentação, estrutura de uma classe, palavras-chave e estruturas de controle.

Linhas, indentação, palavras-chave e tipos

O comprimento recomendado de uma linha é de 80 caracteres. Declarações que extrapolam esse comprimento deve ser quebradas em mais linhas. Não deve haver espaços em branco no final de cada linha e é permitido inserir quebras de linha para facilitar a leitura do código, salvo em casos que isso é proibido. A indentação deve ser realizada com 4 espaços em cada nível.

A escrita de palavras-chave e tipos deve ser em lower case e usar a forma curta quando disponível: int, bool, false, echo etc.

Estrutura de uma classe

Basicamente, a estrutura de uma classe deve ser: abertura da tag do PHP, declaração do namespace, importações com use e o corpo da classe.
Na escrita de uma classe o uso de extends e implements deve ser realizado na mesma linha do nome da classe. A abertura da chaves deve ser realizada após a linha do nome da classe e fechada após o corpo da classe.

A visibilidade de uma propriedade, constante ou método deve ser explicitamente declarada. A abertura e fechamento de chaves dos métodos segue o mesmo padrão para as classes. Quando um método tem parâmetros sempre deve haver um espaço em branco após a vírgula e um parâmetro com valor padrão deve ser sempre colocado por último.

<?php

namespace Vendor\Package;

use FooClass;

class MyClass extends ParentClass implements \ArrayAccess
{
    private int $myNumber;
    private string $myName;

    public function myFunction(int $number, string $name = ''): void
    {
        $this->myNumber = $number;
        $this->myName = $name;
    }
}

Estruturas de controle

As recomendações gerais para todas as estruturas de controle são:

entre o nome da estrutura de controle e a abertura do parênteses da estrutura deve haver um espaço em branco
não deve ter espaço em branco após o fechamento do parênteses
entre o fechamento do parênteses e a abertura da chave da estrutura de controle deve haver um espaço em branco
o corpo da estrutura deve ser delimitado por chaves e a abertura da chave deve ser realizada na mesma linha da declaração da estrutura
o corpo da estrutura deve ser iniciado na próxima linha após a abertura da chave e deve ser recuado uma vez

Exemplo com if:

<?php

if ($variable) {
    // código
} else {
    // código
}

Para o restante das recomendações da PSR-12 acesse a documentação.

Como instalar o PHP 8 no Windows

Marcelo Chiaretto — Tue, 29 Mar 2022 03:16:47 +0000

Com XAMPP ou sem XAMPP?

Depois de um bom tempo que eu havia começado a estudar PHP é que descobri que eu não precisava ter instalado o XAMPP (ou WampServer, EasyPHP etc.) para poder escrever um "Hello World" qualquer. Isso se deve ao fato de que boa parte dos tutoriais que vi relacionavam o uso do PHP à web (e não estão errados) e por isso teria que instalar toda a stack PHP-Apache-MySQL.

Mas hoje penso que para um iniciante na linguagem não deveria ter que se preocupar em entender o que é um servidor Apache e um banco de dados para escrever o seu primeiro echo.

Sendo assim, mostro como instalar manualmente o PHP 8 no Windows 10/11 de forma rápida e nada complicada.

Baixando o PHP 8 no Windows

Na sessão de downloads do site do PHP temos as atuais versões estáveis (current stable) e as antigas versões estáveis (old stable). Vamos instalar então a atual versão estável, que na data em que escrevo a versão estável mais recente é a 8.1.4. Para baixar o PHP para Windows é só clicar no link Windows downloads:

O PHP oferece versões Thread Safe e Non Thread Safe. Escolheremos a Non Thread Safe de 32 ou 64 bits (dependendo do seu sistema), baixando o arquivo zip. Para saber mais sobre Thread Safe veja esse artigo.

Após fazer o download é só descompactar os arquivos no diretório C:\php e renomear o arquivo php.ini-development para php.ini:

Configurando as variáveis de ambiente

O próximo passo agora é adicionar o PHP às variáveis de ambiente do sistema. Acesse Configurações > Sistema > Sobre > Configurações avançadas do sistema > Variáveis de ambiente..., ou simplesmente digite 'variáveis de ambiente' na busca do Windows.

No grupo Variáveis do sistema procure pela variável Path e clique em editar:

Na janela que abrirá clique em Novo e insira o caminho do diretório que o PHP foi instalado e então é só clicar em OK em todas as janelas:

Testando o PHP

Após fazer as configurações, abra um terminal e digite php --version. Se tudo foi configurado corretamente irá aparecer a versão instalada do PHP:

Iniciando o servidor web

O PHP fornece um servidor web próprio, que para fins de estudos e pequenos desenvolvimentos é mais que o suficiente.

Para iniciar o servidor basta abrir o terminal e ir até o diretório onde estão os arquivos PHP e então digitar:



php -S localhost:8080

O servidor web do PHP já está funcionando!

Para testar se o servidor está respondendo, criei um arquivo index.php no diretório que está rodando o servidor, apenas para exibir as informações do PHP que acabamos de instalar:



<?php

phpinfo();

E no navegador acessar o endereço localhost:8080:

Concluindo

Em alguns passos já temos o PHP pronto para rodar no Windows. Como dito antes, fazendo dessa forma já é o suficiente para estudar a linguagem começar os primeiros projetos.