项目中使用到的设计模式详解

前言：在我的新项目中使用到了多种设计模式，策略模式，模板方法模式，执行器模式，混合模式。接下来将会详细解释这几种模式。

策略模式

什么是策略模式

策略模式是一种行为设计模式，它定义了一系列算法，将每个算法封装起来，并使它们可以相互替换。策略模式让算法的变化独立于使用算法的客户端。

核心组件

• 策略接口（Strategy Interface）：定义所有支持的算法的公共接口
• 具体策略（Concrete Strategies）：实现策略接口的具体算法类
• 上下文（Context）：使用策略对象的类，维护对策略对象的引用

策略接口

定义所有代码解析器的统一方法，由于不同策略返回的类型不同，所以这里使用了泛型

public interface CodeParser<T> {
    T parserCode(String codeContent);
}

具体策略实现

两个类是具体的策略实现，各自实现了不同的解析算法

public class HtmlCodeParser implements CodeParser<HtmlCodeResult> {
    @Override
    public HtmlCodeResult parserCode(String codeContent) {
        // HTML解析的具体实现
    }
}

public class MultiFileCodeParser implements CodeParser<MultiFileCodeResult> {
    @Override
    public MultiFileCodeResult parserCode(String codeContent) {
        // 多文件解析的具体实现
    }
}

上下文

根据传入的参数选择使用哪个具体的策略

public class CodeParserExecutor {
    private static final HtmlCodeParser htmlCodeParser = new HtmlCodeParser();
    private static final MultiFileCodeParser multiFileCodeParser = new MultiFileCodeParser();

    public static Object executeParser(String codeContent, CodeGenTypeEnum codeGenType) {
        return switch (codeGenType) {
            case HTML -> htmlCodeParser.parserCode(codeContent);
            case MULTI_FILE -> multiFileCodeParser.parserCode(codeContent);
            default -> throw new RuntimeException("不支持的生成模式");
        };
    }
}

模板方法模式

什么是模板方法类

模板方法模式是一种行为设计模式，它在父类中定义一个算法的框架，允许子类在不改变算法结构的情况下重写算法的特定步骤。

模板方法模式的核心组件

• 抽象类（Abstract Class）：定义算法的骨架和基本操作
• 具体子类（Concrete Classes）：实现抽象类中的抽象方法，完成算法中特定步骤的具体实现
• 模板方法（Template Method）：定义算法步骤的最终方法，通常用final修饰

抽象类

public abstract class CodeFileSaveTemplate<T> {
    // 模板方法（final修饰，不可被子类重写）
    public final File saveCode(T result) {
        //1.验证参数是否合理
        validateResult(result);
        //2.构建文件保存目录
        String baseDirPath = buildUniqueDir();
        //3.保存文件
        saveFiles(result, baseDirPath);
        //4.返回保存的目录
        return new File(baseDirPath);
    }
    
    // 基本方法（可被子类重写）
    protected void validateResult(T result) {
        // 基本实现
    }
    
    // 基本方法（final修饰，不可重写）
    protected final String buildUniqueDir() {
        // 具体实现
    }
    
    // 基本方法（final修饰，不可重写）
    protected final void writeToFile(String dirPath,String filename,String content) {
        // 具体实现
    }
    
    // 抽象方法（必须由子类实现）
    protected abstract CodeGenTypeEnum getCodeType();
    protected abstract void saveFiles(T restult, String baseDirPath);
}

具体子类实现

// HTML文件保存子类
public class HtmlCodeFileSaveTemplate extends CodeFileSaveTemplate<HtmlCodeResult>{
    @Override
    protected CodeGenTypeEnum getCodeType() {
        return CodeGenTypeEnum.HTML;
    }

    @Override
    protected void saveFiles(HtmlCodeResult restult, String baseDirPath) {
        writeToFile(baseDirPath,"index.html",restult.getHtmlCode());
    }

    @Override
    protected void validateResult(HtmlCodeResult result) {
        super.validateResult(result);
        if(result == null || result.getHtmlCode() == null){
            throw new RuntimeException("生成HTML代码文件结果为空");
        }
    }
}

// 多文件保存子类
public class MultiFileCodeFileSaverTemplate extends CodeFileSaveTemplate<MultiFileCodeResult>{
    @Override
    protected CodeGenTypeEnum getCodeType() {
        return CodeGenTypeEnum.MULTI_FILE;
    }

    @Override
    protected void saveFiles(MultiFileCodeResult restult, String baseDirPath) {
        writeToFile(baseDirPath,"index.html",restult.getHtmlCode());
        writeToFile(baseDirPath,"style.css",restult.getCssCode());
        writeToFile(baseDirPath,"script.js",restult.getJsCode());
    }

    @Override
    protected void validateResult(MultiFileCodeResult result) {
        super.validateResult(result);
        if(StrUtil.isBlank(result.getHtmlCode())) {
            throw new BusinessException(ErrorCode.SYSTEM_ERROR, "HTML代码不能为空");
        }
    }
}

执行器类（策略模式的结合）

public class CodeFileSaveExecutor {
    private static final HtmlCodeFileSaveTemplate htmlCodeFileSaveTemplate = new HtmlCodeFileSaveTemplate();
    private static final MultiFileCodeFileSaverTemplate multiFileCodeFileSaverTemplate = new MultiFileCodeFileSaverTemplate();

    public static File executeSave(Object result, CodeGenTypeEnum codeGenType) {
        return switch(codeGenType) {
            case HTML -> htmlCodeFileSaveTemplate.saveCode((HtmlCodeResult) result);
            case MULTI_FILE -> multiFileCodeFileSaverTemplate.saveCode((MultiFileCodeResult) result);
            default -> throw new RuntimeException("不支持的生成模式");
        };
    }
}

模板方法的好处

• 代码复用：将公共代码放在父类中
• 扩展性好：子类可以重写特定步骤而不影响整体结构
• 符合开闭原则：对扩展开放，对修改关闭
• 控制反转：父类控制流程，子类实现细节

执行器模式

概念

执行器模式并不是一个标准的设计模式名称，而是一种常见的架构模式或应用模式。它通常指：

• 核心思想：将请求的执行逻辑与创建逻辑分离

• 主要作用：统一管理、调度和执行各种操作

• 典型特征：

  • 有一个中心化的执行器类

  • 通过参数来选择具体的执行策略

  • 对客户端隐藏具体的实现细节

特点

1. 统一入口
   两个执行器都提供了统一的静态方法作为入口点
2. 策略选择
   根据传入的类型选择具体的执行策略
3. 依赖管理
   执行器内部管理所有依赖的策略对象
4. 客户端简化
   客户端代码变得非常简单