Understand the template method pattern of PHP design patterns in one article

The template method pattern is also a commonly used design pattern, which is a behavioral design pattern. Its definition is: define the skeleton of an algorithm in a method and defer some steps to subclasses. Template methods allow subclasses to redefine certain steps in the algorithm without changing the structure of the algorithm.

Scenario

Usually I get up late on weekends, so I don’t go out to buy breakfast. I might just make a bucket of instant noodles or hot and sour noodles. Noodles or Huainan beef soup. The steps for soaking instant noodles or hot and sour noodles are the same. First, you need to prepare boiling water, then use the boiling water to soak the instant noodles or hot and sour noodles, then add your own seasoning packet, and finally soak for 2 to 3 minutes. There are two steps that are exactly the same (prepare boiling water, soak for 2 to 3 minutes), and two steps are similar (soak ingredients, add respective seasoning packets).

For the above scenario, we can define an algorithm for soaking instant noodles or hot and sour noodles. This algorithm is very simple, 4 steps

• Prepare boiling water

• Soak ingredients (instant noodles or hot and sour noodles)

• Add seasoning (instant noodles and hot and sour noodles have their own seasoning packets)

• Soak in boiling water for 2~3 minutes

Now, we use the template method pattern to complete the above requirements.

First, define an abstract class, which defines the specific algorithm and each step.

abstract class Breakfast
{
    final public function prepare () {
        $this->boilWater();
        $this->brew();
        $this->addSeasoning();
        $this->wait();
    }

    public function boilWater ()
    {
        echo '准备开水' . PHP_EOL;
    }

    // 泡食材
    abstract public function brew ();

    // 加调料
    abstract public function addSeasoning ();

    public function wait ()
    {
        echo '等待2~3分钟' . PHP_EOL;
    }
}

The prepare method contains the specific algorithm. Adding final to this method prevents the method from being overridden. In addition, you can see that there are two abstract methods here, which need to be completed by future generations.

Next, let’s complete the categories of instant noodles and hot and sour noodles. These two classes need to inherit Breakfast and then complete the abstract method.

class Noodle extends Breakfast
{
    public function brew ()
    {
        echo '加入方便面' . PHP_EOL;
    }
    public function addSeasoning ()
    {
        echo '加入方便面的调料包' . PHP_EOL;
    }
}

class Powder extends Breakfast
{
    public function brew ()
    {
        echo '加入酸辣粉' . PHP_EOL;
    }
    public function addSeasoning ()
    {
        echo '加入酸辣粉的调料包' . PHP_EOL;
    }
}

The above example is a typical template method pattern. The algorithm skeleton is defined in the parent class, and the subclass completes some steps in the algorithm.

Hook

The above example reflects a common scenario in the template method pattern: reuse. In addition to reuse, the template method pattern is also an important application - extension.

The template method pattern is extended through hooks. A hook is a method declared in an abstract class, but with an empty or default implementation. The existence of hooks gives subclasses the ability to hook different points of the algorithm. It is up to the subclass to decide whether to hook it or not.

Let’s continue to explain the use of hooks through examples. Usually when I eat instant noodles, I add ham or eggs. Adding ham and eggs is uncertain, so we can hook it and let the subclass decide whether to add ham or eggs.

Modify Breakfast.php

abstract class Breakfast
{
    final public function prepare () {
        $this->boilWater();
        $this->brew();
        $this->addSeasoning();
        $this->hook();
        $this->wait();
    }


    // 省略部分方法


    // 默认不做任何事情
    public function hook () :void
    {}
}

Modify Noodle.php and rewrite the hook method

public function hook(): void
{
    echo '加入火腿和鸡蛋' . PHP_EOL;
}

Template method pattern and callback function

There are many functions in PHP that use ideas similar to the template method pattern or the strategy pattern, such as the sort() function, which encapsulates the sorting algorithm, but the specific sorting rules are completed by the callback function. Through the callback function, there is no need to create abstract classes and subclasses, which greatly reduces the amount of code.

The relationship between template method pattern, factory method pattern and strategy pattern

The factory method pattern is a special form of the template method pattern.

The template method is based on the inheritance mechanism: it allows you to change part of the algorithm by extending part of the content in the subclass.

The strategy pattern is based on the combination mechanism: You can change part of the behavior of an object by providing different strategies for the corresponding behavior.

Template methods operate at the class level, so they are static. Policies operate at the object level, thus allowing behavior to be switched at runtime.

The above is the detailed content of Understand the template method pattern of PHP design patterns in one article. For more information, please follow other related articles on the PHP Chinese website!