Learn PHP design patterns PHP implement template method pattern_php skills

1. Intention
Define the skeleton of an algorithm in one operation, deferring some steps to subclasses. Template Method allows subclasses to redefine certain specific steps of an algorithm without changing the structure of the algorithm [GOF95]
2. Template method pattern structure diagram

3. Main roles in the template method pattern
Abstract template (AbstractClass) role: Define one or more abstract methods for subclasses to implement. These abstract methods are called basic operations, and they are components of top-level logic.
Define a template method. This template method is generally a concrete method, which gives the skeleton of the top-level logic, and the logical composition steps are in the corresponding abstract operations, and these operations will be postponed to subclasses. At the same time, the top-level logic can also call specific implementation methods

Concrete template (ConcrteClass) role: Implement one or more abstract methods of the parent class and exist as a component of top-level logic.

Each abstract template can have multiple concrete templates corresponding to it, and each concrete template has its own implementation of abstract methods (that is, components of top-level logic), making the implementation of top-level logic different.
4. Applicable scenarios of template method mode
1. Implement the immutable part of an algorithm at once and leave the variable behavior to subclasses.
2. Common behaviors in each subclass should be extracted and concentrated into a common parent class to avoid code duplication.
3. Control subclass expansion.
5. Template method pattern and other patterns
1. Strategy mode: The template method uses inheritance to change parts of the algorithm, and the strategy mode uses delegation to change the entire algorithm. The difference is that the closure changes differently, one part changes and the other changes the whole.
2. Factory method pattern (factory method pattern): Factory Method pattern is often called by template methods.
6. Template method pattern PHP example

<&#63;php
/**
 * 抽象模板角色
 * 定义抽象方法作为顶层逻辑的组成部分，由子类实现
 * 定义模板方法作为顶层逻辑的架子，调用基本方法组装顶层逻辑
 */
abstract class AbstractClass {
 
  /**
   * 模板方法 调用基本方法组装顶层逻辑
   */
  public function templateMethod() {
    echo 'templateMethod begin.<br />';
    $this->primitiveOperation1();
    $this->primitiveOperation2();
    echo 'templateMethod end.<br />';
  }
 
  /**
   * 基本方法1
   */
  abstract protected function primitiveOperation1();
 
   /**
   * 基本方法2
   */
  abstract protected function primitiveOperation2();
}
 
/**
 * 具体模板角色
 * 实现父类的抽象方法
 */
class ConcreteClass extends AbstractClass{
  /**
   * 基本方法1
   */
  protected function primitiveOperation1() {
    echo 'primitiveOperation1<br />';
  }
 
   /**
   * 基本方法2
   */
  protected function primitiveOperation2(){
    echo 'primitiveOperation2<br />';
  }
 
}
 
/**
 * 客户端
 */
class Client {
 
   /**
   * Main program.
   */
  public static function main() {
    $class = new ConcreteClass();
    $class->templateMethod();
  }
}
 
Client::main();
&#63;>

7. Template method pattern
Template method is a basic technology for code reuse. Template method leads to a reflective control structure, which refers to the operation of a parent class calling a child class.
The implementation process: prepare an abstract class, implement part of the logic in the form of concrete methods and concrete constructors, and then declare some abstract methods to force the subclass to implement the remaining logic. Different subclasses can implement these abstract methods in different ways and thus have different implementations of the remaining logic.
8. Principles of Reconstruction
The principle that should be followed when refactoring is: move the behavior to the high end of the structure, and move the state to the low end of the structure as much as possible.
1. A class should be defined for behavior rather than state.
2. When implementing behavior, abstract states are used instead of concrete states.
3. Divide operations into layers.
4. Defer status confirmation to subclasses. In the parent class, if you need state attributes, you can call the abstract value method, and put the implementation of the abstract value method in the concrete subclass.
If the above rules can be followed, then the interface and implementation can be separated in the hierarchical structure, and abstraction and concreteness can be separated, thereby ensuring that the code can be reused to the maximum extent.

The above is the code that uses PHP to implement the template method pattern. There are also some conceptual distinctions about the template method pattern. I hope it will be helpful to everyone's learning.