设计模式⑩ ：用类来实现

一、前言

有时候不想动脑子，就懒得看源码又不像浪费时间所以会看看书，但是又记不住，所以决定开始写"抄书"系列。本系列大部分内容都是来源于《 图解设计模式》（【日】结城浩 著）。该系列文章可随意转载。

二、Command 模式

Command 模式 ：命令也是类

1. 介绍

一个类在进行工作时会调用自己或其他类的方法，虽然调用结果会反映在对象的状态中，但并不会留下工作的历史记录。这时如果我们有一个类，用来表示“请进行这项工作”的“命令”就会方便很多。每一项的工作就不再是“方法的调用”这种动态处理了，而是一个表示命令的类的实例，即可以用“物”来表示。想要管理工作的历史记录，只需要管理这些实例的集合即可。还可以随时再次执行过去的命令，或者将多个过去的命令整合成一个新的命令并执行。在设计模式中，我们称这样的命令为 Command 模式（命令模式）。

Command 有时也会被称为事件。它与事件驱动编程中的事件是一样的意思。当需要执行某个命令或事件时，我们可以先将这个命令或事件作成实例，然后按照发生顺序放入队列中，然后在队列中依次处理。

---

Command模式 登场的角色：

• Command (命令) ：Command 角色负责定义命令的接口。
• ConcreteCommand (具体的命令) ：ConcreteCommand 角色负责实现在 Command 角色中定义的接口。
• Receiver (接收者) ：Receiver 角色是 Command 角色执行命令时的对象，也可以被称其为命令接收者。
• Client (请求者) ：Client 角色负责生成 ConcreteCommand 角色并分配 Receiver 角色。
• Invoker（发动者）：Invoker 角色是开始执行命令的角色，它会调用在 Command 角色中定义的接口。

---

类图如下

---

Demo如下 ： 实现两个命令，AddCommand 执行加法，SubtractCommand 执行减法，MacroCommand 表示由多条命令整合成的命令

public interface Command {
    /**
     * 执行命令
     */
    int execute(int num1);
}

public class AddCommand implements Command {
    /**
     * 数字
     */
    private int num;

    public AddCommand(int num) {
        this.num = num;
    }

    @Override
    public int execute(int num1){
        return num1 + num;
    }
}

public class SubtractCommand implements Command {

    /**
     * 数字
     */
    private int num;

    public SubtractCommand(int num) {
        this.num = num;
    }

    @Override
    public int execute(int num1){
        return num1 - num;
    }
}

public class MacroCommand implements Command {
    /**
     * 命令栈，先入后出
     */
    private Stack<Command> commands = new Stack<>();

    /**
     * 栈执行结果
     */
    private int result;

    /**
     * 添加命令
     *
     * @param cmd
     */
    public void append(Command cmd) {
        if (cmd != this) {
            commands.push(cmd);
        }
    }

    /**
     * 删除最后一条命令 : 栈顶出栈
     */
    public void undo() {
        if (!commands.isEmpty()) {
            commands.pop();
        }
    }

    /**
     * 清除所有的命令
     */
    public void clear() {
        commands.clear();
    }

    @Override
    public int execute(int num1) {
        for (Command command : commands) {
            result = command.execute(num1);
        }
        return result;
    }
}

// 对数字10 执行 + 2 - 3 + 5 的命令操作
public class CommandDemoMain {
    public static void main(String[] args) {
        MacroCommand macroCommand = new MacroCommand();
        macroCommand.append(new AddCommand(2));
        macroCommand.append(new SubtractCommand(3));
        macroCommand.append(new AddCommand(5));
        final int result = macroCommand.execute(10);
        System.out.println("result = " + result);

    }
}

---

2.应用

• Runnable接口：Java中的Runnable接口就是一个典型的命令模式的应用。Runnable接口封装了需要执行的任务，然后可以交给线程去执行。

• Timer和TimerTask类：这两个类用于定时任务调度，TimerTask类封装了要执行的任务，然后由Timer类作为调用者执行这些任务。

• Statement接口：在Java中与数据库交互时，SQL语句被封装成Statement对象，然后由数据库驱动程序执行相应的命令。如在 JdbcTemplate#query 方法中，将具体的执行过程封装成 PreparedStatementCallback，交由 JdbcTemplate 来执行。

  	@Nullable
  	public <T> T query(
  			PreparedStatementCreator psc, @Nullable final PreparedStatementSetter pss, final ResultSetExtractor<T> rse)
  			throws DataAccessException {
  
  		Assert.notNull(rse, "ResultSetExtractor must not be null");
  		logger.debug("Executing prepared SQL query");
  		// 执行具体的SQL语句
  		return execute(psc, new PreparedStatementCallback<T>() {
  			@Override
  			@Nullable
  			public T doInPreparedStatement(PreparedStatement ps) throws SQLException {
  				ResultSet rs = null;
  				try {
  					if (pss != null) {
  						pss.setValues(ps);
  					}
  					rs = ps.executeQuery();
  					return rse.extractData(rs);
  				}
  				finally {
  					JdbcUtils.closeResultSet(rs);
  					if (pss instanceof ParameterDisposer) {
  						((ParameterDisposer) pss).cleanupParameters();
  					}
  				}
  			}
  		}, true);
  	}
  

---

---

个人使用：该部分内容是写给自己看的，帮助自身理解，因此就不交代项目背景了，读者请自行忽略（◐ˍ◑）：

• 项目A 中有个功能为数据报表功能，该功能允许内部使用人员通过执行指定命令或者编写指定SQL 来对数据库执行查询操作。此处是模仿Java执行，将指定的SQL语句封装成自定义的 Statement 对象并执行。

• 以事件的方式理解 Command 模式：即每一项的工作就不再是“方法的调用”这种动态处理了，而是一个表示命令的类的实例，那么则有如下一些工具方法的实现，当调用这些方法时，其入参中 Supplier、Runnable 等实例都是一个个类的实例，可以理解为表示命令的类的实例：

      /**
       * 属性为空时处理
       *
       * @param obj
       * @param supplier
       * @param 
       * @return
       */
      public static <T> T doIfNull(T obj, Supplier<T> supplier) {
          if (obj == null || StringUtils.isBlank(obj.toString())) {
              return supplier.get();
          }
          return obj;
      }
  
      /**
       * 在catch 下执行方法
       *
       * @param runnable
       * @param consumer
       */
      public static void runWithCatch(Runnable runnable, Consumer<Exception> consumer) {
          try {
              runnable.run();
          } catch (Exception e) {
              if (consumer != null) {
                  consumer.accept(e);
                  return;
              }
              throw e;
          }
      }
  
      /**
       * 在catch 下执行方法
       *
       * @param supplier
       * @param function
       */
      public static <T> T suppWithCatch(Supplier<T> supplier, Function<Exception, T> function) {
          try {
              return supplier.get();
          } catch (Exception e) {
              if (function != null) {
                  return function.apply(e);
              }
              throw e;
          }
      }
  

3. 总结

扩展思路

• 命令中应该包含哪些信息：这个问题没有绝对的答案，命令的目的不同，所包含的信息也不同。
• 保存历史记录：在适当的场景可以保存命令的历史记录。
• 适配器：对于一个 Command 接口来说可能存在多个命令方法需要实现，此时可以定义一个 CommandAdapter 的实现类，对所有方法有一个默认实现。后续实现继承 CommandAdapter 便只需要实现需要实现的方法即可。

---

相关的设计模式

• Composite 模式：有时会使用 Composite 模式实现宏命令（macrocommand）
• Memento 模式：有时会使用 Memento 模式来保存 Command 角色的历史记录
• Protype 模式：有时会使用 Protype 模式复制发生的事件。

---

一时的小想法，仅仅个人理解，无需在意 ：

• Interpreter 模式 中的 “迷你程序” 感觉可以使用 Command 模式，将一个个 “迷你程序” 编写为一个个 Command。

---

三、Interpreter 模式

Interpreter 模式 ：语法规则也是类

1. 介绍

在 Interpreter 模式中，程序要解决的问题会被用非常简单的“迷你语言”表述出来，即用“迷你语言”编写“迷你程序”把具体的问题表述出来。而迷你程序是无法工作的，所以我们还需要编写一个 “翻译”程序。翻译程序会理解迷你语言并解析和运行迷你程序，这段翻译程序被称为解释器。当需要解决的问题发生变化时，只需要修改迷你语言程序即可。

---

Interpreter 模式 登场的角色：

• AbstractExpression（抽象表达式）：AbstractExpression角色定义了语法树节点的共同接口
• TerminalExpression（终结符表达式）：TerminalExpression角色对应BNF中的终结符表达式。
• NonterminalExpression（非终结表达式）：NonterminalExpression角色对应BNF 中的非终结表达式
• Context（上下文）：Context 角色为解释器进行语法解析提供了必要的信息
• Client（请求者）：为了推导语法树，Client 角色会调用 TerminalExpression 角色和 NonterminalExpression 角色。

---

类图如下

2. 应用

• Jsoup 对 HTML 的解析，需要分析HTML 的各个标签内容， 其解析过程则是使用了语法树进行解析。
• 正则表达式、运算表达式 等的解析都使用到了Interpreter 模式。

---

---

个人使用：该部分内容是写给自己看的，帮助自身理解，因此就不交代项目背景了，读者请自行忽略（◐ˍ◑）：

• 项目A中 使用了 OCR 识别功能，但是OCR 识别的结果可能并不准确，因此在该项目中存在一个数据字典的功能，用户可以自定义规则，当识别结束后，会将识别内容交由数据字典功能处理，数据字典根据客户配置的规则对报文进行进一步的处理，如 字符串截取、拼接、数字类型进行加减乘除等基础运算等。这其中，对于客户自定义规则的解析使用了 Interpreter 模式 。

3. 总结

扩展思路

• 其他迷你语言：如正则表达式、检索表达式、批处理语言等

---

相关的设计模式

• Composite 模式：NonterminalExpression 角色多是递归模式，因此经常会使用 Composite 模式来实现 NonterminalExpression 角色。
• Flyweight 模式：有时会使用 Flyweight 模式来共享 TerminalExpression 角色。
• Visitor 模式：在推导出语法树后，有时会使用 Visitor 模式来访问语法树的各个节点。

---

一时的小想法，仅仅个人理解，无需在意 ：

• 在适当的某些时候，可以使用 Command 模式来编写 Interpreter 模式中的每个 “迷你程序”，最终通过 解释器 将复杂语言解释称多个 Command 命令。

---

参考文章

https://blog.csdn.net/weixin_45433817/article/details/131465270
https://blog.csdn.net/laodanqiu/article/details/132056266