设计模式：12-模板方法模式

1、豆浆制作问题

编写制作豆浆的程序，说明如下：

1）制作豆浆的流程，选材 -> 添加配料 -> 浸泡 -> 放到豆浆机打碎

2）通过添加不同的配料，可以制作出不同口味的豆浆

3）选材、浸泡和放到豆浆机打碎这几个步骤对于制作每种口味的豆浆都是一样的

4）请使用模板方法模式完成（说明：因为模板方法模式，比较简单，很容易就想到这个方案，因此就直接使用，不再使用传统的方案来引出模板方法模式）

2、模板方法模式

2.1 基本介绍

1）模板方法模式（Template Method Pattern），又叫模板模式（Template Pattern），在一个抽象类公开定义了执行它的方法的模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行

2）简单说，模板方法模式定义一个操作中的算法的骨架，而将一些步骤延迟到子类中，使得子类可以不改变一个算法的结构，就可以重定义该算法的某些特定步骤

3）这种类型的设计模式属于行为型模式。

2.2 原理类图

说明（角色及职责）：

1. AbstractClass：抽象类，类中实现了模板方法（template），定义了算法的骨架，具体子类需要去实现其他的抽象方法 operation2、3、4
2. ConcreteClass：实现抽象方法 operation2、3、4，以完成算法中特定子类的步骤

2.3 应用实例

1）要求

编写制作豆浆的程序，说明如下：

• 制作豆浆的流程，选材 -> 添加配料 -> 浸泡 -> 放到豆浆机打碎
• 通过添加不同的配料，可以制作出不同口味的豆浆
• 选材、浸泡和放到豆浆机打碎这几个步骤对于制作每种口味的豆浆都是一样的（红豆、花生）

2）思路分析和图解（类图）

3）代码实现

SoyaMilk 豆浆抽象类

package com.wenze.design.template;  
  
/**  
 * 抽象的豆浆类  
 *  
 * @author wenze  
 * @version 1.0  
 * @Date 2023-10-31 17:28:25  
 * @since 1.0  
 */
public abstract class SoyaMilk {  
    /**  
     * 模板方法，make，模板方法可以做成final，不让子类去覆盖  
     */  
    public final void make() {  
        select();  
        add();  
        soak();  
        beat();  
    }  
    /**  
     * 选材料  
     */  
    public void select() {  
        System.out.println("第一步：选择好的新鲜黄豆");  
    }  
    /**  
     * 添加不同的配料，抽象方法，子类具体实现  
     */  
    public abstract void add();  
    /**  
     * 浸泡  
     */  
    public void soak() {  
        System.out.println("第三步，黄豆和配料开始浸泡，需要3小时");  
    }  
    /**  
     * 打碎  
     */  
    public void beat() {  
        System.out.println("第四步：黄豆和配料放到豆浆机去打碎");  
    }  
}

RedBeanSoyaMilk 红豆豆浆

package com.wenze.design.template;  
  
/**  
 * 红豆豆浆  
 *  
 * @author wenze  
 * @version 1.0  
 * @Date 2023-10-31 17:31:26  
 * @since 1.0  
 */
public class RedBeanSoyMilk extends SoyaMilk {  
    /**  
     * 添加不同的配料，抽象方法，子类具体实现  
     */  
    @Override  
    public void add() {  
        System.out.println("第二步：添加上好的红豆");  
    }  
}

PeanutBeanSoyaMilk 花生豆浆

package com.wenze.design.template;  
  
/**  
 * 花生豆浆  
 *  
 * @author wenze  
 * @version 1.0  
 * @Date 2023-10-31 17:32:03  
 * @since 1.0  
 */
public class PeanutSoyaMilk extends SoyaMilk {  
    /**  
     * 添加不同的配料，抽象方法，子类具体实现  
     */  
    @Override  
    public void add() {  
        System.out.println("第二步：添加上好的花生");  
    }  
}

Client 客户端

package com.wenze.design.template;  
  
/**  
 * 客户端  
 *  
 * @author wenze  
 * @version 1.0  
 * @Date 2023-10-31 17:32:34  
 * @since 1.0  
 */
public class Client {  
    public static void main(String[] args) {  
        // 制作红豆豆浆  
        System.out.println("--制作红豆豆浆--");  
        SoyaMilk redBeanSoyaMilk = new RedBeanSoyMilk();  
        redBeanSoyaMilk.make();  
		
        // 制作花生豆浆  
        System.out.println("--制作花生豆浆--");  
        SoyaMilk peanutSoyaMilk = new PeanutSoyaMilk();  
        peanutSoyaMilk.make();  
    }  
}

2.4 钩子方法

1）在模板方法模式的父类中，我们可以定义一个方法，它默认不做任何事，子类可以视情况要不要覆盖它，该方法成为“钩子”

2）还是用上面做豆浆的例子来讲解，比如，我们还希望制作纯豆浆，不添加任何的配料，请使用钩子方法对前面的模板方法进行改造

3）代码演示：

SoyaMilk 豆浆抽象类

package com.wenze.design.template.improve;  
  
/**  
 * 抽象的豆浆类  
 *  
 * @author wenze  
 * @version 1.0  
 * @Date 2023-10-31 17:28:25  
 * @since 1.0  
 */
public abstract class SoyaMilk {  
    /**  
     * 模板方法，make，模板方法可以做成final，不让子类去覆盖  
     */  
    public final void make() {  
        select();  
        if (customerWantCondiments()) {  
            add();  
        }  
        soak();  
        beat();  
    }  
    /**  
     * 选材料  
     */  
    public void select() {  
        System.out.println("第一步：选择好的新鲜黄豆");  
    }  
    /**  
     * 添加不同的配料，抽象方法，子类具体实现  
     */  
    public abstract void add();  
    /**  
     * 浸泡  
     */  
    public void soak() {  
        System.out.println("第三步，黄豆和配料开始浸泡，需要3小时");  
    }  
    /**  
     * 打碎  
     */  
    public void beat() {  
        System.out.println("第四步：黄豆和配料放到豆浆机去打碎");  
    }  
    /**  
     * 钩子方法，决定是否需要添加配料  
     * @return boolean true 需要，false 不需要  
     */  
    public boolean customerWantCondiments() {  
        return true;  
    }  
}

PureSoyaMilk 纯豆浆类

package com.wenze.design.template.improve;  
  
/**  
 * 纯豆浆  
 *  
 * @author wenze  
 * @version 1.0  
 * @Date 2023-10-31 17:42:56  
 * @since 1.0  
 */
public class PureSoyaMilk extends SoyaMilk {  
    /**  
     * 添加不同的配料，抽象方法，子类具体实现  
     */  
    @Override  
    public void add() {  
    }    @Override  
    public boolean customerWantCondiments() {  
        return false;  
    }  
}

Client 客户端

package com.wenze.design.template.improve;  
  
/**  
 * 客户端  
 *  
 * @author wenze  
 * @version 1.0  
 * @Date 2023-10-31 17:32:34  
 * @since 1.0  
 */
public class Client {  
    public static void main(String[] args) {  
        // 制作红豆豆浆  
        System.out.println("--制作红豆豆浆--");  
        SoyaMilk redBeanSoyaMilk = new RedBeanSoyMilk();  
        redBeanSoyaMilk.make();  
		
        // 制作花生豆浆  
        System.out.println("--制作花生豆浆--");  
        SoyaMilk peanutSoyaMilk = new PeanutSoyaMilk();  
        peanutSoyaMilk.make();  
		
        // 制作纯豆浆  
        System.out.println("--制作纯豆浆--");  
        SoyaMilk pureSoyaMilk = new PureSoyaMilk();  
        pureSoyaMilk.make();  
    }  
}

3、模板方法模式在 Spring 框架应用的源码分析

1）Spring IOC 容器初始化时运用到的模板方法模式

2）代码分析 + 角色分析 + 说明类图

3）针对源码的类图

4、模板方法模式的注意事项和细节

1）基本思想是：算法只存在于一个地方，也就是在父类中，容易修改。 需要修改算法时，只要修改父类的模板方法或者已经实现的某些步骤，子类就会继承这些修改

2）实现了最大化代码复用。父类的模板方法和已实现的某些步骤会被子类继承而直接使用。

3）既统一了算法，也提供了很大的灵活性。父类的模板方法确保了算法的结构保持不变，同时由子类提供部分步骤的实现。

4）该模式的不足之处：每一个不同的实现都需要一个子类实现，导致类的个数增加，使得系统更加庞大

5）一般模板方法都加上 final 关键字，防止子类重写模板方法

6）模板方法模使用场景：当要完成在某个过程，该过程要执行一系列步骤，这一系列的步骤基本相同，但其个别步骤在实习时可能不同，通常考虑用模板方法模式来处理。