php实现设计模式

单例模式（Singleton）

单例模式确保一个类只有一个实例，并提供全局访问点。适用于需要控制资源访问的场景，如数据库连接。

class Singleton {
    private static $instance;

    private function __construct() {}

    public static function getInstance() {
        if (!isset(self::$instance)) {
            self::$instance = new self();
        }
        return self::$instance;
    }
}

$singleton = Singleton::getInstance();

工厂模式（Factory）

工厂模式通过一个工厂类创建对象，而不是直接实例化具体类。适用于对象创建逻辑复杂的场景。

interface Product {
    public function getName();
}

class ConcreteProductA implements Product {
    public function getName() {
        return "Product A";
    }
}

class ProductFactory {
    public static function createProduct($type) {
        switch ($type) {
            case 'A':
                return new ConcreteProductA();
            default:
                throw new Exception("Invalid product type");
        }
    }
}

$product = ProductFactory::createProduct('A');

观察者模式（Observer）

观察者模式定义对象间的一对多依赖关系，当一个对象状态改变时，所有依赖它的对象都会得到通知。

interface Observer {
    public function update($data);
}

class ConcreteObserver implements Observer {
    public function update($data) {
        echo "Received update with data: " . $data . "\n";
    }
}

class Subject {
    private $observers = [];

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

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

$subject = new Subject();
$observer = new ConcreteObserver();
$subject->attach($observer);
$subject->notify("Some data");

策略模式（Strategy）

策略模式定义一系列算法，将每个算法封装起来，并使它们可以互相替换。适用于需要在运行时选择不同算法的场景。

interface Strategy {
    public function execute($a, $b);
}

class AddStrategy implements Strategy {
    public function execute($a, $b) {
        return $a + $b;
    }
}

class Context {
    private $strategy;

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

    public function executeStrategy($a, $b) {
        return $this->strategy->execute($a, $b);
    }
}

$context = new Context(new AddStrategy());
$result = $context->executeStrategy(5, 3);

适配器模式（Adapter）

适配器模式将一个类的接口转换成客户希望的另一个接口。适用于使不兼容的类能够一起工作。

interface Target {
    public function request();
}

class Adaptee {
    public function specificRequest() {
        return "Specific request";
    }
}

class Adapter implements Target {
    private $adaptee;

    public function __construct(Adaptee $adaptee) {
        $this->adaptee = $adaptee;
    }

    public function request() {
        return $this->adaptee->specificRequest();
    }
}

$adapter = new Adapter(new Adaptee());
$result = $adapter->request();

装饰器模式（Decorator）

装饰器模式动态地给一个对象添加一些额外的职责。适用于需要扩展对象功能的场景。

interface Component {
    public function operation();
}

class ConcreteComponent implements Component {
    public function operation() {
        return "ConcreteComponent";
    }
}

class Decorator implements Component {
    protected $component;

    public function __construct(Component $component) {
        $this->component = $component;
    }

    public function operation() {
        return $this->component->operation();
    }
}

class ConcreteDecorator extends Decorator {
    public function operation() {
        return parent::operation() . " decorated";
    }
}

$decorated = new ConcreteDecorator(new ConcreteComponent());
$result = $decorated->operation();

责任链模式（Chain of Responsibility）

责任链模式将请求的发送者和接收者解耦，使多个对象都有机会处理请求。适用于多个对象可以处理同一请求的场景。

abstract class Handler {
    protected $successor;

    public function setSuccessor(Handler $successor) {
        $this->successor = $successor;
    }

    abstract public function handleRequest($request);
}

class ConcreteHandlerA extends Handler {
    public function handleRequest($request) {
        if ($request === 'A') {
            return "Handled by A";
        } elseif ($this->successor !== null) {
            return $this->successor->handleRequest($request);
        }
        return null;
    }
}

$handlerA = new ConcreteHandlerA();
$result = $handlerA->handleRequest('A');

模板方法模式（Template Method）

模板方法模式定义一个操作中的算法骨架，将某些步骤延迟到子类中实现。适用于有固定流程但某些步骤可变的场景。

abstract class AbstractClass {
    public function templateMethod() {
        $this->primitiveOperation1();
        $this->primitiveOperation2();
    }

    abstract protected function primitiveOperation1();
    abstract protected function primitiveOperation2();
}

class ConcreteClass extends AbstractClass {
    protected function primitiveOperation1() {
        echo "Operation 1\n";
    }

    protected function primitiveOperation2() {
        echo "Operation 2\n";
    }
}

$concrete = new ConcreteClass();
$concrete->templateMethod();