消除代码重复：PHP 设计模式的实用指南

工厂方法模式

工厂方法模式定义了一个接口，用于创建产品对象，而将创建实际对象的逻辑委派给子类。这样做可以将产品类的创建分离，使其更易于扩展，而不破坏客户端代码。

interface Product
{
    public function operation();
}

class ConcreteProductA implements Product
{
    public function operation()
    {
        // ...
    }
}

class ConcreteProductB implements Product
{
    public function operation()
    {
        // ...
    }
}

class Creator
{
    public function factoryMethod(): Product
    {
        return new ConcreteProductA(); // 可根据需要返回不同的具体产品
    }
}

$product = (new Creator())->factoryMethod();
$product->operation();

单例模式

单例模式确保类只能实例化一次。这对于控制全局状态或资源访问非常有用。

class Singleton
{
    private static $instance;

    private function __construct() {}
    private function __clone() {}
    private function __wakeup() {}

    public static function getInstance(): Singleton
    {
        if (self::$instance === null) {
            self::$instance = new Singleton();
        }

        return self::$instance;
    }
}

$instance1 = Singleton::getInstance();
$instance2 = Singleton::getInstance();

if ($instance1 === $instance2) {
    // 始终返回同一个实例
}

策略模式

策略模式定义了一组相关的算法，并使它们易于互换。这是一种良好的实践，当我们需要根据不同的场景修改算法的行为时。

interface Strategy
{
    public function operation();
}

class ConcreteStrategyA implements Strategy
{
    public function operation()
    {
        // ...
    }
}

class ConcreteStrategyB implements Strategy
{
    public function operation()
    {
        // ...
    }
}

class Context
{
    private $strategy;

    public function __construct(Strategy $strategy)
    {
        $this->strategy = $strategy;
    }

    public function executeStrategy()
    {
        $this->strategy->operation();
    }
}

$context = new Context(new ConcreteStrategyA());
$context->executeStrategy(); // 使用策略 A

$context = new Context(new ConcreteStrategyB());
$context->executeStrategy(); // 使用策略 B

观察者模式

观察者模式定义了一个对象（主题），它可以存储一组依赖于它的对象（观察者）。当主题的状态发生变化时，它会自动通知所有观察者。

interface Subject
{
    public function attach(Observer $observer);
    public function detach(Observer $observer);
    public function notify();
}

class ConcreteSubject implements Subject
{
    private $observers = [];
    private $state;

    public function attach(Observer $observer)
    {
        $this->observers[] = $observer;
    }

    public function detach(Observer $observer)
    {
        $index = array_search($observer, $this->observers);
        if ($index !== false) {
            unset($this->observers[$index]);
        }
    }

    public function notify()
    {
        foreach ($this->observers as $observer) {
            $observer->update();
        }
    }

    public function setState($state)
    {
        $this->state = $state;
        $this->notify();
    }

    public function getState()
    {
        return $this->state;
    }
}

interface Observer
{
    public function update();
}

class ConcreteObserver implements Observer
{
    private $state;

    public function update()
    {
        // 拉取主题的最新状态
        $subject = $this->getSubject();
        $this->state = $subject->getState();

        // ...
    }

    protected function getSubject(): Subject
    {
        // 获取主题的引用（实现可能因具体场景而异）
    }
}

$subject = new ConcreteSubject();
$observer1 = new ConcreteObserver();
$observer2 = new ConcreteObserver();

$subject->attach($observer1);
$subject->attach($observer2);

$subject->setState("新状态"); // 通知观察者状态已更改

通过采用这些设计模式，可以消除代码重复，提高代码的可读性、可维护性和可扩展性。它们提供了灵活的解决方案，使开发人员能够根据不同的场景定制和重用代码。