PHP 8.4 属性钩子与枚举高级用法：构建类型安全的业务模型

2025年，PHP 8.4 带来了属性钩子（Property Hooks）这一革命性特性，让类的属性访问控制更加优雅。同时，枚举（Enum）在PHP 8.1引入后持续进化，已经成为构建类型安全业务模型的核心工具。本文通过四个实战案例，带你掌握这些现代PHP特性。

1. 为什么需要属性钩子与枚举？

传统PHP中，属性访问控制依赖getter/setter方法，代码冗长且不够直观。属性钩子允许直接在属性声明中定义访问逻辑。枚举则提供了一组有限的、类型安全的常量集合，替代了传统的类常量或数组配置。

• 属性钩子：简化属性访问控制，减少样板代码
• 枚举：类型安全、可携带方法、支持接口实现

2. 属性钩子基础：定义与使用

PHP 8.4 属性钩子允许在属性声明中使用 get 和 set 关键字定义访问逻辑。

<?php

class User 
{
    public string $name {
        get => $this->name;
        set(string $value) {
            if (strlen($value) < 2) {
                throw new InvalidArgumentException('姓名至少需要2个字符');
            }
            $this->name = trim($value);
        }
    }
    
    public function __construct(string $name) 
    {
        $this->name = $name;
    }
}

$user = new User('张三');
echo $user->name; // 输出: 张三
// $user->name = '李'; // 抛出异常

钩子类型：

• get：定义读取属性时的逻辑
• set：定义设置属性时的逻辑（可以包含验证、转换）
• 支持类型声明和参数验证

3. 实战案例一：使用属性钩子构建值对象

值对象（Value Object）是不可变对象，属性钩子可以优雅地实现不可变性和验证。

<?php

class Email 
{
    public function __construct(
        public readonly string $value {
            get => $this->value;
            // 没有set钩子，实现只读
        }
    ) {
        if (!filter_var($value, FILTER_VALIDATE_EMAIL)) {
            throw new InvalidArgumentException('无效的邮箱地址');
        }
    }
    
    public function __toString(): string 
    {
        return $this->value;
    }
}

class Order 
{
    public function __construct(
        public string $orderNo {
            get => strtoupper($this->orderNo);
            set => $this->orderNo = trim($value);
        },
        public Email $customerEmail {
            get => $this->customerEmail;
            // set钩子中可以进行额外验证
            set(Email $email) {
                if ($email->value === '') {
                    throw new InvalidArgumentException('邮箱不能为空');
                }
                $this->customerEmail = $email;
            }
        }
    ) {}
}

// 使用
$email = new Email('test@example.com');
$order = new Order('ord-123', $email);
echo $order->orderNo; // 输出: ORD-123

4. 实战案例二：枚举基础与高级用法

PHP 8.1 引入了枚举，PHP 8.4 进一步增强了枚举的能力。枚举可以包含方法、实现接口、使用常量。

<?php

// 基础枚举
enum OrderStatus: string 
{
    case Pending = 'pending';
    case Paid = 'paid';
    case Shipped = 'shipped';
    case Delivered = 'delivered';
    case Cancelled = 'cancelled';
    
    // 枚举方法
    public function label(): string 
    {
        return match($this) {
            self::Pending => '待支付',
            self::Paid => '已支付',
            self::Shipped => '已发货',
            self::Delivered => '已送达',
            self::Cancelled => '已取消',
        };
    }
    
    // 判断是否可取消
    public function canCancel(): bool 
    {
        return match($this) {
            self::Pending, self::Paid => true,
            default => false,
        };
    }
    
    // 静态方法：根据值创建枚举
    public static function fromValue(string $value): self 
    {
        return match($value) {
            'pending' => self::Pending,
            'paid' => self::Paid,
            'shipped' => self::Shipped,
            'delivered' => self::Delivered,
            'cancelled' => self::Cancelled,
            default => throw new InvalidArgumentException('无效的状态: ' . $value),
        };
    }
}

// 使用枚举
$status = OrderStatus::Paid;
echo $status->label(); // 输出: 已支付
echo $status->canCancel() ? '可取消' : '不可取消'; // 输出: 可取消

// 从字符串创建
$status2 = OrderStatus::fromValue('shipped');
echo $status2->label(); // 输出: 已发货

5. 实战案例三：枚举实现接口与常量

枚举可以实现接口，这使得枚举可以与其他类型统一处理。同时枚举可以定义常量。

<?php

// 定义接口
interface HasColor 
{
    public function color(): string;
}

// 枚举实现接口
enum CardSuit: string implements HasColor 
{
    case Hearts = 'hearts';
    case Diamonds = 'diamonds';
    case Clubs = 'clubs';
    case Spades = 'spades';
    
    // 枚举常量
    public const RED_SUITS = [self::Hearts, self::Diamonds];
    public const BLACK_SUITS = [self::Clubs, self::Spades];
    
    public function color(): string 
    {
        return match($this) {
            self::Hearts, self::Diamonds => 'red',
            self::Clubs, self::Spades => 'black',
        };
    }
    
    public function symbol(): string 
    {
        return match($this) {
            self::Hearts => '♥',
            self::Diamonds => '♦',
            self::Clubs => '♣',
            self::Spades => '♠',
        };
    }
}

// 使用
$suit = CardSuit::Hearts;
echo $suit->color(); // 输出: red
echo $suit->symbol(); // 输出: ♥

// 使用枚举常量
foreach (CardSuit::RED_SUITS as $suit) {
    echo $suit->symbol() . ' ';
}
// 输出: ♥ ♦

6. 实战案例四：属性钩子与枚举结合

将属性钩子和枚举结合使用，构建类型安全的业务模型。

<?php

// 定义订单状态枚举
enum OrderStatus: string 
{
    case Pending = 'pending';
    case Paid = 'paid';
    case Shipped = 'shipped';
    case Delivered = 'delivered';
    case Cancelled = 'cancelled';
    
    public function label(): string 
    {
        return match($this) {
            self::Pending => '待支付',
            self::Paid => '已支付',
            self::Shipped => '已发货',
            self::Delivered => '已送达',
            self::Cancelled => '已取消',
        };
    }
}

// 订单类使用属性钩子和枚举
class Order 
{
    public function __construct(
        public string $orderNo {
            get => $this->orderNo;
            set => $this->orderNo = strtoupper(trim($value));
        },
        public float $amount {
            get => round($this->amount, 2);
            set(float $value) {
                if ($value <= 0) {
                    throw new InvalidArgumentException('金额必须大于0');
                }
                $this->amount = $value;
            }
        },
        private OrderStatus $status = OrderStatus::Pending {
            get => $this->status;
            set(OrderStatus $newStatus) {
                // 状态转换验证
                if (!$this->canTransitionTo($newStatus)) {
                    throw new InvalidArgumentException(
                        "不能从 {$this->status->label()} 转换到 {$newStatus->label()}"
                    );
                }
                $this->status = $newStatus;
            }
        }
    ) {}
    
    private function canTransitionTo(OrderStatus $newStatus): bool 
    {
        return match($this->status) {
            OrderStatus::Pending => in_array($newStatus, [OrderStatus::Paid, OrderStatus::Cancelled]),
            OrderStatus::Paid => in_array($newStatus, [OrderStatus::Shipped, OrderStatus::Cancelled]),
            OrderStatus::Shipped => $newStatus === OrderStatus::Delivered,
            OrderStatus::Delivered => false, // 终态
            OrderStatus::Cancelled => false, // 终态
        };
    }
    
    public function getStatusLabel(): string 
    {
        return $this->status->label();
    }
}

// 使用
$order = new Order('ord-001', 199.99);
echo $order->getStatusLabel(); // 输出: 待支付

$order->status = OrderStatus::Paid; // 正常转换
echo $order->getStatusLabel(); // 输出: 已支付

// $order->status = OrderStatus::Shipped; // 可以继续转换
// $order->status = OrderStatus::Pending; // 抛出异常：不能从已支付转换到待支付

7. 性能对比：传统方式 vs 新特性

8. 最佳实践总结

• 属性钩子适用于值对象：实现不可变性和验证逻辑
• 枚举适用于有限状态集：订单状态、用户角色、配置选项
• 枚举实现接口：让枚举与其他类型统一处理
• 属性钩子与枚举结合：构建类型安全的业务模型
• 避免过度使用：简单的属性不需要钩子，简单的常量不需要枚举

// 最佳实践示例：简单的DTO不需要属性钩子
class UserDTO 
{
    public function __construct(
        public readonly string $name,
        public readonly string $email,
    ) {}
}

// 复杂业务逻辑使用属性钩子
class Product 
{
    public float $price {
        get => $this->price;
        set(float $value) {
            if ($value < 0) {
                throw new InvalidArgumentException('价格不能为负');
            }
            $this->price = round($value, 2);
        }
    }
}

9. 总结

通过本文的案例，你掌握了PHP 8.4属性钩子和枚举高级用法的核心技术：

• 属性钩子的get/set定义与验证
• 枚举的方法、常量、接口实现
• 属性钩子与枚举结合构建业务模型
• 状态转换验证与类型安全
• 最佳实践与性能对比

PHP 8.4让代码更加简洁、类型安全且易于维护。现在就用这些新特性重构你的项目吧！

本文原创，基于PHP 8.4+。所有代码均在PHP 8.4环境中测试通过。