zoukankan html css js c++ java

设计模式【九】—— 模板方法模式/命令模式

第十三章模板方法模式

13.1 基本介绍

模板方法模式（Template Method Pattern）又叫模板模式(Template Pattern)，指在一个抽象类公开定义了执行
它的方法的模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。
简单说，模板方法模式定义一个操作中的算法的骨架，而将一些步骤延迟到子类中，使得子类可以不改变一个算法的结构，就可以重定义该算法的某些特定步骤。
这种类型的设计模式属于行为型模式。

13.2 角色及职责

AbstractClass 抽象类，类中实现了模板方法（template()），定义了算法的骨架（即大致流程），具体子类需要去实现其它的抽象方法 operationr2()、operationr3()…。
ConcreteClass 实现抽象方法 operationr2()、operationr3()…，以完成算法中特点子类的步骤。

13.3 应用实例

制作不同口味的豆浆：其中 add() 方法用以添加配料，不同的豆浆配料不同，做成抽象方法由具体子类实现。

//抽象类，表示豆浆
public abstract class SoyaMilk {

   //模板方法, make , 模板方法可以做成final , 不让子类去覆盖.
   final void make() {  
      select(); 
      if(customerWantCondiments()) { // 使用钩子方法
         addCondiments();
      }
      soak();
      beat();    
   } 
   
   void select() { //选材料
      System.out.println("第一步：选择好的新鲜黄豆  ");
   }
   
   //添加不同的配料， 抽象方法, 子类具体实现
   abstract void addCondiments();
   
   void soak() { //浸泡
      System.out.println("第三步， 黄豆和配料开始浸泡， 需要3小时 ");
   }
    
   void beat() {
      System.out.println("第四步：黄豆和配料放到豆浆机去打碎  ");
   }
   
   //钩子方法，决定是否需要添加配料
   boolean customerWantCondiments() {
      return true;
   }
}

// 具体实现类：原味豆浆
public class PureSoyaMilk extends SoyaMilk{
   @Override
   void addCondiments() {
      //空实现
   }
   // 覆盖重写钩子方法
   @Override
   boolean customerWantCondiments() {
      return false;
   }
}

// 具体实现类：红豆豆浆
public class RedBeanSoyaMilk extends SoyaMilk {
   @Override
   void addCondiments() {
      System.out.println(" 加入上好的红豆 ");
   }
}

// 具体实现类：花生豆浆
public class PeanutSoyaMilk extends SoyaMilk {
   @Override
   void addCondiments() {
      System.out.println(" 加入上好的花生 ");
   }
}

public class Client {
   public static void main(String[] args) {    
      System.out.println("----制作红豆豆浆----");
      SoyaMilk redBeanSoyaMilk = new RedBeanSoyaMilk();
      redBeanSoyaMilk.make();
      
      System.out.println("----制作花生豆浆----");
      SoyaMilk peanutSoyaMilk = new PeanutSoyaMilk();
      peanutSoyaMilk.make();
      
      System.out.println("----制作纯豆浆----");
      SoyaMilk pureSoyaMilk = new PureSoyaMilk();
      pureSoyaMilk.make();
   }
}

13.4 模板方法模式的钩子方法

在模板方法模式的父类中，可以定义一个方法，它默认不做任何事，子类可以视情况要不要覆盖它，该方法称为“钩子”。

上述实例中，如果希望制作纯豆浆，不添加任何的配料，可以使用钩子方法对前面的模板方法进行改造，如上所示。

13.5 注意事项和细节

基本思想是：算法只存在于一个地方，也就是在父类中，容易修改。需要修改算法时，只要修改父类的模板方法或者已经实现的某些步骤，子类就会继承这些修改。
实现了最大化代码复用。父类的模板方法和已实现的某些步骤会被子类继承而直接使用。
既统一了算法，也提供了很大的灵活性。父类的模板方法确保了算法的结构保持不变，同时由子类提供部分步骤的实现。
该模式的不足之处：每一个不同的实现都需要一个子类实现，导致类的个数增加，使得系统更加庞大。
一般模板方法都加上 final 关键字，防止子类重写模板方法。
使用场景：当要完成在某个过程，该过程要执行一系列步骤，这一系列的步骤基本相同，但其个别步骤在实现时可能不同，通常考虑用模板方法模式来处理。

13.6 在 Spring 框架中的应用

Spring IOC 容器初始化时运用了模板方法模式。

第十四章命令模式

14.1 基本介绍

命令模式（Command Pattern）：在软件设计中，我们经常需要向某些对象发送请求，但是并不知道请求的接收者是谁，也不知道被请求的操作是哪个，我们只需在程序运行时指定具体的请求接收者即可，此时，可以使用命令模式来进行设计。
命令模式使得请求发送者与请求接收者消除彼此之间的耦合，让对象之间的调用关系更加灵活，实现解耦。
在命令模式中，会将一个请求封装为一个对象，以便使用不同参数来表示不同的请求（即命令），同时命令模式也支持可撤销的操作。
通俗易懂的理解：将军发布命令，士兵去执行。
- 角色：将军（命令发布者）、士兵（命令的具体执行者）、命令（连接将军和士兵）。
- Invoker 是调用者（将军），Receiver 是被调用者（士兵），MyCommand 是命令，实现了 Command 接口，持有接收对象。

14.2 角色及职能

Invoker：是调用者角色
Command：是命令角色，需要执行的所有命令都在这里，可以是接口或抽象类
Receiver：接受者角色，知道如何实施和执行一个请求相关的操作
ConcreteCommand：将一个接受者对象与一个动作绑定，调用接受者相应的操作，实现 execute()

14.3 应用实例

使用命令模式完成前面的智能家电项目，即一个遥控器上有多个开关来遥控多个家电。
进行扩展时，只需要要添加具体的命令和接受者角色即可，其他不用改动。

// 接受者角色：电灯
public class LightReceiver {
   public void on() {
      System.out.println(" 电灯打开了.. ");
   } 
   public void off() {
      System.out.println(" 电灯关闭了.. ");
   }
}

//创建命令接口
public interface Command {
   //执行动作(操作)
   public void execute();
   //撤销动作(操作)
   public void undo();
}

 //没有任何命令，即空执行: 可以省掉对空判断
 //用于初始化每个按钮, 当调用空命令时，对象什么都不做
public class NoCommand implements Command {
   @Override
   public void execute() {     
   }
   @Override
   public void undo() {
   }
}

// 具体的命令：打开电灯的开关
public class LightOnCommand implements Command {
   //聚合LightReceiver
   LightReceiver light;   
   //构造器
   public LightOnCommand(LightReceiver light) {
      super();
      this.light = light;
   }    
   @Override
   public void execute() {
      //调用接收者的方法
      light.on();
   }
   @Override
   public void undo() {
      //调用接收者的方法
      light.off();
   }
}

// 具体的命令：关闭电灯的开关
public class LightOffCommand implements Command {
   // 聚合LightReceiver
   LightReceiver light;
   // 构造器
   public LightOffCommand(LightReceiver light) {
         super();
         this.light = light;
      }
   @Override
   public void execute() {
      // 调用接收者的方法
      light.off();
   }
   @Override
   public void undo() {
      // 调用接收者的方法
      light.on();
   }
}

// 调用者角色：遥控器
public class RemoteController {
   // 开 按钮的命令数组
   Command[] onCommands;
   Command[] offCommands;
   // 执行撤销的命令
   Command undoCommand;
   // 构造器，完成对按钮初始化

   public RemoteController() {
      onCommands = new Command[5];
      offCommands = new Command[5];

      for (int i = 0; i < 5; i++) {
         onCommands[i] = new NoCommand();
         offCommands[i] = new NoCommand();
      }
   }
   // 给我们的按钮设置你需要的命令
   public void setCommand(int no, Command onCommand, Command offCommand) {
      onCommands[no] = onCommand;
      offCommands[no] = offCommand;
   }
   // 按下开按钮
   public void onButtonWasPushed(int no) { // no 0
      // 找到你按下的开的按钮， 并调用对应方法
      onCommands[no].execute();
      // 记录这次的操作，用于撤销
      undoCommand = onCommands[no];
   }
   // 按下开按钮
   public void offButtonWasPushed(int no) { // no 0
      // 找到你按下的关的按钮， 并调用对应方法
      offCommands[no].execute();
      // 记录这次的操作，用于撤销
      undoCommand = offCommands[no];
   }  
   // 按下撤销按钮
   public void undoButtonWasPushed() {
      undoCommand.undo();
   }
}

// 客户端
public class Client {
   public static void main(String[] args) {
      //使用命令设计模式，完成通过遥控器，对电灯的操作
      
      //创建电灯的对象(接受者)
      LightReceiver lightReceiver = new LightReceiver();    
      //创建电灯相关的开关命令
      LightOnCommand lightOnCommand = new LightOnCommand(lightReceiver);
      LightOffCommand lightOffCommand = new LightOffCommand(lightReceiver);     
      //需要一个遥控器
      RemoteController remoteController = new RemoteController();
      //给我们的遥控器设置命令, 比如 no = 0 是电灯的开和关的操作
      remoteController.setCommand(0, lightOnCommand, lightOffCommand);      
      System.out.println("--------按下灯的开按钮-----------");
      remoteController.onButtonWasPushed(0);
      System.out.println("--------按下灯的关按钮-----------");
      remoteController.offButtonWasPushed(0);
      System.out.println("--------按下撤销按钮-----------");
      remoteController.undoButtonWasPushed();
      }
}

14.4 注意事项和细节

将发起请求的对象与执行请求的对象解耦。发起请求的对象是调用者，调用者只要调用命令对象的 execute() 方法就可以让接收者工作，而不必知道具体的接收者对象是谁、是如何实现的，命令对象会负责让接收者执行请求的动作，也就是说：”请求发起者”和“请求执行者”之间的解耦是通过命令对象实现的，命令对象起到了纽带桥梁的作用。
容易设计一个命令队列。只要把命令对象放到列队，就可以多线程的执行命令。
容易实现对请求的撤销和重做。
命令模式不足：可能导致某些系统有过多的具体命令类，增加了系统的复杂度，这点在使用的时候要注意。
空命令也是一种设计模式，它为我们省去了判空的操作。在上面的实例中，如果没有用空命令，每按下一个按键都要判空，这会给编码带来一定的麻烦。
命令模式经典的应用场景：界面的一个按钮都是一条命令、模拟 CMD（DOS 命令）订单的撤销/恢复、触发-反馈机制。

14.5 在 Spring 框架中的应用

Spring 框架的 JdbcTemplate 就使用到了命令模式：

StatementCallback 接口，类似命令接口（Command）；
class QueryStatementCallback implements StatementCallback<T>, SqlProvider ，匿名内部类，实现了命令接口，同时也充当命令接收者；
命令调用者是 JdbcTemplate , 其中 execute(StatementCallback action) 方法中，调用 action.doInStatement 方法，不同的实现 StatementCallback 接口的对象，对应不同的 doInStatemnt 实现逻辑，实现 StatementCallback 命令接口的子类还有 UpdateStatementCallback、ExecuteStatementCallback、BatchUpdateStatementCallback。

查看全文

相关阅读:
面向对象 (11)求交并集判断字符形式
 软件工程课程总结
 面向对象 (10)正则判邮箱
 面向对象 (9)计算时间差找随机数范围内规律
 面向对象 (8)字符串出现字符个数统计字母组成回文串判定
 面向对象 (7)中介买房平均数异常处理
 面向对象 (6)买房付首款
 第16周作业
 第15周作业
 迟到的第14周作业

原文地址：https://www.cnblogs.com/Songzw/p/13081015.html