15.命令模式

命令模式

1 . 智能生活项目需求

我们买了一套智能家电，有照明灯、风扇、冰箱、洗衣机，我们只要在手机上安装 app 就可以控制对这些家电工作。
这些智能家电来自不同的厂家，我们不想针对每一种家电都安装一个 App，分别控制，我们希望只要一个 app 就可以控制全部智能家电。
要实现一个 app 控制所有智能家电的需要，则每个智能家电厂家都要提供一个统一的接口给 app 调用，这时就可以考虑使用命令模式。
命令模式可将“动作的请求者”从“动作的执行者” 对象中解耦出来。
在我们的例子中，动作的请求者是手机 app，动作的执行者是每个厂商的一个家电产品。

2 . 命令模式基本介绍

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

3 . 命令模式原理类图

Invoker：是调用者角色，里面聚合了一个 Command实现类的对象
Command：是命令角色，用于定义接口规范，需要执行的所有命令都在这里，可以是接口或抽象类
Receiver：接收者角色，知道如何实施和执行一个请求相关的操作
ConcreteCommand：具体的命令角色，实现(或继承)Command，将一个接收者对象与一个动作绑定，调用接受者相应的操作
将 Command 的具体实现类与 Invoker 聚合，将 Receiver 与Command 的具体实现类聚合，从而将 Invoker(命令调用者)和 Receiver(命令执行者)解耦

3 . 命令模式原理类图

controller：是调用者角色，里面聚合了一个 Command 实现类的对象
Command：是命令角色，用于定义接口规范，需要执行的所有命令都在这里，可以是接口或抽象类
Receiver：接收者角色，知道如何实施和执行一个请求相关的操作
ConcreteCommand：具体的命令角色，实现(或继承) Command，将一个接收者对象与一个动作绑定，调用接受者相应的操作
将 Command 的具体实现类与 Controller 聚合，将 Receiver 与 Command 的具体实现类聚合，从而将 Controller(命令调用者)和 Receiver(命令执行者)解耦

在这里插入图片描述

4 . 命令模式解决智能生活项目

应用实例要求

编写程序，使用命令模式完成前面的智能家电项目
在这里插入图片描述

代码实现:

1.Command：定义命令的规范


/**
 * Created with IntelliJ IDEA.
 *
 * @Author: compass
 * @Date: 2021-09-30-12:36
 * @Version:1.0
 * @Description: 定义执行和撤销行为
 */
public interface Command {
    
    
    /**
     * 执行某个操作，由命令连接器去实现
     */
    void execute();

    /**
     *  取消某个操作，由命令连接器去实现
     */
    void undo();
}

2.LightOnCommand：打开电灯的命令类，该类实现了 Command 接口，并且聚合了一个 LightReceiver 的实现类，用于操作电灯的开、关

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: compass
 * @Date: 2021-09-30-12:35
 * @Version:1.0
 * @Description: 打开命令的实现类，并且实现执行和撤销功能 具体命令角色）
 */
public class LightOnCommand implements Command {
    
    
    // 聚合 LightReceiver
    LightReceiver lightReceiver;
    /**
     * 执行某个操作，由命令连接器去实现
     */
   @Override
   public  void execute(){
    
    
    // 调用接收者的方法
    lightReceiver.on();
   }

    /**
     *  取消某个操作，由命令连接器去实现
     */
    @Override
    public void undo() {
    
    
    // 调用接收者的方法
    lightReceiver.off();
    }
    // 利用构造器给 lightReceiver 初始化值
    public LightOnCommand(LightReceiver receiver){
    
    
        this.lightReceiver=receiver;
    }

}

3.LightOffCommand：关闭电灯的命令类，该类实现了 Command 接口，并且聚合了一个 LightReceiver 的实现类，用于操作电灯的开、关

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: compass
 * @Date: 2021-09-30-12:35
 * @Version:1.0
 * @Description: 关闭命令的实现类，并且实现执行和撤销功能（具体命令角色）
 */
public class LightOffCommand implements Command {
    
    
    // 聚合 LightReceiver
    LightReceiver lightReceiver;
    /**
     * 执行某个操作，由命令连接器去实现
     */
   @Override
   public  void execute(){
    
    
    // 调用接收者的方法
    lightReceiver.off();
   }

    /**
     *  取消某个操作，由命令连接器去实现
     */
    @Override
    public void undo() {
    
    
    // 调用接收者的方法
    lightReceiver.on();
    }
    // 利用构造器给 lightReceiver 初始化值
    public  LightOffCommand (LightReceiver receiver){
    
    
        this.lightReceiver=receiver;
    }

}

4.NoCommand：空命令，该类在 RemoteController 中用于初始化命令按钮，这样就不用做空指针判断

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: compass
 * @Date: 2021-09-30-13:22
 * @Version:1.0
 * @Description: 没有任何命令，空执行：用于初始化每个按钮
 */
public class NoCommand implements Command{
    
    

    @Override
    public void execute() {
    
    

    }

    @Override
    public void undo() {
    
    

    }
}

5.LightReceiver：命令执行者，用于操作电灯的开、关

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: compass
 * @Date: 2021-09-30-12:35
 * @Version:1.0
 * @Description: 命令的接收者，去执行相应的指令
 */
public class LightReceiver {
    
    

    public void on(){
    
    
        System.out.println("light open");
    }

    public void off(){
    
    
        System.out.println("light off");
    }
}

6.RemoteController：命令的发出者(Controller)，聚合了 Command 的实现类，在 RemoteController 中调用 Command 实现类的方法控制设备的开、关

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: compass
 * @Date: 2021-09-30-13:26
 * @Version:1.0
 * @Description:
 */
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();
        }
    }

    /**
     *
     * @param no 按钮编号
     * @param onCommand 打开命令
     * @param offCommand 关闭命令
     */
    public void setOnCommand(int no,Command onCommand,Command offCommand){
    
    
        onCommands[no]=onCommand;
        offCommands[no]=offCommand;
    }

    /**
     * 按下开按钮
     * @param no 按钮编号
     */
    public void onButtonWasPushed(int no){
    
    
        // 找到对应的按钮，并调用开的按钮
        onCommands[no].execute();
        // 记录最后一次的操作，用于撤销
        undoCommand=onCommands[no];
    }

    /**
     * 按下关按钮
     * @param no 按钮编号
     */
    public void offButtonWasPushed(int no){
    
    
        // 找到对应的按钮，并调用关的按钮
        offCommands[no].execute();
        // 记录最后一次的操作，用于撤销
        undoCommand=offCommands[no];
    }

    public void undoButtonWasPushed(){
    
    
        undoCommand.undo();
    }
}

6.Client：测试代码

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: compass
 * @Date: 2021-09-30-13:39
 * @Version:1.0
 * @Description: 通过设计模式，完成遥控器对电灯的操作
 */
public class Client1 {
    
    
    public static void main(String[] args) {
    
    
        // 创建电灯对象
        LightReceiver lightReceiver = new LightReceiver();

        // 创建电灯相关的开关命令
        LightOffCommand lightOffCommand = new LightOffCommand(lightReceiver);
        LightOnCommand  lightOnCommand = new LightOnCommand(lightReceiver);

        // 需要一个遥控器
        RemoteController remoteController = new RemoteController();

        // 给我们的遥控器设置命令，比如no=0 是电灯的开关操作
        remoteController.setOnCommand(0,lightOnCommand,lightOffCommand);

        System.out.println("--------电灯的打开-----------");
        remoteController.onButtonWasPushed(0);
        System.out.println("--------电灯的关闭-----------");
        remoteController.offButtonWasPushed(0);
        System.out.println("--------电灯的撤销-----------");
        remoteController.undoButtonWasPushed();
    }
}

如果要增加新的一种家电的时候：只需要再添加：TVReceiver，TVOffCommand，TVOnCommand 即可完成。

5 . Spring JdbcTemplate

命令模式在Spring框架JdbcTemplate应用的源码分析

1.StatementCallback 接口类似与之前的 Command 接口，用于定义命令的规范

public interface StatementCallback<T> {
    
    

T doInStatement(Statement stmt) throws SQLException, DataAccessException;

}

2.QueryStatementCallback 为匿名内部类，实现了 StatementCallback 接口，同时也充当了命令的接收者(Receiver)

public class JdbcTemplate extends JdbcAccessor implements JdbcOperations {
    
    

    // ...

	@Override
	public <T> T query(final String sql, final ResultSetExtractor<T> rse) throws DataAccessException {
    
    
		Assert.notNull(sql, "SQL must not be null");
		Assert.notNull(rse, "ResultSetExtractor must not be null");
		if (logger.isDebugEnabled()) {
    
    
			logger.debug("Executing SQL query [" + sql + "]");
		}
		class QueryStatementCallback implements StatementCallback<T>, SqlProvider {
    
    
			@Override
			public T doInStatement(Statement stmt) throws SQLException {
    
    
				ResultSet rs = null;
				try {
    
    
					rs = stmt.executeQuery(sql);
					ResultSet rsToUse = rs;
					if (nativeJdbcExtractor != null) {
    
    
						rsToUse = nativeJdbcExtractor.getNativeResultSet(rs);
					}
					return rse.extractData(rsToUse);
				}
				finally {
    
    
					JdbcUtils.closeResultSet(rs);
				}
			}
			@Override
			public String getSql() {
    
    
				return sql;
			}
		}
		return execute(new QueryStatementCallback());
	}
    
    // ...

3.JdbcTemplate 为命令的调用者，在 execute(StatementCallback<T> action) 方法中，执行了命令： T result = action.doInStatement(stmtToUse);，不同的 StatementCallback 实现类，doInStatement() 方法的实现逻辑也不同

public class JdbcTemplate extends JdbcAccessor implements JdbcOperations {
    
    

    // ...
    
	@Override
	public <T> T execute(StatementCallback<T> action) throws DataAccessException {
    
    
		Assert.notNull(action, "Callback object must not be null");

		Connection con = DataSourceUtils.getConnection(getDataSource());
		Statement stmt = null;
		try {
    
    
			Connection conToUse = con;
			if (this.nativeJdbcExtractor != null &&
					this.nativeJdbcExtractor.isNativeConnectionNecessaryForNativeStatements()) {
    
    
				conToUse = this.nativeJdbcExtractor.getNativeConnection(con);
			}
			stmt = conToUse.createStatement();
			applyStatementSettings(stmt);
			Statement stmtToUse = stmt;
			if (this.nativeJdbcExtractor != null) {
    
    
				stmtToUse = this.nativeJdbcExtractor.getNativeStatement(stmt);
			}
			T result = action.doInStatement(stmtToUse);
			handleWarnings(stmt);
			return result;
		}
		catch (SQLException ex) {
    
    
			// Release Connection early, to avoid potential connection pool deadlock
			// in the case when the exception translator hasn't been initialized yet.
			JdbcUtils.closeStatement(stmt);
			stmt = null;
			DataSourceUtils.releaseConnection(con, getDataSource());
			con = null;
			throw getExceptionTranslator().translate("StatementCallback", getSql(action), ex);
		}
		finally {
    
    
			JdbcUtils.closeStatement(stmt);
			DataSourceUtils.releaseConnection(con, getDataSource());
		}
	}
    
    // ...

4.另外实现 StatementCallback 命令接口的子类还有如下四个

在这里插入图片描述

6 . 命令模式的注意事项

命令模式的注意事项和细节

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

命令模式

1 . 智能生活项目需求

2 . 命令模式基本介绍

3 . 命令模式原理类图

4 . 命令模式解决智能生活项目

5 . Spring JdbcTemplate

6 . 命令模式的注意事项

猜你喜欢