模板方法模式---Template Method Pattern

Posted 2021-09-06 高高for 循环

模板方法

定义:

- 模板方法（Template Method）模式：定义一个操作中的算法的骨架，而将一些步骤延 迟到子类中。使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

- 这里的算法的结构，可以理解为你根据需求设计出来的业务流程。特定的步骤就是指那些可能在 内容上存在变数的环节。

可以看出来，模板方法模式也是为了巧妙解决变化对系统带来的影响而设计的。使用模
板方法使系统扩展性增强，最小化了变化对系统的影响

日常生活中的模板方法:

• 造房时，地基、走线、水管都一样，只有在建筑后期装修上才有差异
• 西游记里面菩萨定好的 81 难，这就是一个顶层的逻辑骨架。
• 对于汽车，车从发动到停车的顺序是相同的，不同的是引擎声、鸣笛声等
• spring 中对 MYbatis的支持，将一些已经定好的方法封装起来，比如开启事务、获取 Session、关闭 Session 等，程序员不重复写那些已经规范好的代码，直接丢一个实体就可以保存。

组成:

代码结构展示:

public class Main {
    public static void main(String[] args) {
        F f = new C1();
        f.m();
    }

}

abstract class F {
    public void m() {
        op1();
        op2();
    }

    abstract void op1();
    abstract void op2();
}

class C1 extends F {

    @Override
    void op1() {
        System.out.println("op1");
    }

    @Override
    void op2() {
        System.out.println("op2");
    }
}

• 模板方法m(),定义好了业务流程先后顺序,是先执行op1(),后执行op2().
• 至于具体的op1,op2实现逻辑和方式,可以留给子类去重写.

案例1

需求:计算加减乘除,把这四项基本运算,抽象成一个模板方法.

分析算法步骤:

1. 分离需要运算的参数
2. 对分离出来的运算,做相对应的计算

抽象计算类: AbstractCalculator

具体的计算,留给子类扩展,但算法流程步骤已经固定好

public abstract class AbstractCalculator {
    /*主方法，实现对本类其它方法的调用*/
    public final int calculate(String exp,String opt){
        int array[] = split(exp,opt);
        return calculate(array[0],array[1]);
    }

    //提取参数
    public int[] split(String exp,String opt){
        String array[] = exp.split(opt);
        int arrayInt[] = new int[2];
        arrayInt[0] = Integer.parseInt(array[0]);
        arrayInt[1] = Integer.parseInt(array[1]);
        return arrayInt;
    }

    /*被子类重写的方法*/
    abstract public int calculate(int num1,int num2);
}

具体加法类: Plus

public class Plus extends AbstractCalculator{
    @Override
    public int calculate(int num1,int num2) {
        return num1 + num2;
    }
}

测试:StrategyTest

public class StrategyTest {
    public static void main(String[] args) {
        String exp = "8+8";
        AbstractCalculator cal = new Plus();
        int result = cal.calculate(exp, "\\\\+");
        System.out.println("8+8= "+result);
    }   
}

案例 2 :读数据库表查询

读数据库表,获取jdbc连接,然后select读取表中数据,这些共性操作,完全也可以封装这些相同的步骤,到抽象类,做成模板方法,子类去继承就好.

步骤:

1. 解析参数 (包括表名,select语句,mapper文件位置)
2. 获取jdbc连接
3. 拼接查询语句
4. 查询出来的结果分装到map
5. 抽象方法,留给子类去处理查询出来的结果集

思路 :

• 以上 步骤1 到步骤4 都可以封装到抽象类的openCursor()方法里面,
• 然后子类main只需要调用this.openCursor()就可以完成以上数据库查询操作

总结

应用场景:

1. 一次性实现一个算法的不变的部分，并将可变的行为留给子类来实现；
2. 将相同处理逻辑的代码放到抽象父类中，避免代码重复；提高代码的复用性。
3. 把不变的行为写在父类上，去除子类的重复代码，提供了一个很好的代码复用平台， 符合开闭原则。

优点:

• 提高代码复用性
  将相同部分的代码放在抽象的父类中
• 提高了拓展性
  将不同的代码放入不同的子类中，通过对子类的扩展增加新的行为
• 实现了反向控制
  通过一个父类调用其子类的操作，通过对子类的扩展增加新的行为，实现了反向控制 & 符合“开闭原则”

缺点:

1. 类数目的增加，每一个抽象类都需要一个子类来实现，这样导致类的个数增加。

2. 类数量的增加，间接地增加了系统实现的复杂度。

3. 继承关系自身缺点，如果父类添加新的抽象方法，所有子类都要改一遍。

注意事项:

• 为防恶意操作，一般模板方法都加上final关键字