Osheep

时光不回头,当下最重要。

简单易懂设计模式 之 模板方法(Template method)

现实生活中经常存在这样的场景,某件事情的基本流程已定,但每步或其中几步流程具体如何实施却可自由发挥,这种场景映射到设计模式中就是模板方法,或者Template method

使用场景

当某个流程或算法的大致流程已定,但其中的某些步骤的实现需(或最好)推迟至其子类进行实现;此时即考虑使用模板方法模式;同时在前述场景下又可进行进一步细分:

  • 流程中大概的步骤已经固定,具体流程实现者只是定制特定步骤的实现,而不改变整体的流程
  • 流程中大概的步骤已经固定,具体流程实现者不但可以定制特定步骤的实现,还能控制流程中某些步骤选择性执行

对于第二种细分场景,我们可以通过一种称之为钩子(hook)的方法进行流程控制

代码示例

首先假设有一个基本流程的定义类TemplateInterface,在基本流程方法templateMethod()中定义了执行的基本步骤,在步骤方法中,step1()step3()已有默认的实现,而step2()step4()是抽象方法,需在子类中实现,并且step4()不属于必须执行的步骤,所以就提供了一个钩子方法shouldDoStep4()以供子类控制step4()执行与否

public abstract class TemplateInterface {
       private void step1() {
            System. out.println("TemplateInterface step1" );
      }
       public abstract void step2();
      
       private void step3() {
            System. out.println("TemplateInterface step3" );
      }
      
       public abstract void step4();
      
       public boolean shouldDoStep4() {//钩子方法
             return true ;
      }
      
       public final void templateMethod() {
             //template begin
            step1();
            step2();
            step3();
             if(shouldDoStep4()){//钩子
                  step4();
            }
             //template ends
      }
}

再来看模板的第一个子类,暂且称之为子模板1,它重写了步骤方法step2()step4()以及钩子方法shouldDoStep4(),可以发现在子模板1中,step4()是需要执行的

public class TemplateImplements_1 extends TemplateInterface{

       @Override
       public void step2() {
            System. out.println("TemplateImplements_1 step2" );
      }

       @Override
       public void step4() {
            System. out.println("TemplateImplements_1 step4" );
      }

      
       public boolean shouldDoStep4() {
             return true ;
      }
}

然后来看模板的另外一个子类,暂且称之为子模板2,它也重写了步骤方法step2()step4()以及钩子方法shouldDoStep4(),不同的是,在模板2的使用场景下,step4()是不需要执行的

public class TemplateImplements_2 extends TemplateInterface{
       @Override
       public void step2() {
            System. out.println("TemplateImplements_2 step2" );
      }

       @Override
       public void step4() {
            System. out.println("TemplateImplements_2 step4" );
      }
      
       public boolean shouldDoStep4() {
             return false ;
      }
}

最后来看调用结果

public class TemplateTest {
       public static void main(String[] args) {
            TemplateInterface templateImplements_1 = new TemplateImplements_1();
          System.out.println("template 1 begin");
          templateImplements_1.templateMethod();
          System.out.println("template 1 end");
          TemplateInterface templateImplements_2 = new TemplateImplements_2();
          System.out.println();
          System.out.println("template 2 begin");
          templateImplements_2.templateMethod();
          System.out.println("template 2 end");
      }
}

//运行结果
template 1 begin
TemplateInterface step1
TemplateImplements_1 step2
TemplateInterface step3
TemplateImplements_1 step4
template 1 end

template 2 begin
TemplateInterface step1
TemplateImplements_2 step2
TemplateInterface step3
template 2 end

可以发现,模板1与模板2分别就特定步骤完成了自己的实现,并且通过钩子方法,模板2可控制自己的执行流程里没有step4()

基于模板方法模式,父类控制流程以及公共行为,子类负责具体实现,实现代码复用,同时子类还可通过hook实现反向控制,模板方法模式很好的体现了开闭原则(OCP)

点赞