PHP Traits 与代码复用详解
Traits 基本概念
Traits 是 PHP 5.4 引入的代码复用机制，用于解决单继承限制问题,它允许在不同类层次结构中复用方法集。
基础语法
<?php
// 定义 Trait
trait LoggerTrait {
protected $logFile = 'app.log';
public function log($message) {
echo "[LOG] " . date('Y-m-d H:i:s') . " - {$message}\n";
file_put_contents($this->logFile, $message . PHP_EOL, FILE_APPEND);
}
public function setLogFile($filename) {
$this->logFile = $filename;
}
}
// 使用 Trait
class UserModel {
use LoggerTrait;
public function save($data) {
// 保存逻辑
$this->log("User data saved: " . json_encode($data));
return true;
}
}
class ProductModel {
use LoggerTrait;
public function delete($id) {
// 删除逻辑
$this->log("Product {$id} deleted");
return true;
}
}
// 使用
$user = new UserModel();
$user->save(['name' => 'John', 'email' => 'john@example.com']);
$product = new ProductModel();
$product->delete(123);
多 Trait 组合
<?php
trait TimestampTrait {
public function getCreatedAt() {
return $this->createdAt ?? null;
}
public function setCreatedAt($timestamp) {
$this->createdAt = $timestamp;
}
}
trait SoftDeleteTrait {
public $deletedAt = null;
public function softDelete() {
$this->deletedAt = time();
$this->log("Record soft deleted");
}
public function restore() {
$this->deletedAt = null;
$this->log("Record restored");
}
public function isDeleted() {
return $this->deletedAt !== null;
}
}
class Model {
use TimestampTrait, SoftDeleteTrait, LoggerTrait;
public function __construct() {
$this->setCreatedAt(time());
}
}
// 使用
$model = new Model();
$model->softDelete();
echo $model->isDeleted() ? "Deleted" : "Active"; // Output: Deleted
解决冲突
<?php
trait A {
public function sayHello() {
echo "Hello from Trait A\n";
}
}
trait B {
public function sayHello() {
echo "Hello from Trait B\n";
}
public function sayHi() {
echo "Hi from Trait B\n";
}
}
class MyClass {
use A, B {
// 解决冲突：指定使用哪个 Trait 的方法
B::sayHello insteadof A;
// 为被覆盖的方法设置别名
A::sayHello as sayHelloFromA;
// 改变方法访问权限
B::sayHi as protected;
}
}
$obj = new MyClass();
$obj->sayHello(); // Output: Hello from Trait B
$obj->sayHelloFromA(); // Output: Hello from Trait A
// $obj->sayHi(); // Fatal error: Call to protected method
抽象方法与静态方法
<?php
trait CacheableTrait {
abstract protected function getCacheKey($id);
abstract public function refreshCache();
public static $cachePrefix = 'app:';
public function getFromCache($id) {
$key = self::$cachePrefix . $this->getCacheKey($id);
echo "Fetching from cache: {$key}\n";
return "cached_data_{$id}";
}
public static function clearAllCache() {
echo "Clearing all cache with prefix: " . self::$cachePrefix . "\n";
}
}
class UserRepository {
use CacheableTrait;
protected function getCacheKey($id) {
return "user:{$id}";
}
public function refreshCache() {
echo "Refreshing user cache\n";
}
}
// 使用
$repo = new UserRepository();
$repo->getFromCache(42); // Output: Fetching from cache: app:user:42
UserRepository::clearAllCache(); // Output: Clearing all cache with prefix: app:
属性定义
<?php
trait ConfigurableTrait {
// 定义属性
public $timeout = 30;
protected $retryCount = 3;
private $config = [];
public function setConfig($key, $value) {
$this->config[$key] = $value;
}
public function getConfig($key) {
return $this->config[$key] ?? null;
}
}
class HttpClient {
use ConfigurableTrait;
// 可以覆盖 Trait 属性初始值
public $timeout = 60;
public function request($url) {
echo "Timeout: {$this->timeout}s\n";
echo "Retry count: {$this->retryCount}\n";
}
}
// 使用
$client = new HttpClient();
$client->request('https://api.example.com');
// Output: Timeout: 60s
// Output: Retry count: 3
实际项目示例
<?php
// 数据库操作 Trait
trait DatabaseOperationsTrait {
protected $table;
protected $connection;
public function find($id) {
echo "SELECT * FROM {$this->table} WHERE id = {$id}\n";
return "{$this->table}_record_{$id}";
}
public function create(array $data) {
$fields = implode(', ', array_keys($data));
$values = "'" . implode("', '", array_values($data)) . "'";
echo "INSERT INTO {$this->table} ({$fields}) VALUES ({$values})\n";
return true;
}
public function update($id, array $data) {
$sets = [];
foreach ($data as $key => $value) {
$sets[] = "{$key} = '{$value}'";
}
$setStr = implode(', ', $sets);
echo "UPDATE {$this->table} SET {$setStr} WHERE id = {$id}\n";
return true;
}
public function delete($id) {
echo "DELETE FROM {$this->table} WHERE id = {$id}\n";
return true;
}
}
// 使用示例
class BaseModel {
protected $table;
public function __construct($table) {
$this->table = $table;
}
}
class User extends BaseModel {
use DatabaseOperationsTrait;
public function __construct() {
parent::__construct('users');
}
public function getActiveUsers() {
echo "SELECT * FROM {$this->table} WHERE status = 'active'\n";
return ['user1', 'user2'];
}
}
class Order extends BaseModel {
use DatabaseOperationsTrait;
public function __construct() {
parent::__construct('orders');
}
public function getPendingOrders() {
echo "SELECT * FROM {$this->table} WHERE status = 'pending'\n";
return ['order1', 'order2'];
}
}
// 使用
$user = new User();
$user->find(1);
$user->create(['name' => 'John', 'email' => 'john@example.com']);
$user->getActiveUsers();
$order = new Order();
$order->find(100);
$order->update(100, ['status' => 'shipped']);
$order->getPendingOrders();
最佳实践
<?php
// 1. 单一职责原则 - 每个 Trait 只做一件事
trait SerializableTrait {
public function toArray() {
return get_object_vars($this);
}
public function toJson() {
return json_encode($this->toArray());
}
}
trait ValidatableTrait {
protected $errors = [];
abstract protected function rules(): array;
public function validate($data): bool {
$this->errors = [];
foreach ($this->rules() as $field => $rules) {
foreach ($rules as $rule) {
if (!$this->validateField($data[$field] ?? null, $rule)) {
$this->errors[$field][] = "Failed {$rule} validation";
}
}
}
return empty($this->errors);
}
private function validateField($value, $rule): bool {
// 验证逻辑
return true;
}
public function getErrors(): array {
return $this->errors;
}
}
// 2. 避免过于复杂的 Trait
trait EventDispatcherTrait {
private $listeners = [];
public function addListener($event, callable $listener) {
$this->listeners[$event][] = $listener;
}
public function dispatch($event, $data = null) {
if (isset($this->listeners[$event])) {
foreach ($this->listeners[$event] as $listener) {
call_user_func($listener, $data);
}
}
}
}
// 3. 使用组合优于继承的思维
class UserService {
use LoggerTrait, CacheableTrait, ValidatableTrait;
protected $userModel;
public function __construct(UserModel $userModel) {
$this->userModel = $userModel;
}
protected function rules(): array {
return [
'email' => ['required', 'email'],
'name' => ['required', 'string']
];
}
public function createUser(array $data) {
if (!$this->validate($data)) {
return ['error' => true, 'messages' => $this->getErrors()];
}
$user = $this->userModel->create($data);
$this->log("User created: {$user->id}");
$this->dispatch('user.created', $user);
return $user;
}
}
// 使用
$service = new UserService(new UserModel());
$result = $service->createUser([
'email' => 'john@example.com',
'name' => 'John Doe'
]);
与接口配合使用
<?php
// 定义接口
interface LoggableInterface {
public function log($message);
public function getLogs(): array;
}
// Trait 实现接口
trait LoggableTrait {
private $logs = [];
public function log($message) {
$this->logs[] = [
'message' => $message,
'timestamp' => time()
];
}
public function getLogs(): array {
return $this->logs;
}
}
// 类实现接口并使用 Trait
class PaymentGateway implements LoggableInterface {
use LoggableTrait;
public function processPayment($amount) {
// 处理支付
$this->log("Processing payment: \${$amount}");
return true;
}
}
// 使用
$gateway = new PaymentGateway();
$gateway->processPayment(100.00);
print_r($gateway->getLogs());
注意事项
<?php
// 1. Trait 不能实例化
// $trait = new LoggerTrait(); // Fatal Error
// 2. Trait 可以定义常量 (PHP 8.2+)
trait HttpStatusTrait {
const HTTP_OK = 200;
const HTTP_CREATED = 201;
const HTTP_NOT_FOUND = 404;
}
// 3. 避免 Trait 过多依赖
trait DatabaseTrait {
protected $db;
// 不推荐：Trait 依赖外部类
public function __construct(PDO $db) {
$this->db = $db;
}
}
// 4. 优先考虑组合而不是 Trait
class ServiceWithCache {
private $cache;
public function __construct(CacheInterface $cache) {
$this->cache = $cache;
}
public function getData($key) {
if ($this->cache->has($key)) {
return $this->cache->get($key);
}
// 获取数据逻辑
return null;
}
}
Traits 的优势：
- 解决单继承限制
- 细粒度的代码复用
- 支持多 Trait 组合
- 可解决命名冲突
- 支持抽象方法
适用场景：
- 跨类共享通用方法（日志、缓存、验证）
- 实现接口的通用实现
- 为多个类添加相同功能
- 构建可组合的功能模块
不适用场景：
- 需要维护状态的对象（考虑组合）
- 复杂业务逻辑（考虑服务类）
- 需要大量属性的场景（考虑基类）
