当前位置：首页 > article >正文

Spring框架之模板方法模式 (Template Method Pattern)

article 2025/1/19 17:21:51

模板方法模式（Template Method Pattern）详解

模板方法模式（Template Method Pattern）是一种行为型设计模式，它定义了一个算法的骨架，并允许子类在不改变算法结构的前提下重新定义算法中的某些步骤。模板方法模式的核心思想是将通用的逻辑抽取到基类中，而将个性化的实现留给子类，从而实现代码的复用和扩展。

1. 模板方法模式的定义

1.1 什么是模板方法模式？

模板方法模式定义了一个操作中的算法骨架，而将一些步骤延迟到子类中实现。模板方法使得子类可以不改变算法的结构即可重新定义算法中的某些步骤。这种模式的主要目的是复用代码，同时提供一定的灵活性来扩展特定步骤。

1.2 模板方法模式的结构

模板方法模式通常包含以下几个角色：

抽象类（AbstractClass）：定义算法的骨架，并在算法的步骤中提供一些抽象方法供子类实现。
具体类（ConcreteClass）：继承抽象类，实现抽象方法，从而完成算法的个性化步骤。
模板方法（Template Method）：通常由抽象类实现，用于定义算法的步骤，并按照顺序调用这些步骤。模板方法一般声明为 final，防止子类重写其算法步骤。

2. 模板方法模式的类图

+-------------------+
|   AbstractClass   |<-----------------------+
+-------------------+                        |
| - templateMethod()|                        |
| - step1()         |                        |
| - step2()         |                        |
+-------------------+                        |
             ^                              |
             |                              |
+-------------------+                +------------------+
| ConcreteClassA    |               | ConcreteClassB   |
+-------------------+               +------------------+
| + step1()         |               | + step2()        |
| + step2()         |               | + step1()        |
+-------------------+               +------------------+

3. 模板方法模式的实现

以下是一个简单的模板方法模式的示例。我们假设要制作不同种类的饮料，但它们的制作步骤大部分是相同的，只是某些步骤有所不同。

3.1 Java 示例代码

// 抽象类：饮料制作模板
abstract class Beverage {
    // 模板方法：定义饮料制作的步骤
    public final void prepareBeverage() {
        boilWater();
        brew();
        pourInCup();
        if (customerWantsCondiments()) { // 钩子方法
            addCondiments();
        }
        System.out.println("饮料已准备完毕！\n");
    }

    // 共有的步骤：煮沸水
    private void boilWater() {
        System.out.println("把水煮沸");
    }

    // 共有的步骤：倒入杯中
    private void pourInCup() {
        System.out.println("将饮料倒入杯中");
    }

    // 抽象方法：冲泡饮料
    abstract void brew();

    // 抽象方法：添加调料
    abstract void addCondiments();

    // 钩子方法：可选的步骤
    boolean customerWantsCondiments() {
        return true;
    }
}

// 具体类：茶的制作
class Tea extends Beverage {
    @Override
    void brew() {
        System.out.println("用沸水浸泡茶叶");
    }

    @Override
    void addCondiments() {
        System.out.println("加柠檬");
    }
}

// 具体类：咖啡的制作
class Coffee extends Beverage {
    @Override
    void brew() {
        System.out.println("用沸水冲泡咖啡");
    }

    @Override
    void addCondiments() {
        System.out.println("加牛奶和糖");
    }

    // 重写钩子方法，询问用户是否需要调料
    @Override
    boolean customerWantsCondiments() {
        return false; // 假设用户不想要额外调料
    }
}

// 测试客户端
public class TemplateMethodDemo {
    public static void main(String[] args) {
        System.out.println("准备茶:");
        Beverage tea = new Tea();
        tea.prepareBeverage();

        System.out.println("准备咖啡:");
        Beverage coffee = new Coffee();
        coffee.prepareBeverage();
    }
}

输出结果：

准备茶:
把水煮沸
用沸水浸泡茶叶
将饮料倒入杯中
加柠檬
饮料已准备完毕！

准备咖啡:
把水煮沸
用沸水冲泡咖啡
将饮料倒入杯中
饮料已准备完毕！

4. 模板方法模式的应用场景

模板方法模式在实际开发中非常常用，尤其是在以下场景下：

算法步骤稳定但实现各异：
- 例如不同种类的报表生成，各种格式的文件解析（CSV、XML、JSON）。
需要复用代码的场景：
- 例如在不同的类中有相同的逻辑，只是某些步骤不同时，可以使用模板方法模式将相同的部分抽取到基类中。
框架设计：
- 在框架开发中，模板方法模式通常被用作定义算法骨架的方法，框架的用户通过继承和扩展基类来实现自己的逻辑。

5. 模板方法模式的优缺点

5.1 优点

代码复用：将相同的逻辑抽取到基类中，减少代码重复，提高代码复用性。
灵活性：通过钩子方法和抽象方法的组合，允许子类灵活地扩展算法的部分步骤。
封装变化：将可变部分封装在子类中，实现了“开闭原则”（对扩展开放，对修改关闭）。

5.2 缺点

增加代码复杂度：如果算法步骤过多或结构复杂，模板方法模式可能会导致基类变得庞大而难以维护。
继承带来的问题：由于模板方法模式使用了继承机制，因此会带来父类和子类的紧耦合，降低系统的灵活性。

6. 模板方法模式的扩展

6.1 钩子方法（Hook Method）

钩子方法是一种可选的方法，通常在模板方法模式中用于扩展功能。子类可以选择性地重写钩子方法来改变算法的行为。

6.2 策略模式（Strategy Pattern）与模板方法模式的区别

策略模式：将算法的每个步骤都抽象成接口，通过组合的方式进行算法替换。
模板方法模式：定义一个算法的骨架，将某些步骤延迟到子类实现，适合算法步骤固定但部分实现不同的场景。

6.3 模板方法模式与工厂方法模式（Factory Method Pattern）的区别

模板方法模式：侧重于算法步骤的复用，通过继承来实现算法的多态。
工厂方法模式：侧重于对象的创建，通过工厂方法来生成对象，主要用于实例化时的灵活性。

7. 模板方法模式的实际应用示例

Spring 框架中的 JdbcTemplate：
- JdbcTemplate 类使用了模板方法模式，用于封装 JDBC 操作流程，如连接获取、SQL 执行、结果集处理等。用户只需提供 SQL 语句和处理结果集的逻辑，其余步骤由框架自动完成。
JUnit 测试框架：
- 在 JUnit 框架中，测试方法的执行顺序是固定的，例如 setUp() -> testXxx() -> tearDown()。setUp() 和 tearDown() 方法可以由用户定义，但其执行顺序由框架控制。