【Java23种设计模式】：模板方法模式

模板方法模式定义

模板方法模式属于行为型设计模式，定义一个操作中的算法骨架，将某些步骤延迟到子类中实现。模板方法使得子类可以不改变算法结构的情况下重新定义某些特定步骤。

核心思想

• 抽象类定义模板方法：抽象类中定义算法的骨架（即模板方法），包含固定流程的步骤。
• 具体步骤由子类实现：抽象类中的某些步骤可以是抽象方法，由子类具体实现。
• 钩子方法（可选）：提供默认行为，子类可选择覆盖以影响模板方法的流程。

适用场景

• 多个子类有共有的行为逻辑，但部分步骤实现不同。
• 需要控制子类扩展的流程，避免子类破坏核心结构。
• 代码复用，避免重复编写相同流程的代码。

模板方法模式结构

角色说明

1. 抽象类（AbstractClass）

   • 定义模板方法，包含算法骨架。
   • 声明抽象方法（需子类实现）或具体方法（默认实现）。

2. 具体子类（ConcreteClass）

   • 实现抽象类中的抽象方法，完成特定步骤的逻辑。

• 抽象类包含：templateMethod()（模板方法）、abstractStep1()、abstractStep2()。
• 具体子类实现：ConcreteClassA、ConcreteClassB 分别重写抽象方法。

代码实现示例

抽象类定义

public abstract class AbstractTemplate {
    // 模板方法：定义算法骨架（final 防止子类覆盖）
    public final void templateMethod() {
        step1();
        step2();
        if (hookMethod()) {
            step3();
        }
    }

    // 抽象方法：子类必须实现
    protected abstract void step1();
    protected abstract void step2();

    // 具体方法：默认实现
    protected void step3() {
        System.out.println("AbstractClass: 默认步骤3");
    }

    // 钩子方法：子类可选覆盖
    protected boolean hookMethod() {
        return true;
    }
}

具体子类实现

public class ConcreteClassA extends AbstractTemplate {
    @Override
    protected void step1() {
        System.out.println("ConcreteClassA: 实现步骤1");
    }

    @Override
    protected void step2() {
        System.out.println("ConcreteClassA: 实现步骤2");
    }

    // 覆盖钩子方法
    @Override
    protected boolean hookMethod() {
        return false; // 禁用步骤3
    }
}

public class ConcreteClassB extends AbstractTemplate {
    @Override
    protected void step1() {
        System.out.println("ConcreteClassB: 实现步骤1");
    }

    @Override
    protected void step2() {
        System.out.println("ConcreteClassB: 实现步骤2");
    }
}

客户端调用

public class Client {
    public static void main(String[] args) {
        AbstractTemplate templateA = new ConcreteClassA();
        templateA.templateMethod(); // 输出步骤1、步骤2（跳过步骤3）

        AbstractTemplate templateB = new ConcreteClassB();
        templateB.templateMethod(); // 输出步骤1、步骤2、步骤3
    }
}

模式优缺点

优点

• 提高代码复用性，封装不变部分，扩展可变部分。
• 符合开闭原则，通过子类扩展新行为，无需修改抽象类。

缺点

• 每个不同实现需定义一个子类，可能导致类数量增加。
• 父类与子类耦合较高，父类修改可能影响所有子类。

实际应用案例

1. Java Servlet 中的 service() 方法

   • HttpServlet 的 service() 是模板方法，调用 doGet()、doPost() 等由子类实现的方法。

2. Spring 的 JdbcTemplate

   • 封装数据库操作流程（如连接、执行、关闭），具体 SQL 由用户通过回调接口实现。

3. Android 的 Activity 生命周期

   • onCreate()、onStart() 等方法构成模板方法模式，子类重写特定生命周期逻辑。