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

设计模式 - 行为模式_Template Method Pattern模板方法模式在数据处理中的应用

article 2025/1/31 5:02:35

文章目录

  • 概述
  • 1. 核心思想
  • 2. 结构
  • 3. 示例代码
  • 4. 优点
  • 5. 缺点
  • 6. 适用场景
  • 7. 案例：模板方法模式在数据处理中的应用
    • 案例背景
    • UML
    • 搭建抽象基类 - 数据处理的 “总指挥”
    • 子类定制 - 适配不同供应商
      • 供应商 A 的数据处理器
      • 供应商 B 的数据处理器
    • 在业务代码中整合运用
  • 8. 总结

在这里插入图片描述

概述

模板方法模式（Template Method Pattern）是一种行为设计模式，其核心思想是：定义一个操作的算法骨架，将一些步骤的实现延迟到子类中。在软件设计中，模板方法模式通常用于处理一系列相似的操作，这些操作可以被抽象为固定的流程，而流程中的某些步骤则由子类来具体实现。

1. 核心思想

模板方法模式的核心思想可以总结为以下几点：

  • 固定流程：定义一个固定的算法流程，确保所有子类都遵循相同的步骤。
  • 可变步骤：将某些步骤的具体实现延迟到子类中，允许子类根据需求定制。
  • 代码复用：通过将通用逻辑放在父类中，减少代码重复。

2. 结构

模板方法模式通常由以下几个部分组成：

  1. 抽象类（Abstract Class）：定义算法的骨架，并包含一些抽象方法供子类实现。
  2. 具体子类（Concrete Class）：实现抽象类中的抽象方法，完成具体的业务逻辑。
  3. 模板方法（Template Method）：在抽象类中定义的一个方法，它调用了算法中的各个步骤。

3. 示例代码

一个简单的模板方法模式示例，展示如何定义一个算法骨架并在子类中实现具体步骤。

// 抽象类
abstract class AbstractClass {

    // 模板方法，定义了算法的骨架
    public final void templateMethod() {
        step1();
        step2();
        step3();
    }

    // 具体方法，子类可以直接使用
    private void step1() {
        System.out.println("执行步骤1");
    }

    // 抽象方法，子类需要实现
    protected abstract void step2();

    // 钩子方法，子类可以选择性重写
    protected void step3() {
        System.out.println("执行步骤3");
    }
}

// 具体子类A
class ConcreteClassA extends AbstractClass {

    @Override
    protected void step2() {
        System.out.println("ConcreteClassA 执行步骤2");
    }
}

// 具体子类B
class ConcreteClassB extends AbstractClass {

    @Override
    protected void step2() {
        System.out.println("ConcreteClassB 执行步骤2");
    }

    @Override
    protected void step3() {
        System.out.println("ConcreteClassB 执行步骤3");
    }
}

// 客户端代码
public class TemplateMethodPatternDemo {
    public static void main(String[] args) {
        AbstractClass classA = new ConcreteClassA();
        classA.templateMethod();

        AbstractClass classB = new ConcreteClassB();
        classB.templateMethod();
    }
}

为了防止恶意修改，模板方法通常使用final关键字修饰，避免被子类重写。

4. 优点

  • 代码复用：通过将通用逻辑放在父类中，减少了代码重复。
  • 扩展性：子类可以通过实现抽象方法来扩展算法的某些步骤，而无需修改算法的整体结构。
  • 灵活性：钩子方法（Hook Method）允许子类选择性地覆盖某些步骤，增加了灵活性。

5. 缺点

  • 复杂性：如果算法的步骤过多，可能会导致类的层次结构变得复杂。
  • 限制性：模板方法模式要求算法的步骤是固定的，这可能会限制某些场景下的灵活性。

6. 适用场景

  • 固定流程：当某个算法的流程是固定的，但某些步骤的具体实现可能不同时，可以使用模板方法模式。
  • 代码复用：当多个子类有共同的逻辑时，可以将这些逻辑提取到父类中，减少代码重复。
  • 框架设计：在框架设计中，模板方法模式常用于定义框架的核心流程，而将具体实现留给用户自定义。

7. 案例：模板方法模式在数据处理中的应用

案例背景

我们的平台需要处理来自以下两个供应商的商品数据：

  1. 供应商 A：提供 JSON 格式的商品数据，需要对商品名称进行标准化处理。
  2. 供应商 B：提供 XML 格式的商品数据，需要对商品价格进行汇率转换。

尽管数据格式和处理逻辑不同，但整体的处理流程是相同的，包括以下步骤：

  1. 数据验证：验证数据的完整性和合法性。
  2. 数据解析：将原始数据解析为内部数据结构。
  3. 数据处理：根据业务需求对数据进行处理。
  4. 数据存储：将处理后的数据存储到数据库中。

UML

在这里插入图片描述

搭建抽象基类 - 数据处理的 “总指挥”

首先，我们创建一个抽象的基类 AbstractProductDataHandler，它将定义整个数据处理流程的骨架。

public abstract class AbstractProductDataHandler {

    // 模板方法，定义了数据处理的固定流程
    public final void handleProductData(String rawData) {
        if (validateData(rawData)) {
            logStart(rawData);
            Product product = parseData(rawData);
            processProduct(product);
            saveProduct(product);
            logCompletion(product);
        } else {
            handleValidationFailure(rawData);
        }
    }

    // 抽象方法，子类需要实现数据验证逻辑
    protected abstract boolean validateData(String rawData);

    // 抽象方法，子类需要实现数据解析逻辑
    protected abstract Product parseData(String rawData);

    // 抽象方法，子类需要实现数据处理逻辑
    protected abstract void processProduct(Product product);

    // 具体方法，通用的数据存储逻辑
    private void saveProduct(Product product) {
        System.out.println("保存商品数据：" + product);
        // 实际项目中，这里会调用数据库操作
    }

    // 具体方法，记录处理开始日志
    private void logStart(String rawData) {
        System.out.println("开始处理商品数据，来源：" + getSource());
    }

    // 具体方法，记录处理完成日志
    private void logCompletion(Product product) {
        System.out.println("商品数据处理完成，结果：" + product);
    }

    // 具体方法，处理验证失败的情况
    protected void handleValidationFailure(String rawData) {
        System.out.println("数据验证失败：" + rawData);
    }

    // 抽象方法，子类需要实现以返回数据来源
    protected abstract String getSource();
}

子类定制 - 适配不同供应商

接下来，我们为每个供应商创建具体的子类，实现抽象基类中的抽象方法。

供应商 A 的数据处理器

@Component
public class SupplierADataHandler extends AbstractProductDataHandler {

    @Override
    protected boolean validateData(String rawData) {
        // 简单的 JSON 格式验证
        return rawData != null && rawData.startsWith("{") && rawData.endsWith("}");
    }

    @Override
    protected Product parseData(String rawData) {
        // 解析 JSON 数据
        // 实际项目中，可以使用 Jackson 或 Gson 等库
        Product product = new Product();
        product.setName("SupplierA Product");
        product.setPrice(100.0);
        return product;
    }

    @Override
    protected void processProduct(Product product) {
        // 对商品名称进行标准化处理
        product.setName(product.getName().toUpperCase());
    }

    @Override
    protected String getSource() {
        return "Supplier A";
    }
}

供应商 B 的数据处理器

@Component
public class SupplierBDataHandler extends AbstractProductDataHandler {

    @Override
    protected boolean validateData(String rawData) {
        // 简单的 XML 格式验证
        return rawData != null && rawData.startsWith("<") && rawData.endsWith(">");
    }

    @Override
    protected Product parseData(String rawData) {
        // 解析 XML 数据
        // 实际项目中，可以使用 JAXB 或 DOM 解析器
        Product product = new Product();
        product.setName("SupplierB Product");
        product.setPrice(200.0);
        return product;
    }

    @Override
    protected void processProduct(Product product) {
        // 对商品价格进行汇率转换
        product.setPrice(product.getPrice() * 0.85); // 假设汇率为 0.85
    }

    @Override
    protected String getSource() {
        return "Supplier B";
    }
}

在业务代码中整合运用

最后，我们在业务代码中使用这些数据处理器。通过 Spring 的依赖注入机制，我们可以轻松地切换不同的处理器。

@Service
public class ProductDataProcessingService {

    @Autowired
    private SupplierADataHandler supplierAHandler;

    @Autowired
    private SupplierBDataHandler supplierBHandler;

    public void processDataFromSupplierA(String rawData) {
        supplierAHandler.handleProductData(rawData);
    }

    public void processDataFromSupplierB(String rawData) {
        supplierBHandler.handleProductData(rawData);
    }
}

8. 总结

模板方法模式通过定义算法的骨架并将某些步骤的具体实现延迟到子类中，提供了一种灵活且可扩展的设计方式。它在代码复用、扩展性和灵活性方面具有显著优势，适用于需要固定流程但允许部分步骤自定义的场景。通过合理使用模板方法模式，可以构建出清晰、可维护且易于扩展的代码架构。
在这里插入图片描述


http://www.kler.cn/a/525500.html

相关文章：

  • 从0开始使用面对对象C语言搭建一个基于OLED的图形显示框架（基础图形库实现）
  • Java面试题2025-设计模式
  • 微服务入门（go）
  • 关联传播和 Python 和 Scikit-learn 实现
  • Solon Cloud Gateway 开发：Route 的过滤器与定制
  • 【C语言练习题】找出不是两个数组共有的元素
  • C#方法作用
  • Java基础知识总结（二十八）--可变参数（...）、静态导入、枚举
  • JMeter插件 Arrivals Thread Group 源码解析：实现原理与性能测试中的应用
  • C24.【C++ Cont】结构体
  • springboot 简化 spring开发
  • 智能家居能源管理系统：Python与AI的完美结合
  • QT设置应用程序图标
  • LeetCode：56.合并区间
  • 工业相机常用词语解释
  • Vue.js 使用 Vuex 管理组件间的共享状态
  • 【GStreamer】GstBuffer的简单分析
  • 10.7 获得程序版本信息
  • 【DeepSeek】LLM强化学习GRPO Trainer详解
  • Baklib在知识管理效率提升中的独特价值与其他产品的比较探析
  • RocketMQ 中如何实现消息的可靠传递？
  • C++，STL 简介：历史、组成、优势
  • 9.1 LangChain深度解析：大模型应用开发的“万能胶水”与核心架构设计
  • 数论问题77一一3x+1问题
  • 【deepseek实战】绿色好用，不断网
  • UE5制作视差图