La libération de Couplé avec Depuis plus d’une décennie, nous avons généré des getters et des setters religieux, gonflant nos entités et nos DTO avec des boilerplate qui ajoutent du bruit visuel mais zéro valeur commerciale. PHP 8.4, Symfony 7.4 (LTS), L’introduction de PHP 8.4 et Nous pouvons écrire des modèles de domaine concis et expressifs qui encapsulent le comportement sans la verbosité. Property Hooks Asymmetric Visibility Dans cet article, je vais explorer comment moderniser une application Symfony 7.4 en utilisant ces fonctionnalités.Je vais refactor une entité Doctrine de style héritier en un composant PHP moderne et maigre 8.4, assurant une compatibilité complète avec le Serializer, Validator et Forms de Symfony. L’environnement Avant de plonger dans le code, assurez-vous que vous exécutez la pile correcte. Symfony 7.4 est la version de support à long terme publiée en novembre 2025. Assurez-vous que votre environnement local est prêt. Exécuter les commandes suivantes: php -v
# Output must indicate PHP 8.4.0 or higher

composer version
# Ensure you are on Composer 2.8+
 Nous utiliserons des composants Symfony 7.4 standard. Si vous commencez un nouveau projet: 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
 Si vous mettez à niveau un projet existant, assurez-vous que votre Restrictions deux et Les paquets . composer.json php ^8.4 symfony/* ^7.4 Visibilité asymétrique : la fin de la plaque de chaudière Getter/Setter Pendant des années, nous avons rendu les propriétés privées et ajouté des jetons publics pour empêcher les modifications externes, tout en permettant un accès interne. 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.
}
 La visibilité asymétrique nous permet de définir l’autorisation « set » indépendamment de l’autorisation « 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;
    }
}
 Intégration avec la doctrine Cela fonctionne parfaitement avec Doctrine ORM dans Symphony 7.4. Doctrine utilise la réflexion pour hydrater les propriétés, en contournant les gardiens de la visibilité, de sorte est parfaitement sécurisé pour les entités cartographiées. public private(set) Une doctrine moderne 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 : pas de getId(), getName(), getStock(). Encapsulation sécurisée : $product->stock = 100 déclenche une erreur fatale en dehors de la classe. DX (Developer Experience): Autocompletion fonctionne directement sur les propriétés ($product->name), qui se sent plus «native» que les appels de méthode. Propriétés : Propriétés intelligentes Contrôle de la visibilité asymétrique , à Ils remplacent les méthodes magiques (__get, __set) et les getters/setters explicites avec la logique attachée directement à la propriété. access Property Hooks La normalisation des données (the set hook) Imaginez une entité utilisateur où l'e-mail doit toujours être stocké dans le sous-casier. 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
 Propriétés virtuelles (The Get Hook) Les propriétés virtuelles ne stockent pas de données ; elles le calculent sur le volant.Cela est parfait pour les accessoires de commodité dans les DTO de Symfony ou les entités qui n'ont pas besoin d'être persistantes à la base de données. 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;
    }
}
 Intégration avec Symfony Serializer L'une des caractéristiques les plus puissantes de Property Hooks dans Symfony 7.4 est la façon dont le composant Serializer les gère. 
 
 
 Propriétés soutenues : Sérialisées normalement. Propriétés virtuelles: Si elles sont publiques, le Serializer les traite comme des propriétés réelles. Vous n'avez plus besoin de #[SerializedName] sur une méthode getFullName() . Exemple de contrôleur : 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);
    }
}
 La sortie : {
  "firstName": "Jane",
  "lastName": "Doe",
  "fullName": "Jane Doe"
}
 Modèle avancé : Objets de valeur & DTO Regardons un scénario plus complexe impliquant un Objet de transfert de données (DTO) pour un formulaire Symfony ou une charge utile API. directement sur les propriétés hooked. 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();
    }
}
 : Soyez prudent avec le get hook sur $registeredAt ci-dessus. Si la propriété est non initialisée, l'accès via $this->registeredAt à l'intérieur du hook provoque une récursion infinie. Warning Refonte d’un service héréditaire Traditionnellement, nous pouvons injecter des dépendances et utiliser des méthodes standard. Avec PHP 8.4, nous pouvons rendre nos configurations de service plus propres. : une qui nécessite une adresse « expéditeur » par défaut, mais nous voulons permettre de la modifier temporairement avec une validation stricte. 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);
    }
}
 dans : services.yaml services:
    App\Service\EmailService:
        arguments:
            $mailer: '@mailer'
            $defaultSender: '%env(DEFAULT_EMAIL_SENDER)%'
 Si l’environnement est variable contenant un courrier électronique non valide, l'instantiation du service échouera immédiatement avec une Exception claire, au lieu d'échouer silencieusement plus tard lors de l'envoi du courrier électronique. . DEFAULT_EMAIL_SENDER This “Fail Fast” approach is enhanced by property hooks Symfony 7.4 Form Compatibilité des composants Les formes symphoniques dépendent fortement de la composant pour lire et écrire des données sur vos objets. PropertyAccessor : le Dans la symphonie 7.4 PHP 8.4 pour Mac. Good News PropertyAccessor fully supports 
 
 
 Lorsque le formulaire lit des données pour stocker des champs, il déclenche le raccord. Lorsque le formulaire renvoie des données à l’objet, il déclenche la lame de configuration. Les transformations de l’entité Vous pouvez souvent supprimer les transformateurs de données de formulaire en déplaçant la logique vers la hook Entité/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;
    }
}
 Dans votre forme : $builder->add('tagString', TextType::class, [
    'label' => 'Tags (comma separated)',
]);
 Cela simplifie le conserver la logique de transformation des données au sein de l'objet de domaine auquel elle appartient. FormType Considérations de performance & Pitfalls Bien que ces fonctionnalités soient excellentes, les développeurs « seniors » savent quand ne pas les utiliser. Le clonage de la cascade Quand vous Si vous utilisez une visibilité asymétrique, l'objet cloné conserve les mêmes règles de visibilité. clone Cependant, soyez prudent avec Si une propriété virtuelle dépend d'un autre objet (par exemple, ) et vous clonez l'objet parent mais pas l'objet interne La propriété virtuelle peut toujours pointer vers la référence utilisateur ancienne.C'est le comportement d'objet PHP standard, mais les hooks peuvent cacher cette complexité. Virtual Properties $this->user->name $user Doctrine des Proxies Doctrine utilise Proxies (subclasses) pour le chargement paresseux. 
 
 
 Visibilité asymétrique : Fonctionne bien parce que Doctrine utilise Réflexion pour définir des propriétés privées. Hooks: Si vous définissez un hook sur une propriété cartographiée, Doctrine le déclenchera lors de l'hydratation de l'entité à moins qu'il n'utilise la réflexion (ce qu'il fait). Cependant, soyez très prudent à propos de l'ajout d'effets secondaires (comme les appels de journaux ou de base de données) à l'intérieur d'un ensemble de hook d'une entité de Doctrine. Évitez les effets secondaires (logging, appels API) dans les hooks d'entité. . Best Practice Keep hooks strictly for data validation and transformation La complexité cachée Ne mettez pas 50 lignes de logique d'affaires à l'intérieur d'un crochet. Si la logique est complexe, déléguez-la à une méthode privée ou, mieux encore, à un service. 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;
    }
}
 Guide de migration : de 7.3/8.3 à 7.4/8.4 Si vous effectuez une mise à niveau d’une base de codes massive, n’essayez pas de tout réécrire à la fois. 
 
 
 
 Visibilité asymétrique. Exécutez une recherche regex ou utilisez Rector (une fois mis à jour pour 8.4) pour remplacer les propriétés privées + simples getters par public private(set).Search: private type $prop; ... getProp() {retour $this->prop; }Remplace: public private(set) type $prop; Propriétés virtuelles pour les ressources API. Recherchez des classes avec les méthodes #[SerializedName(‘virtual_field’)] et getVirtualField() . Mouvez la logique Assert simple qui transforme les données (telles que trim() ou strtolower()) des contrôleurs/écouteurs en Hooks de propriété. Conclusion et Nous nous éloignons des structures de données verbales et « stupides » du passé vers des objets intelligents et autogérants. PHP 8.4 Symfony 7.4 Principaux Takeaways 
 
 
 
 
 Utilisez la visibilité asymétrique (privé public(set)) pour exposer les données de manière sécurisée. Utilisez Property Hooks pour la validation légère, la transformation et les propriétés virtuelles. Symfony Serializer et Forms prennent en charge ces fonctionnalités hors de la boîte dans 7.4. Gardez les crochets propres et rapides; Éviter les effets secondaires lourds. Les jours de génération de getters et de setters sont terminés.Bienvenue à l'ère de la PHP moderne. Votre équipe est-elle prête à migrer vers Symfony 7.4 ?J'aide les organisations à moderniser les applications PHP anciennes et à adopter des architectures hautes performances. Restez connecté sur LinkedIn [ ] Let’s connect https://www.linkedin.com/in/matthew-mochalkin/ https://www.linkedin.com/in/matthew-mochalkin/

Read My Stories

Cet audio est produit dans la langue originale de l'histoire !

Hooks de propriété en action: voici quelques exemples du monde réel que vous devriez regarder

About Author

COMMENTAIRES

ÉTIQUETTES

CET ARTICLE A ÉTÉ PARU DANS

Related Stories

Valhalla de Floki se joint en tant que sponsor associé de la tournée indienne au Sri Lanka

Des forums aux flux : comment les algorithmes des réseaux sociaux façonnent l'interaction numérique

Naviguer sur les eaux : développer des applications RAG de qualité production avec des lacs de données

Créer des produits cryptographiques centrés sur l'utilisateur : l'importance des retours clients

Valhalla de Floki se joint en tant que sponsor associé de la tournée indienne au Sri Lanka

Des forums aux flux : comment les algorithmes des réseaux sociaux façonnent l'interaction numérique

Naviguer sur les eaux : développer des applications RAG de qualité production avec des lacs de données

Créer des produits cryptographiques centrés sur l'utilisateur : l'importance des retours clients

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps