PHP设计模式工厂模式详解

PHP设计模式工厂模式详解

工厂模式是设计模式中最常用的创建型模式之一。它把对象创建的逻辑封装起来，客户端不需要知道具体的创建过程。今天从简单工厂到抽象工厂一步步说清楚。

简单工厂是最基础的形式。用一个工厂类根据参数创建不同的对象。

```php
interface Logger
{
public function log(string $message): void;
}

class FileLogger implements Logger
{
public function __construct(private string $path) {}

public function log(string $message): void
{
file_put_contents($this->path, $message . "\n", FILE_APPEND);
}
}

class DatabaseLogger implements Logger
{
public function __construct(private PDO $pdo) {}

public function log(string $message): void
{
$stmt = $this->pdo->prepare(
"INSERT INTO logs (message, created_at) VALUES (?, NOW())"
);
$stmt->execute([$message]);
}
}

class EchoLogger implements Logger
{
public function log(string $message): void
{
echo "[" . date('Y-m-d H:i:s') . "] $message\n";
}
}

// 简单工厂
class LoggerFactory
{
public static function create(string $type): Logger
{
return match ($type) {
'file' => new FileLogger('/var/log/app.log'),
'database' => new DatabaseLogger(
new PDO('mysql:host=localhost;dbname=test', 'root', '')
),
'echo' => new EchoLogger(),
default => throw new InvalidArgumentException("不支持的日志类型: $type"),
};
}
}

// 使用
$logger = LoggerFactory::create('file');
$logger->log('用户登录成功');
$logger->log('订单创建成功');

$logger2 = LoggerFactory::create('echo');
$logger2->log('这行会显示在控制台');
?>
```

工厂方法模式把工厂本身也抽象化，每个产品对应一个工厂子类。这样新增产品不需要修改工厂类，符合开闭原则。

```php
// 工厂方法模式
interface LoggerFactoryInterface
{
public function createLogger(): Logger;
}

class FileLoggerFactory implements LoggerFactoryInterface
{
public function __construct(private string $path) {}

public function createLogger(): Logger
{
return new FileLogger($this->path);
}
}

class DatabaseLoggerFactory implements LoggerFactoryInterface
{
public function __construct(private PDO $pdo) {}

public function createLogger(): Logger
{
return new DatabaseLogger($this->pdo);
}
}

class EchoLoggerFactory implements LoggerFactoryInterface
{
public function createLogger(): Logger
{
return new EchoLogger();
}
}

// 使用工厂方法
$factory = new FileLoggerFactory('/var/log/app.log');
$logger = $factory->createLogger();
$logger->log('使用工厂方法创建的日志');
?>
```

抽象工厂模式用于创建一系列相关的产品。比如跨平台UI组件，Windows和Mac各有不同的实现。

```php
// 抽象产品
interface Button
{
public function render(): string;
public function click(): void;
}

interface Checkbox
{
public function render(): string;
public function toggle(): void;
}

interface TextField
{
public function render(): string;
public function setValue(string $value): void;
}

// Windows产品族
class WindowsButton implements Button
{
public function render(): string
{
return "确定";
}

public function click(): void
{
echo "Windows按钮被点击\n";
}
}

class WindowsCheckbox implements Checkbox
{
public function render(): string
{
return "";
}

public function toggle(): void
{
echo "Windows复选框切换\n";
}
}

// Mac产品族
class MacButton implements Button
{
public function render(): string
{
return "确定";
}

public function click(): void
{
echo "Mac按钮被点击\n";
}
}

class MacCheckbox implements Checkbox
{
public function render(): string
{
return "";
}

public function toggle(): void
{
echo "Mac复选框切换\n";
}
}

// 抽象工厂
interface UIFactory
{
public function createButton(): Button;
public function createCheckbox(): Checkbox;
public function createTextField(): TextField;
}

// Windows工厂
class WindowsUIFactory implements UIFactory
{
public function createButton(): Button
{
return new WindowsButton();
}

public function createCheckbox(): Checkbox
{
return new WindowsCheckbox();
}

public function createTextField(): TextField
{
return new class implements TextField {
private string $value = '';
public function render(): string { return ""; }
public function setValue(string $value): void { $this->value = $value; }
};
}
}

// Mac工厂
class MacUIFactory implements UIFactory
{
public function createButton(): Button
{
return new MacButton();
}

public function createCheckbox(): Checkbox
{
return new MacCheckbox();
}

public function createTextField(): TextField
{
return new class implements TextField {
private string $value = '';
public function render(): string { return ""; }
public function setValue(string $value): void { $this->value = $value; }
};
}
}

// 应用
class Application
{
private UIFactory $factory;

public function __construct(string $platform)
{
$this->factory = match ($platform) {
'windows' => new WindowsUIFactory(),
'mac' => new MacUIFactory(),
default => throw new InvalidArgumentException("不支持的平台: $platform"),
};
}

public function renderUI(): void
{
$button = $this->factory->createButton();
$checkbox = $this->factory->createCheckbox();
$textField = $this->factory->createTextField();

echo $button->render() . "\n";
echo $checkbox->render() . "\n";
echo $textField->render() . "\n";
}
}

$app = new Application('windows');
$app->renderUI();

$app2 = new Application('mac');
$app2->renderUI();
?>
```

实际项目中工厂模式最常见的用途是创建数据库连接、缓存实例或支付网关。把这些对象的创建集中管理，切换实现的时候只需要改工厂，不用改业务代码。

```php
// 支付网关工厂
interface PaymentGateway
{
public function charge(float $amount, array $params): array;
public function refund(string $transactionId): array;
}

class StripeGateway implements PaymentGateway
{
public function charge(float $amount, array $params): array
{
return ['id' => 'ch_' . uniqid(), 'amount' => $amount, 'status' => 'succeeded'];
}

public function refund(string $transactionId): array
{
return ['id' => 'rf_' . uniqid(), 'status' => 'succeeded'];
}
}

class PayPalGateway implements PaymentGateway
{
public function charge(float $amount, array $params): array
{
return ['id' => 'PAY-' . uniqid(), 'amount' => $amount, 'state' => 'approved'];
}

public function refund(string $transactionId): array
{
return ['refund_id' => 'REF-' . uniqid(), 'state' => 'completed'];
}
}

class PaymentGatewayFactory
{
private static array $configs = [];

public static function configure(string $name, string $class, array $config = []): void
{
self::$configs[$name] = ['class' => $class, 'config' => $config];
}

public static function create(string $name): PaymentGateway
{
if (!isset(self::$configs[$name])) {
throw new InvalidArgumentException("未配置的支付网关: $name");
}

$config = self::$configs[$name];
$class = $config['class'];

return new $class($config['config']);
}
}

// 配置
PaymentGatewayFactory::configure('default', StripeGateway::class);
PaymentGatewayFactory::configure('paypal', PayPalGateway::class);

// 使用
$gateway = PaymentGatewayFactory::create('default');
$result = $gateway->charge(99.99, ['currency' => 'usd']);
print_r($result);
?>
```

工厂模式和依赖注入容器配合使用效果更好。容器负责管理对象的生命周期，工厂负责创建复杂对象。用好了工厂模式，代码的扩展性和可维护性会提升很多。