A libertação do Juntado com Há mais de uma década, temos geradores e seters religiosamente gerados, inundando nossas entidades e DTOs com boilerplate que adiciona ruído visual, mas zero valor de negócios. PHP 8.4, Symfony 7.4 (LTS), Introdução ao PHP 8.4 e Podemos escrever modelos de domínio concisos e expressivos que encapsulam o comportamento sem a verbosidade. Property Hooks Asymmetric Visibility Neste artigo, irei explorar como modernizar um aplicativo Symfony 7.4 usando esses recursos. irei refactor uma entidade Doctrine de estilo legado em um moderno, lean PHP 8.4 componente, garantindo total compatibilidade com o Serializer, Validator e Forms da Symfony. O Meio Ambiente Antes de mergulhar no código, vamos garantir que você esteja executando a pilha correta. Symfony 7.4 é a versão de Suporte a Longo Prazo lançada em novembro de 2025. Certifique-se de que o ambiente local está pronto. Execute os seguintes comandos: php -v
# Output must indicate PHP 8.4.0 or higher

composer version
# Ensure you are on Composer 2.8+
 Vamos usar os componentes padrão do Symfony 7.4.Se você está iniciando um novo projeto: composer create-project symfony/skeleton:7.4.* my_project
cd my_project
composer require symfony/webapp-pack:7.4.*
composer require symfony/orm-pack
composer require symfony/serializer-pack
composer require symfony/validator-pack
 Se você estiver atualizando um projeto existente, certifique-se de Restrições Dois e Pacotes para . composer.json php ^8.4 symfony/* ^7.4 Visibilidade assimétrica: o fim do Getter/Setter Boilerplate Durante anos, tornamos as propriedades privadas e adicionamos gates públicos para evitar modificações externas, ao mesmo tempo em que permitimos acesso interno. The Old Way (PHP 8.3 and below): class User
{
    private string $email;

    public function __construct(string $email)
    {
        $this->email = $email;
    }

    public function getEmail(): string
    {
        return $this->email;
    }
    
    // No setter meant it was effectively "read-only" externally, 
    // but we still needed the getter to read it.
}
 Visibilidade assimétrica permite-nos definir a permissão “set” independentemente da permissão “get”. The PHP 8.4 Way class User
{
    // Publicly readable, but only writeable by the class itself (private)
    public private(set) string $email;

    public function __construct(string $email)
    {
        $this->email = $email;
    }
}
 Integração com a doutrina Isso funciona perfeitamente com a Doctrine ORM na Sinfonia 7.4.A Doctrine usa reflexão para hidratar propriedades, contornando os guardas de visibilidade, de modo que é perfeitamente seguro para entidades mapeadas. public private(set) Uma entidade doutrinária moderna namespace App\Entity;

use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\Validator\Constraints as Assert;

#[ORM\Entity]
class Product
{
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column]
    public private(set) ?int $id = null;

    #[ORM\Column(length: 255)]
    #[Assert\NotBlank]
    public private(set) string $name;

    #[ORM\Column]
    #[Assert\PositiveOrZero]
    public private(set) int $stock = 0;

    public function __construct(string $name)
    {
        $this->name = $name;
    }

    // Business logic method to mutate state
    public function addToStock(int $quantity): void
    {
        if ($quantity < 1) {
            throw new \InvalidArgumentException('Quantity must be positive');
        }
        $this->stock += $quantity;
    }
}
 Why this matters: 
 
 
 
 Zero Boilerplate: Nenhum getId(), getName(), getStock(). Encapsulação segura: $product->stock = 100 desencadeia um erro fatal de fora da classe. DX (Experiência do Desenvolvedor): O Autocompletion funciona diretamente em propriedades ($product->name), que se sentem mais “nativas” do que as chamadas de método. Propriedades: Propriedades Inteligentes Controle de visibilidade assimétrica , em Eles substituem métodos mágicos (__get, __set) e getters / setters explícitos com lógica anexada diretamente à propriedade. access Property Hooks Normalização de Dados (The Set Hook) Imagine uma entidade de usuário onde o e-mail deve ser sempre armazenado em uma caixa baixa. namespace App\Entity;

use Doctrine\ORM\Mapping as ORM;

#[ORM\Entity]
class User
{
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column]
    public private(set) ?int $id = null;

    #[ORM\Column(length: 180, unique: true)]
    public string $email {
        // The 'set' hook intercepts assignment
        set(string $value) {
            if (!filter_var($value, FILTER_VALIDATE_EMAIL)) {
                throw new \InvalidArgumentException("Invalid email format");
            }
            // The backing value is updated automatically via this assignment
            $this->email = strtolower($value);
        }
    }

    public function __construct(string $email)
    {
        // This triggers the set hook!
        $this->email = $email;
    }
}
 Verification: $user = new User('ADMIN@Example.com');
echo $user->email; // Outputs: admin@example.com
 Propriedades Virtuais (The Get Hook) As propriedades virtuais não armazenam dados; eles o calculam de forma instantânea.Isto é perfeito para acessórios de conveniência em DTOs da Symfony ou entidades que não precisam ser persistentes no banco de dados. namespace App\Entity;

use Doctrine\ORM\Mapping as ORM;

#[ORM\Entity]
class Customer
{
    #[ORM\Column]
    public string $firstName;

    #[ORM\Column]
    public string $lastName;

    // This is a VIRTUAL property. It has no storage in memory.
    // Notice we do NOT add #[ORM\Column] because it's not in the DB.
    public string $fullName {
        get => $this->firstName . ' ' . $this->lastName;
    }
}
 Integração com o Symfony Serializer Uma das características mais poderosas do Property Hooks no Symfony 7.4 é como o componente Serializer lida com eles. 
 
 
 Propriedades suportadas: Serializadas normalmente. Propriedades virtuais: Se elas forem públicas, o Serializer as trata como propriedades reais. Você não precisa mais de #[SerializedName] em um método getFullName(). Exemplo do controlador: namespace App\Controller;

use App\Entity\Customer;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\Routing\Attribute\Route;

class CustomerController extends AbstractController
{
    #[Route('/customer/{id}', methods: ['GET'])]
    public function show(Customer $customer): JsonResponse
    {
        // Serialization automatically includes "fullName" in the JSON output
        return $this->json($customer);
    }
}
 A saída: {
  "firstName": "Jane",
  "lastName": "Doe",
  "fullName": "Jane Doe"
}
 Padrão Avançado: Objetos de Valor e DTOs Vamos olhar para um cenário mais complexo envolvendo um Objeto de Transferência de Dados (DTO) para um formulário Symfony ou carga útil da API. diretamente sobre as propriedades embutidas. validation attributes namespace App\DTO;

use Symfony\Component\Validator\Constraints as Assert;

class RegistrationRequest
{
    #[Assert\NotBlank]
    public string $firstName;

    #[Assert\NotBlank]
    public string $lastName;

    // A 'write-only' property behavior for passwords using a hook
    // We only want to set it, but reading it might return a masked value or be disallowed
    public string $password {
        set(string $value) {
            $this->password = password_hash($value, PASSWORD_BCRYPT);
        }
        get => '***MASKED***'; 
    }
    
    // Combining hooks with asymmetric visibility
    // Publicly readable, but only settable internally or by hydration
    public private(set) \DateTimeImmutable $registeredAt {
        get => $this->registeredAt ?? new \DateTimeImmutable();
    }
}
 Se a propriedade for desinicializada, acessá-la através de $this->registeredAt dentro do gancho causa recursão infinita.O ??check é um padrão seguro se o campo de backing for null. Warning Recuperação de um serviço de legado Vamos olhar para uma classe de serviço. Tradicionalmente, podemos injetar dependências e usar métodos padrão. Com o PHP 8.4, podemos tornar nossas configurações de serviço mais limpas. : um que precisa de um endereço de “envio” padrão, mas queremos permitir que ele seja alterado temporariamente com rigorosa validação. Scenario EmailService namespace App\Service;

use Symfony\Component\Mailer\MailerInterface;
use Symfony\Component\Mime\Email;

class EmailService
{
    public function __construct(
        private readonly MailerInterface $mailer,
        // Property Hook to validate configuration immediately
        public string $defaultSender {
            set(string $value) {
                if (!filter_var($value, FILTER_VALIDATE_EMAIL)) {
                    throw new \InvalidArgumentException("Invalid sender email");
                }
                $this->defaultSender = $value;
            }
        }
    ) {}

    public function sendWelcomeEmail(string $recipient): void
    {
        $email = (new Email())
            ->from($this->defaultSender)
            ->to($recipient)
            ->subject('Welcome!')
            ->text('Welcome to our platform.');

        $this->mailer->send($email);
    }
}
 em : services.yaml services:
    App\Service\EmailService:
        arguments:
            $mailer: '@mailer'
            $defaultSender: '%env(DEFAULT_EMAIL_SENDER)%'
 Quando o ambiente é variável contém um e-mail inválido, a instância do serviço falhará imediatamente com uma Exceção clara, em vez de falhar silenciosamente mais tarde quando o e-mail é enviado. . DEFAULT_EMAIL_SENDER This “Fail Fast” approach is enhanced by property hooks Compatibilidade com Symfony 7.4 Form Component As formas sinfônicas dependem fortemente da Componente para ler e escrever dados para seus objetos. PropertyAccessor • O em Sinfonia 7.4 O PHP 8.4 é um hook. Good News PropertyAccessor fully supports 
 
 
 Quando o formulário lê dados para preencher campos, ele desencadeia o ganho. Quando o formulário envia dados de volta para o objeto, ele desencadeia o gancho de set. Transformações na entidade Muitas vezes, você pode remover Form Data Transformers movendo a lógica para o gancho Entity/DTO. // Old way: create a CallbackTransformer to handle string-to-array conversion
// New way:

class TagAwareDTO
{
    /** @var string[] */
    private array $tags = [];

    // The form field can be mapped to 'tagString'
    // The underlying data is stored in $tags array
    public string $tagString {
        get => implode(', ', $this->tags);
        set(string $value) {
            $this->tags = array_map('trim', explode(',', $value));
        }
    }
    
    public function getTags(): array
    {
        return $this->tags;
    }
}
 Na sua forma: $builder->add('tagString', TextType::class, [
    'label' => 'Tags (comma separated)',
]);
 Isso simplifica o significativamente, mantendo a lógica de transformação de dados dentro do objeto de domínio onde pertence. FormType Considerações de desempenho & Pitfalls Embora esses recursos sejam excelentes, os desenvolvedores “Senior” sabem quando não usá-los. O clonagem da caça Quando você Se você usar visibilidade assimétrica, o objeto clonado mantém as mesmas regras de visibilidade. clone No entanto, tenha cuidado com Se uma propriedade virtual depende de outro objeto (por exemplo, ) e você clona o objeto-mãe, mas não o , a propriedade virtual ainda pode apontar para a antiga referência do usuário. Este é o comportamento de objeto PHP padrão, mas os ganchos podem esconder essa complexidade. Virtual Properties $this->user->name $user Doutrina Proxies A Doutrina usa Proxies (subclassificações) para carregamento preguiçoso. 
 
 
 Visibilidade assimétrica: Funciona bem porque a Doutrina usa Reflexão para definir propriedades privadas. Hooks: Se você definir um hook em uma propriedade mapeada, a Doutrina irá desencadeá-lo quando hidratar a entidade, a menos que ela use reflexão (o que faz). No entanto, tenha muito cuidado ao adicionar efeitos colaterais (como logging ou chamadas de banco de dados) dentro de um conjunto de hook de uma entidade da Doutrina. Quando a Doutrina hidrata o objeto do DB, você não quer que esses efeitos colaterais sejam executados. Evite efeitos colaterais (logging, chamadas de API) em hooks de entidade. . Best Practice Keep hooks strictly for data validation and transformation Complexidade escondida Não coloque 50 linhas de lógica de negócios dentro de um gancho.Se a lógica for complexa, delegue-a a um método privado ou, melhor ainda, a um serviço. Bad: public string $status {
    set {
        // 50 lines of code checking permissions, logging to DB, sending emails...
    }
}
 Good: public string $status {
    set {
        $this->validateStatusTransition($value);
        $this->status = $value;
    }
}
 Guia de migração: de 7.3/8.3 a 7.4/8.4 Se você estiver atualizando uma base de código maciça, não tente reescrever tudo de uma só vez. 
 
 
 
 Visibilidade assimétrica. Execute uma pesquisa de regex ou use o Rector (uma vez atualizado para 8.4) para substituir propriedades privadas + simples getters com public private(set).Search: private type $prop; ... getProp() {devolver $this->prop; }Replace: public private(set) type $prop; Propriedades virtuais para recursos da API. Procure classes com #[SerializedName(‘virtual_field’)] e obtenha os métodosVirtualField(). Converte-as em propriedades virtuais. Mova a lógica Assert simples que transforma dados (como trim() ou strtolower()) de controladores/listeners em Property Hooks. CONCLUSÃO e Nós estamos nos afastando das estruturas de dados verbosas e “estúpidas” do passado para objetos inteligentes e auto-geridos. PHP 8.4 Symfony 7.4 Principais Takeaways 
 
 
 
 
 Use Visibilidade assimétrica (público privado(sete)) para expor os dados de forma segura sem geradores. Use Property Hooks para validação leve, transformação e propriedades virtuais. Symfony Serializer e Forms suportam esses recursos fora da caixa em 7.4. Mantenha os ganchos limpos e rápidos; Evite efeitos colaterais graves. Os dias de gerar getters e setters terminaram.Bem-vindo à era do PHP moderno. Sua equipe está pronta para migrar para o Symfony 7.4? ajudo as organizações a modernizar aplicativos PHP antigos e adotar arquiteturas de alto desempenho. : Fique em contato no LinkedIn [ ] Let’s connect https://www.linkedin.com/in/matthew-mochalkin/ https://www.linkedin.com/in/matthew-mochalkin/

Read My Stories

Este áudio é produzido no idioma original da história!

Hooks de propriedade em ação: Aqui estão alguns exemplos do mundo real que você deve olhar

About Author

COMENTARIOS

Rótulos

ESTE ARTIGO FOI APRESENTADO EM

Related Stories

De fóruns a feeds: como os algoritmos de mídia social moldam a interação digital

Liberando o poder da IA. Uma revisão sistemática de técnicas de ponta: resumo e introdução

Modelo Bitcoin UTXO, alimentando um ecossistema único

As camadas invisíveis: por que as entrevistas com usuários são um ativo insubstituível

De fóruns a feeds: como os algoritmos de mídia social moldam a interação digital

Liberando o poder da IA. Uma revisão sistemática de técnicas de ponta: resumo e introdução

Modelo Bitcoin UTXO, alimentando um ecossistema único

As camadas invisíveis: por que as entrevistas com usuários são um ativo insubstituível

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps