An in-depth analysis of the template method pattern in PHP

In the previous article "Understand the facade pattern in PHP in one article" we introduced the facade pattern in PHP. This article will take you to understand the template method pattern in PHP design pattern.

The template method pattern is also one of the patterns that we often use inadvertently. This model is the best interpretation of inheritance. When there are repeated actions in the subclass, they are extracted and placed in the parent class for unified processing. This is the simplest and most popular explanation of the template method pattern. Just like when we usually do projects, the process of each project is actually the same, including research, development, testing, deployment and online processes. In each project, the implementation of these processes will not be exactly the same. This process is like a template method, allowing us to develop according to this process every time.

Gof class diagram and explanation

GoF definition: Define the skeleton of an algorithm in an operation, while deferring some steps to subclasses . TemplateMethod allows subclasses to redefine specific steps of an algorithm without changing the structure of the algorithm.

GoF class diagram

##Code implementation

abstract class AbstractClass
{
    public function TemplateMethod()
    {
        $this->PrimitiveOperation1();
        $this->PrimitiveOperation2();
    }

    abstract public function PrimitiveOperation1();
    abstract public function PrimitiveOperation2();
}

Define an abstract class with a template method TemplateMethod(), in which we call the algorithm operation method. These algorithm abstract methods are implemented in subclasses.

class ConcreteClassA extends AbstractClass
{
    public function PrimitiveOperation1()
    {
        echo '具体类A实现方法1', PHP_EOL;
    }
    public function PrimitiveOperation2()
    {
        echo '具体类A实现方法2', PHP_EOL;
    }
}

class ConcreteClassB extends AbstractClass
{
    public function PrimitiveOperation1()
    {
        echo '具体类B实现方法1', PHP_EOL;
    }
    public function PrimitiveOperation2()
    {
        echo '具体类B实现方法2', PHP_EOL;
    }
}

Specific implementation classes, they only need to implement the algorithm defined by the parent class.

$c = new ConcreteClassA();
$c->TemplateMethod();

$c = new ConcreteClassB();
$c->TemplateMethod();

In the client call, the subclass is instantiated, but the template method of the parent class inherited by the subclass is called. Unified algorithm calls can be achieved.

I believe that anyone who has done some object-oriented development will have used the template method pattern to some extent. Because it is very common
• In some frameworks, some functional classes often have the function of initialization, and many other internal functions are called in the initialization function. This is actually an application of the template method pattern
• The template method pattern can easily implement hook functions. Just like many templates or hook functions prepared for you in open source systems. For example, some blog open source programs will reserve some advertising spaces or hook functions in special locations for users to implement on demand.
• The template method pattern is suitable for: implementing the unchanged part of an algorithm at one time, and The variable parts are left to the subclass to implement; the common behaviors in the subclass are extracted and concentrated into the parent class; the extension of the subclass is controlled;
• This model embodies a thing called the "Hollywood Law" The principle is "Don't come to us, we come to you"

In the company, I highly recommend agile project management. Of course, this does not mean traditional project management. No matter how bad it is, it's just that agile is more suitable for a short-term, flat and fast company like ours. In agile, we use the Scurm framework, which is actually a template. It defines four types of meetings, three types of people, and three tools. In the specific implementation of each project, we will abide by these rules, but the specific implementation will not be the same. For example, sometimes we iterate once a week, and sometimes we iterate once a month. Sometimes we don't need a retrospective meeting, but hold the retrospective and review meetings together. No matter what, we will carry out flexible project development based on Scurm. As a leader, I only need to call up the basic process of Scurm in each project. Therefore, the strength of the company is inseparable from everyone’s learning. Of course, useful things must be learned, shared and applied all the time! !

Full code: https://github.com/zhangyue0503/designpatterns-php/blob/master/20.template-method/source/template-method.php

Example

No more text messages. This time we implement the initialization part of a Cache class. Just like the tool classes in some frameworks mentioned above. Generally, we will use Memcached or Redis to implement Cache, so we extract a public Cache class, and then let the Cache implementation classes of Memcached and Redis inherit it. In the public class, some initialization work of the implementation class is performed through template methods. These tasks are uniformly called by the parent class. The implementation class only needs to implement the specific content of each step.

Cache class diagram

Full source code: https://github.com/zhangyue0503/designpatterns-php/ blob/master/20.template-method/source/template-method-cache.php

<?php

abstract class Cache
{
    private $config;
    private $conn;

    public function __construct()
    {
        $this->init();
    }
    public function init()
    {
        $this->GetConfig();
        $this->OpenConnection();
        $this->CheckConnection();
    }

    abstract public function GetConfig();
    abstract public function OpenConnection();
    abstract public function CheckConnection();
}

class MemcachedCache extends Cache
{
    public function GetConfig()
    {
        echo &#39;获取Memcached配置文件！&#39;, PHP_EOL;
        $this->config = &#39;memcached&#39;;
    }
    public function OpenConnection()
    {
        echo &#39;链接memcached!&#39;, PHP_EOL;
        $this->conn = 1;
    }
    public function CheckConnection()
    {
        if ($this->conn) {
            echo &#39;Memcached连接成功！&#39;, PHP_EOL;
        } else {
            echo &#39;Memcached连接失败，请检查配置项！&#39;, PHP_EOL;
        }
    }
}

class RedisCache extends Cache
{
    public function GetConfig()
    {
        echo &#39;获取Redis配置文件！&#39;, PHP_EOL;
        $this->config = &#39;redis&#39;;
    }
    public function OpenConnection()
    {
        echo &#39;链接redis!&#39;, PHP_EOL;
        $this->conn = 0;
    }
    public function CheckConnection()
    {
        if ($this->conn) {
            echo &#39;Redis连接成功！&#39;, PHP_EOL;
        } else {
            echo &#39;Redis连接失败，请检查配置项！&#39;, PHP_EOL;
        }
    }
}

$m = new MemcachedCache();

$r = new RedisCache();

Description

• We have implemented such a simple cache class. Is it very similar to the code in many frameworks?
• Subclasses only need to define their own implementation, and the rest of the repeated code is left to the parent class. If there is no parent class, they all need to implement an init() method themselves
• Of course, when you need to add other implementation classes, you only need to inherit this Cache parent class and complete your own implementation. Clients can face these implementation classes very easily because they know that they only need to call initialization first. Methods can use this class, no matter which implementation class it is, it is the same

Original address: https://juejin.cn/post/6844903989348139021

Author ：Hard-core project manager

Recommended learning: "PHP Video Tutorial"

The above is the detailed content of An in-depth analysis of the template method pattern in PHP. For more information, please follow other related articles on the PHP Chinese website!