PHP 面向对象与设计模式：SOLID、常用模式与 Laravel 实践

// PHP 8 构造器属性提升 + 只读类
readonly class Money
{
    public function __construct(
        public readonly int $amount,
        public readonly string $currency,
    ) {}
}

// 联合类型：参数接受多种形态
public function pay(Money|CreditCard $payment): void { ... }

interface Logger {
    public function log(string $msg): void;
    public function debug(string $msg): void
    { $this->log("[DEBUG] $msg"); }   // 默认实现
}

// 坏：高层依赖具体实现，改支付方式要改业务代码
class Checkout {
    public function __construct(private StripePayment $payment) {}
}

// 好：依赖抽象接口
interface PaymentGateway {
    public function charge(int $amount): Receipt;
}
class Checkout {
    public function __construct(private PaymentGateway $payment) {}
}

final class Config {
    private static ?self $instance = null;
    public static function get(): self {
        return self::$instance ??= new self();
    }
    private function __construct() {
        $this->load(env('APP_ENV'));
    }
}

interface Notifier { public function send(string $to, string $msg): void; }

class SmsNotifier implements Notifier { ... }
class EmailNotifier implements Notifier { ... }

class NotifierFactory {
    public function create(string $type): Notifier {
        return match ($type) {
            'sms'   => new SmsNotifier(),
            'email' => new EmailNotifier(),
            default => throw new InvalidArgumentException("未知通知方式 $type"),
        };
    }
}

class QueryBuilder {
    private array $clauses = [];
    public function where(string $col, mixed $val): self {
        $this->clauses[] = "$col = ?";
        return $this;                       // 链式
    }
    public function get(): string {
        return 'WHERE ' . implode(' AND ', $this->clauses);
    }
}
$q = (new QueryBuilder())->where('a', 1)->where('b', 2);

// 老系统邮件接口
class LegacyMailer { public function sendMail(string $to, string $body): void {} }

// 适配到统一接口
class LegacyMailerAdapter implements Mailer {
    public function __construct(private LegacyMailer $inner) {}
    public function send(string $to, string $msg): void {
        $this->inner->sendMail($to, $msg);   // 翻译调用
    }
}

interface Middleware { public function handle(): void; }

class LoggingDecorator implements Middleware {
    public function __construct(private Middleware $inner) {}
    public function handle(): void {
        $start = microtime(true);
        $this->inner->handle();
        echo '耗时: ' . (microtime(true) - $start) . 's';
    }
}
$pipeline = new LoggingDecorator(new RateLimitDecorator(new RealHandler()));

interface Node { public function render(): string; }
class Leaf implements Node { ... }
class Branch implements Node {
    private array $children = [];
    public function render(): string {
        return implode('', array_map(fn($c) => $c->render(), $this->children));
    }
}

interface SortStrategy { public function sort(array &$data): void; }
class QuickSort implements SortStrategy { ... }
class BubbleSort implements SortStrategy { ... }

class Sorter {
    public function __construct(private SortStrategy $strategy) {}
    public function setStrategy(SortStrategy $s): void { $this->strategy = $s; }
    public function apply(array &$data): void { $this->strategy->sort($data); }
}

interface Subscriber {
    public function notify(string $event, array $payload): void;
}
class EventBus {
    private array $subscribers = [];
    public function subscribe(Subscriber $s): void { $this->subscribers[] = $s; }
    public function dispatch(string $event, array $payload): void {
        foreach ($this->subscribers as $s) { $s->notify($event, $payload); }
    }
}

// 订单创建后广播，日志/邮件/库存各自订阅
$bus = new EventBus();
$bus->subscribe(new EmailSubscriber());
$bus->subscribe(new InventorySubscriber());
$bus->dispatch('order.created', ['orderId' => 1]);

abstract class DataImporter {
    final public function import(): void {        // 骨架
        $data = $this->fetch();
        $this->validate($data);
        $this->persist($data);
    }
    abstract protected function fetch(): array;
    abstract protected function persist(array $data): void;
    protected function validate(array $data): void {}   // 默认空实现
}

// 不使用 DI：类内 new，测试只能真依赖
class OrderService {
    public function __construct() {
        $this->repo = new OrderRepository();
    }
}

// 使用 DI：构造注入，测试可换 fake
class OrderService {
    public function __construct(
        private OrderRepository $repo,       // 依赖被注入
    ) {}
}

// 简化容器
class Container {
    private array $bindings = [];
    public function bind(string $abstract, callable $factory): void {
        $this->bindings[$abstract] = $factory;
    }
    public function make(string $abstract): object {
        return ($this->bindings[$abstract])($this);
    }
}

$c = new Container();
$c->bind(PaymentGateway::class, fn() => new StripeGateway('sk_test_...'));
$checkout = new Checkout($c->make(PaymentGateway::class));

// 服务提供者 = 容器的「装配点」
class OrderServiceProvider extends ServiceProvider {
    public function register(): void {
        $this->app->bind(PaymentGateway::class, fn() =>
            new StripeGateway(config('payment.stripe_key')));
    }
}

// 控制器只依赖接口，换实现不动业务
class OrderController {
    public function __construct(private PaymentGateway $payment) {}
}

interface PaymentGateway {
    public function charge(Order $order): Receipt;
}

class OrderProcessor {
    public function __construct(
        private PaymentGateway $payment,
        private array $notifiers,       // Notifier[]
    ) {}

    public function process(Order $order): void {
        $receipt = $this->payment->charge($order);
        foreach ($this->notifiers as $n) {
            $n->send($order->customerEmail(), "订单 {$order->id} 支付成功");
        }
        $this->emit('order.processed', $order, $receipt);
    }
}

$bus->subscribe(new OrderConfirmationMailer());
$bus->subscribe(new StockDecrementer());
$bus->subscribe(new AnalyticsTracker());