Six commonly used design patterns in PHP (summary sharing)

This article brings you relevant knowledge about PHP, which mainly introduces related issues about the six major design patterns, including singleton mode, factory mode, registration tree mode, strategy Let’s take a look at the contents of mode, adapter mode and observer mode. I hope it will be helpful to everyone.

Recommended study: "PHP Video Tutorial"

Single Case Mode

Features:

Three private and one public: private static variables (to store instances), private constructors (to prevent instance creation), private cloning methods (to prevent cloning of objects) , public static method (providing instances to the outside world)

Application scenarios:

In program applications, when database operations are involved, if you connect to the database every time you operate , which will cause a lot of resource consumption. You can create a unique database connection object through the singleton mode.

<?phpclass  Singleton{
    private static $_instance;
    private function __construct(){}
    private function __clone(){}
    public static function getInstance()
    {
        if(self::$_instance instanceof Singleton){//instanceof 判断一个实例是否是某个类的对象
            self::$_instance = new Singleton();
        }
        return self::$_instance;
    }}

Factory pattern

Features:

Separates the calling object from the created object, and the caller directly requests the factory. Reduce code coupling and improve system maintainability and scalability.

Application scenario:

Provide a class with certain methods that create objects for you, so that you can use a factory class to create objects instead of using new directly. This way if you want to change the type of object created, you only need to change the factory.

//假设3个待实例化的类class Aclass{}class Bclass{}class Cclass{}class Factory{
    //定义每个类的类名
    const ACLASS = 'Aclass';
    const BCLASS = 'Bclass';
    const CCLASS = 'Cclass';
    public static function getInstance($newclass)
    {
        $class = $newclass;//真实项目中这里常常是用来解析路由，加载文件。
        return new $class;
    }}//调用方法：Factory::getInstance(Factory::ACLASS);

Registration tree mode

Features:

Registration tree mode registers object instances to a global object tree. A pattern design approach that picks from the object tree when needed.

Application:

No matter whether you generate objects through singleton mode, factory mode or a combination of the two, all of them will be "inserted" for me to register. On the tree. When I use an object, I just fetch it directly from the registration tree. This is as convenient and practical as using global variables. And the registration tree pattern also provides a very good idea for other patterns. (The following example is the combined use of singleton, factory, and registration tree)

//创建单例class Single{
    public $hash;
    static protected $ins=null;
    final protected function __construct(){
        $this->hash=rand(1,9999);
    }

    static public function getInstance(){
        if (self::$ins instanceof self) {
            return self::$ins;
        }
        self::$ins=new self();
        return self::$ins;
    }}//工厂模式class RandFactory{
    public static function factory(){
        return Single::getInstance();
    }}//注册树class Register{
    protected static $objects;
    public static function set($alias,$object){
        self::$objects[$alias]=$object;
    }
    public static function get($alias){
        return self::$objects[$alias];
    }
    public static function _unset($alias){
        unset(self::$objects[$alias]);
    }}//调用Register::set('rand',RandFactory::factory());$object=Register::get('rand');print_r($object);

Strategy pattern

Definition:

Define a series of algorithms to Encapsulate each algorithm and make them interchangeable. The Strategy pattern allows the algorithm to change independently of the clients using it.

Features:

The strategy pattern provides a way to manage related algorithm families; the strategy pattern provides a way to replace the inheritance relationship; using the strategy pattern can avoid using multiple Conditional transfer statement.

Application scenarios:

Multiple classes only differ in their behavior. You can use Strategy mode to dynamically select the specific behavior to be executed at runtime. For example, there are many strategies for going to school: walking, bus, subway...

abstract class Strategy{
    abstract function goSchool();}class Run extends Strategy{
    public function goSchool()
    {
        // TODO: Implement goSchool() method.
    }}class Subway extends Strategy{
    public function goSchool()
    {
        // TODO: Implement goSchool() method.
    }}class Bike extends Strategy{
    public function goSchool()
    {
        // TODO: Implement goSchool() method.
    }}class Context{
    protected $_stratege;//存储传过来的策略对象
    public function goSchoole()
    {
        $this->_stratege->goSchoole();
    }}//调用：$contenx = new Context();$avil_stratery = new Subway();$contenx->goSchoole($avil_stratery);

Adapter mode

Features:

Combine various completely different functions The interface is encapsulated into a unified API.

Application:

There are three database operations in PHP: MySQL, MySQLi, and PDO. You can use the adapter mode to unify different database operations into one. Same API. Similar scenarios include cache adapters, which can unify different cache functions such as memcache, redis, file, apc, etc. into a consistent one.

abstract class Toy{
    public abstract function openMouth();

    public abstract function closeMouth();}class Dog extends Toy{
    public function openMouth()
    {
        echo "Dog open Mouth\n";
    }

    public function closeMouth()
    {
        echo "Dog close Mouth\n";
    }}class Cat extends Toy{
    public function openMouth()
    {
        echo "Cat open Mouth\n";
    }

    public function closeMouth()
    {
        echo "Cat close Mouth\n";
    }}//目标角色（红）interface RedTarget{
    public function doMouthOpen();

    public function doMouthClose();}//目标角色（绿）interface GreenTarget{
    public function operateMouth($type = 0);}//类适配器角色（红）class RedAdapter implements RedTarget{
    private $adaptee;

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

    //委派调用Adaptee的sampleMethod1方法
    public function doMouthOpen()
    {
        $this->adaptee->openMouth();
    }

    public function doMouthClose()
    {
        $this->adaptee->closeMouth();
    }}//类适配器角色（绿）class GreenAdapter implements GreenTarget{
    private $adaptee;

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

    //委派调用Adaptee：GreenTarget的operateMouth方法
    public function operateMouth($type = 0)
    {
        if ($type) {
            $this->adaptee->openMouth();
        } else {
            $this->adaptee->closeMouth();
        }
    }}class testDriver{
    public function run()
    {
        //实例化一只狗玩具
        $adaptee_dog = new Dog();
        echo "给狗套上红枣适配器\n";
        $adapter_red = new RedAdapter($adaptee_dog);
        //张嘴
        $adapter_red->doMouthOpen();
        //闭嘴
        $adapter_red->doMouthClose();
        echo "给狗套上绿枣适配器\n";
        $adapter_green = new GreenAdapter($adaptee_dog);
        //张嘴
        $adapter_green->operateMouth(1);
        //闭嘴
        $adapter_green->operateMouth(0);
    }}//调用$test = new testDriver();$test->run();

Observer pattern

Features:

Observer pattern (Observer), when the state of an object changes , all objects that depend on it will be notified and updated automatically. The observer pattern implements a low-coupling, non-intrusive notification and update mechanism.

Application:

After an event occurs, a series of update operations must be performed. The traditional programming method is to add processing logic directly after the event code. When the updated logic increases, the code will become difficult to maintain. This method is coupled and intrusive, and adding new logic requires modifying the main code of the event.

// 主题接口interface Subject{
    public function register(Observer $observer);
    public function notify();}// 观察者接口interface Observer{
    public function watch();}// 主题class Action implements Subject{
    public $_observers=[];
    public function register(Observer $observer){
        $this->_observers[]=$observer;
    }

    public function notify(){
        foreach ($this->_observers as $observer) {
            $observer->watch();
        }

    }}// 观察者class Cat1 implements Observer{
    public function watch(){
        echo "Cat1 watches TV<hr>";
    }}
 class Dog1 implements Observer{
     public function watch(){
         echo "Dog1 watches TV<hr>";
     }
 }
 class People implements Observer{
     public function watch(){
         echo "People watches TV<hr>";
     }
 }// 调用实例$action=new Action();$action->register(new Cat1());$action->register(new People());$action->register(new Dog1());$action->notify();

Recommended learning: "PHP Video Tutorial"

The above is the detailed content of Six commonly used design patterns in PHP (summary sharing). For more information, please follow other related articles on the PHP Chinese website!