PHP常用设计模式解析与应用

在PHP开发中，设计模式是提升代码可读性、可维护性和扩展性的重要工具。本文将深入解析PHP中常用的几种设计模式，并通过实际案例展示其应用。

单例模式（Singleton）

单例模式确保一个类只有一个实例，并提供一个全局访问点。这在处理数据库连接、配置管理等场景中非常有用。

class Database {
    private static $instance = null;

    private function __construct() {}

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

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

$database = Database::getInstance();

工厂模式（Factory）

工厂模式用于创建对象，但无需指定具体类。它将对象的创建逻辑封装在一个工厂类中，提高了代码的灵活性和可扩展性。

interface Product {
    public function getName();
}

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

class Factory {
    public static function createProduct($type) {
        switch ($type) {
            case 'book':
                return new Book();
            default:
                throw new Exception("Unknown product type.");
        }
    }
}

$product = Factory::createProduct('book');
echo $product->getName(); // Output: Book

观察者模式（Observer）

观察者模式允许对象在状态变化时通知其他对象。适用于事件处理、日志记录等场景。

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

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

class User implements Subject {
    private $observers = [];
    private $email;

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

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

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

    public function setEmail($email) {
        $this->email = $email;
        $this->notify();
    }

    public function getEmail() {
        return $this->email;
    }
}

class EmailLogger implements Observer {
    public function update($subject) {
        echo "EmailLogger: User email changed to " . $subject->getEmail() . "\n";
    }
}

$user = new User();
$logger = new EmailLogger();

$user->attach($logger);
$user->setEmail("example@example.com"); // Output: EmailLogger: User email changed to example@example.com

策略模式（Strategy）

策略模式定义了一系列算法，并将每个算法封装起来，使它们可以互相替换。适用于需要动态改变算法的场景。

interface SortingStrategy {
    public function sort(array $data);
}

class QuickSortStrategy implements SortingStrategy {
    public function sort(array $data) {
        sort($data);
        return $data;
    }
}

class BubbleSortStrategy implements SortingStrategy {
    public function sort(array $data) {
        // Bubble sort implementation
        $n = count($data);
        for ($i = 0; $i < $n; $i++) {
            for ($j = 0; $j < $n - $i - 1; $j++) {
                if ($data[$j] > $data[$j + 1]) {
                    $temp = $data[$j];
                    $data[$j] = $data[$j + 1];
                    $data[$j + 1] = $temp;
                }
            }
        }
        return $data;
    }
}

class Context {
    private $strategy;

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

    public function setStrategy(SortingStrategy $strategy) {
        $this->strategy = $strategy;
    }

    public function sort(array $data) {
        return $this->strategy->sort($data);
    }
}

$context = new Context(new QuickSortStrategy());
$data = [3, 1, 4, 1, 5, 9];
echo implode(", ", $context->sort($data)); // Output: 1, 1, 3, 4, 5, 9

$context->setStrategy(new BubbleSortStrategy());
echo implode(", ", $context->sort($data)); // Output: 1, 1, 3, 4, 5, 9

通过以上几种常用设计模式的