学静思语

Menu

学静思语
Published on 2025-03-15 / 10 Visits
0
0

模板模式详解与应用场景

#面试准备

模板模式（Template Method Pattern）详解与应用场景

1. 模板模式解决的问题

模板模式是一种行为型设计模式，它主要解决了以下核心问题：

1.1 核心问题解决

  • 算法结构与实现分离 - 将算法的骨架与其具体步骤分离，使得子类可以重新定义算法的某些特定步骤，而不改变算法的结构
  • 代码重复 - 避免在多个子类中编写相同的代码，提高代码复用性
  • 控制扩展点 - 父类决定哪些操作是固定的，哪些是可以由子类重写的

1.2 适用场景

  • 当多个类的算法有相同的结构，只有部分步骤的实现不同时
  • 当需要控制子类扩展，只允许在特定点进行扩展时
  • 当希望通过一个统一的算法骨架来管理多个相似但又有差异的流程时

模板模式通过"好莱坞原则”（Don't call us, we'll call you）实现了反向控制，使得高层组件调用低层组件，而非低层组件调用高层组件，保证了整体流程的稳定性和一致性。

2. 模板模式的具体应用场景

2.1 Web框架生命周期管理

问题：在Spring、Django等框架中，需要管理控制器/请求处理的生命周期，但又要允许开发者自定义特定处理步骤。

应用：

// Spring MVC中的DispatcherServlet
public abstract class FrameworkServlet extends HttpServlet {
    // 模板方法，定义了处理请求的完整流程
    protected final void processRequest(HttpServletRequest request, HttpServletResponse response) {
        // 预处理
        preProcess(request, response);

        // 实际处理请求(由子类实现)
        doService(request, response);

        // 后处理
        postProcess(request, response);
    }

    // 钩子方法，允许子类扩展
    protected void preProcess(HttpServletRequest request, HttpServletResponse response) {
        // 默认实现或空实现
    }

    // 抽象方法，子类必须实现
    protected abstract void doService(HttpServletRequest request, HttpServletResponse response);

    // 钩子方法，允许子类扩展
    protected void postProcess(HttpServletRequest request, HttpServletResponse response) {
        // 默认实现或空实现
    }
}

2.2 数据导入导出系统

问题：企业需要处理各种格式(CSV、Excel、XML)的数据导入导出，但核心处理流程相似。

应用：

public abstract class DataExporter {
    // 模板方法
    public final void exportData() {
        connectToDataSource();
        extractData();
        transformData();
        writeToTarget();
        cleanup();
    }

    // 所有导出器通用的方法
    private void connectToDataSource() {
        System.out.println("连接数据源");
    }

    // 由子类实现的特定步骤
    protected abstract void extractData();
    protected abstract void transformData();

    // 由子类实现的特定步骤
    protected abstract void writeToTarget();

    // 通用的清理步骤
    private void cleanup() {
        System.out.println("清理资源");
    }
}

// CSV导出器
public class CSVExporter extends DataExporter {
    @Override
    protected void extractData() {
        System.out.println("提取数据为CSV格式");
    }

    @Override
    protected void transformData() {
        System.out.println("转换数据为CSV格式");
    }

    @Override
    protected void writeToTarget() {
        System.out.println("写入CSV文件");
    }
}

2.3 电商订单处理流程

问题：不同类型的订单(普通订单、会员订单、国际订单)处理流程基本相同，但部分步骤有差异。

应用：

public abstract class OrderProcessor {
    // 模板方法
    public final void processOrder(Order order) {
        validateOrder(order);
        calculatePrice(order);
        applyDiscount(order);

        // 钩子方法判断是否需要国际物流
        if (requiresInternationalLogistics(order)) {
            handleInternationalLogistics(order);
        }

        processPayment(order);
        notifyCustomer(order);
    }

    // 通用步骤
    private void validateOrder(Order order) {
        System.out.println("验证订单基本信息");
    }

    // 子类实现的特定步骤
    protected abstract void calculatePrice(Order order);

    // 带默认实现的钩子方法
    protected void applyDiscount(Order order) {
        // 默认无折扣
    }

    // 钩子方法
    protected boolean requiresInternationalLogistics(Order order) {
        return false; // 默认不需要国际物流
    }

    // 特定情况才会执行的方法
    private void handleInternationalLogistics(Order order) {
        System.out.println("处理国际物流");
    }

    // 通用步骤
    private void processPayment(Order order) {
        System.out.println("处理支付");
    }

    // 可能被子类覆盖的方法
    protected void notifyCustomer(Order order) {
        System.out.println("通知客户订单状态");
    }
}

2.4 单元测试框架

问题：测试框架需要统一的测试执行流程，但允许开发者自定义测试内容和断言。

应用：

# JUnit/PyTest等测试框架的简化实现
class TestCase:
    # 模板方法
    def run_test(self):
        self.set_up()

        try:
            self.test_implementation()
        except Exception as e:
            self.handle_exception(e)
        finally:
            self.tear_down()

    # 测试前准备，可被重写
    def set_up(self):
        print("准备测试环境")

    # 子类必须实现的具体测试
    def test_implementation(self):
        raise NotImplementedError("必须在子类中实现测试方法")

    # 异常处理，可被重写
    def handle_exception(self, exception):
        print(f"测试失败: {exception}")

    # 测试后清理，可被重写
    def tear_down(self):
        print("清理测试环境")

2.5 构建工具的构建流程

问题：不同项目的构建过程有相似的步骤(编译、测试、打包)，但具体实现有差异。

应用：

// 类似Maven、Gradle的构建系统
abstract class Builder {
    // 模板方法
    public final build(): void {
        this.initialize();
        this.compile();

        if (this.shouldRunTests()) {
            this.runTests();
        }

        this.package();
        this.deploy();
        this.generateReports();
    }

    private initialize(): void {
        console.log("初始化构建环境");
    }

    // 抽象方法，由具体构建器实现
    protected abstract compile(): void;

    // 钩子方法，决定是否运行测试
    protected shouldRunTests(): boolean {
        return true; // 默认运行测试
    }

    protected runTests(): void {
        console.log("运行测试");
    }

    // 抽象方法，由具体构建器实现
    protected abstract package(): void;

    // 钩子方法，可被覆盖
    protected deploy(): void {
        // 默认不部署
    }

    // 具有默认实现，可被覆盖
    protected generateReports(): void {
        console.log("生成基本构建报告");
    }
}

3. 模板模式的价值

在这些场景中，模板模式：

  1. 提供了标准化流程 - 确保关键步骤不会被遗漏或顺序错乱
  2. 减少了重复代码 - 将通用逻辑放在父类，只有变化部分需要在子类中实现
  3. 控制了扩展点 - 明确哪些步骤是必须的，哪些是可选的，哪些允许自定义
  4. 简化了开发 - 开发者只需关注特定业务逻辑，而不必理解整个流程的复杂性
  5. 提高了维护性 - 算法的骨架集中在一处，便于全局修改和维护

4. 实现要点

在实现模板模式时，有几个关键点需要注意：

  1. 模板方法应设为final - 防止子类覆盖，保证算法骨架的完整性
  2. 区分抽象方法和钩子方法 - 抽象方法必须由子类实现，钩子方法可选实现
  3. 合理使用访问修饰符 - 通常模板方法为public，具体步骤为protected，不希望子类重写的方法为private
  4. 遵循单一职责原则 - 每个步骤方法应专注于完成单一职责

通过这种方式，模板模式在保持核心算法结构不变的同时，为不同实现提供了灵活性，成为了处理多变业务流程的强大工具。

Spring Framework ...
事务(Transaction)详细解释

Comment