La liberación de Combinado con Desde hace más de una década, hemos generado getters y setters religiosamente, hinchando nuestras entidades y DTOs con boilerplate que añade ruido visual pero cero valor empresarial. PHP 8.4, Symfony 7.4 (LTS), Con la introducción de PHP 8.4 y Podemos escribir modelos de dominio concisos y expresivos que encapsulan el comportamiento sin la verbosidad. Property Hooks Asymmetric Visibility En este artículo, exploraré cómo modernizar una aplicación Symfony 7.4 utilizando estas características. refactor una entidad Doctrine de estilo legado en un moderno, lean PHP 8.4 componente, asegurando la plena compatibilidad con Symfony's Serializer, Validator, y Forms. El Medio Ambiente Antes de profundizar en el código, asegúrese de que esté ejecutando la pila correcta. Symfony 7.4 es la versión de soporte a largo plazo lanzada en noviembre de 2025. Asegúrese de que su entorno local esté listo. ejecute los siguientes comandos: php -v
# Output must indicate PHP 8.4.0 or higher

composer version
# Ensure you are on Composer 2.8+
 Utilizaremos los componentes estándar de Symfony 7.4. Si está comenzando un nuevo proyecto: 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 está actualizando un proyecto existente, asegúrese de Restricciones Dos y Los paquetes . composer.json php ^8.4 symfony/* ^7.4 Visibilidad asimétrica: el final de la placa de boiler Getter / Setter Durante años, hemos hecho que las propiedades sean privadas y añadimos getters públicos para evitar modificaciones externas, permitiendo al mismo tiempo el acceso 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.
}
 La visibilidad asimétrica nos permite definir el permiso “set” independientemente del permiso “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;
    }
}
 Integración con la doctrina Esto funciona sin problemas con Doctrine ORM en la Sinfonía 7.4.La Doctrina utiliza la reflexión para hidratar las propiedades, evitando los guardias de la visibilidad, por lo que Es totalmente seguro para las entidades mapeadas. public private(set) Una Entidad Doctrinal 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: No getId(), getName(), getStock(). Encapsulación segura: $product->stock = 100 desencadena un error fatal desde fuera de la clase. DX (Experiencia de desarrollador): Autocompletion trabaja directamente en propiedades ($product->nombre), que se siente más "nativo" que las llamadas de método. Propiedades: Propiedades inteligentes Control de la visibilidad asimétrica , de Reemplazan los métodos mágicos (__get, __set) y los getters/setters explícitos con la lógica anexada directamente a la propiedad. access Property Hooks Normalización de datos (The set hook) Imagínese una entidad de usuario donde el correo electrónico debe almacenarse siempre en un subconjunto. 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
 Propiedades virtuales (The Get Hook) Las propiedades virtuales no almacenan datos; lo calculan en el vuelo. Esto es perfecto para accesorios de conveniencia en Symfony DTOs o Entidades que no necesitan ser persistentes en la base de datos. 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;
    }
}
 Integración con Symfony Serializer Una de las características más poderosas de Property Hooks en Symfony 7.4 es cómo el componente Serializer las maneja. 
 
 
 Propiedades respaldadas: Serializadas normalmente. Propiedades virtuales: Si son públicas, el Serializer las trata como propiedades reales. ya no necesitas #[SerializedName] en un método getFullName(). Ejemplo del 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);
    }
}
 La salida: {
  "firstName": "Jane",
  "lastName": "Doe",
  "fullName": "Jane Doe"
}
 Padrón avanzado: Objetos de valor y DTOs Veamos un escenario más complejo que involucre un Objeto de Transferencia de Datos (DTO) para una carga útil de Symfony Form o API. directamente en los bienes inmuebles. 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();
    }
}
 : Tenga cuidado con el get hook en $registeredAt arriba. Si la propiedad está desinicializada, acceder a ella a través de $this->registeredAt dentro del hook causa recursión infinita. El ?? cheque es un patrón seguro si el campo de respaldo puede ser nulo. Warning Refactorizar un servicio de legado Tradicionalmente, podríamos inyectar dependencias y utilizar métodos estándar. Con PHP 8.4, podemos hacer que nuestras configuraciones de servicio sean más limpias. : Año que necesita una dirección “enviadora” predeterminada, pero queremos permitir cambiarla temporalmente con estricta validación. 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);
    }
}
 en : services.yaml services:
    App\Service\EmailService:
        arguments:
            $mailer: '@mailer'
            $defaultSender: '%env(DEFAULT_EMAIL_SENDER)%'
 Si el ambiente es variable Si contiene un correo electrónico inválido, la instanciación del servicio fallará inmediatamente con una Excepción clara, en lugar de fallar silenciosamente más tarde cuando se envía el correo electrónico. . DEFAULT_EMAIL_SENDER This “Fail Fast” approach is enhanced by property hooks Compatibilidad Symfony 7.4 Form Component Las formas sinfónicas dependen en gran medida de la Componente para leer y escribir datos a sus objetos. PropertyAccessor : El En la Sinfonía 7.4 PHP 8.4 en la actualidad. Good News PropertyAccessor fully supports 
 
 
 Cuando el formulario lee los datos para cubrir los campos, se activa el get hook. Cuando el formulario envía datos de vuelta al objeto, desencadena el hook de conjunto. Transformaciones en la entidad A menudo puede eliminar los Transformadores de Datos de Formulario moviendo la lógica a la conexión 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;
    }
}
 En su forma: $builder->add('tagString', TextType::class, [
    'label' => 'Tags (comma separated)',
]);
 Esto simplifica el significativamente, manteniendo la lógica de transformación de datos dentro del objeto del dominio al que pertenece. FormType Consideraciones de rendimiento & Pitfalls Aunque estas características son excelentes, los desarrolladores “Senior” saben cuándo no usarlas. La caída del clonado Cuando tú Si se utiliza visibilidad asimétrica, el objeto clonado mantiene las mismas reglas de visibilidad. clone Sin embargo, ten cuidado con Si una propiedad virtual depende de otro objeto (por ejemplo, ) y clona el objeto principal, pero no el , la propiedad virtual todavía podría apuntar a la antigua referencia de usuario. Este es el comportamiento de objeto PHP estándar, pero los ganchos pueden ocultar esta complejidad. Virtual Properties $this->user->name $user Doctrina Proxies Doctrina utiliza Proxies (subclases) para cargar de manera lenta. 
 
 
 Visibilidad asimétrica: funciona bien porque Doctrina utiliza Reflexión para establecer propiedades privadas. Hooks: Si define un hook en una propiedad mapeada, la Doctrina lo desencadenará cuando hidrata la entidad a menos que utilice reflexión (lo que hace). Sin embargo, tenga mucho cuidado con la adición de efectos secundarios (como las llamadas de registro o de base de datos) dentro de un conjunto de hook de una entidad de la Doctrina. Cuando la Doctrina hidrata el objeto del DB, no desea que esos efectos secundarios se ejecuten. Evite efectos secundarios (logging, llamadas de API) en los hooks de la entidad. . Best Practice Keep hooks strictly for data validation and transformation Complejidad oculta No pongas 50 líneas de lógica de negocio dentro de un hook. Si la lógica es compleja, delegala a un método privado o, mejor aún, a un servicio. 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;
    }
}
 Guía de migración: De 7.3/8.3 a 7.4/8.4 Si está actualizando una base de código masiva, no trate de reescribir todo de una vez. 
 
 
 
 Visibilidad asimétrica. Execute una búsqueda de regex o use Rector (una vez actualizado para 8.4) para reemplazar propiedades privadas + getters simples con público privado(set).Búsqueda: tipo privado $prop; ... getProp() {devolver $this->prop; }Remplace: público privado(set) tipo $prop; Propiedades virtuales para recursos de API. Busque clases con #[SerializedName(‘virtual_field’)] y obtenga los métodosVirtualField() Convertirlas en propiedades virtuales. Mover la lógica Assert simple que transforma los datos (como trim() o strtolower()) de los controladores / escuchadores en Property Hooks. Conclusión y Permítannos escribir el código que es probablemente el más limpio en la historia del lenguaje.Estamos desplazándose de las estructuras de datos verbosas y “estúpidas” del pasado hacia objetos inteligentes y autogestionables. PHP 8.4 Symfony 7.4 Temas clave 
 
 
 
 
 Utilice Visibilidad asimétrica (público privado(set)) para exponer los datos de forma segura sin retrasos. Use Property Hooks para la validación ligera, la transformación y las propiedades virtuales. Symfony Serializer y Forms soportan estas características fuera de la caja en 7.4. Mantenga los ganchos limpios y rápidos; evite efectos secundarios pesados. Los días de generar getters y setters han terminado.Bienvenido a la era de PHP moderno. ¿Está tu equipo listo para migrar a Symfony 7.4? ayudo a las organizaciones a modernizar aplicaciones PHP antiguas y adoptar arquitecturas de alto rendimiento. : Estar en contacto en Linkedin [ ] Let’s connect https://www.linkedin.com/in/matthew-mochalkin/ https://www.linkedin.com/in/matthew-mochalkin/

Read My Stories

Este audio es producido en el idioma original de la historia!

Hooks de propiedad en acción: Aquí están algunos ejemplos del mundo real que debes mirar

About Author

COMENTARIOS

ETIQUETAS

ESTE ARTÍCULO FUE PRESENTADO EN

Related Stories

La guía completa para una migración exitosa a la nube: estrategias y mejores prácticas

Una guía del arquitecto para crear una arquitectura de referencia para un lago de datos de IA/ML

Cómo mejorar su flujo de trabajo 10 veces: 17 aplicaciones esenciales

Una breve introducción a la teoría del cerebro de Boltzmann

La guía completa para una migración exitosa a la nube: estrategias y mejores prácticas

Una guía del arquitecto para crear una arquitectura de referencia para un lago de datos de IA/ML

Cómo mejorar su flujo de trabajo 10 veces: 17 aplicaciones esenciales

Una breve introducción a la teoría del cerebro de Boltzmann

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps