设计模式系列—命令模式

模式定义

将一个请求封装为一个对象，使发出请求的责任和执行请求的责任分割开。这样两者之间通过命令对象进行沟通，这样方便将命令对象进行储存、传递、调用、增加与管理。

在软件开发系统中，常常出现“方法的请求者”与“方法的实现者”之间存在紧密的耦合关系。这不利于软件功能的扩展与维护。例如，想对行为进行“撤销、重做、记录”等处理都很不方便，因此“如何将方法的请求者与方法的实现者解耦?”变得很重要，命令模式能很好地解决这个问题。

模版实现如下：

package com.niuh.designpattern.command.v1; 
 
 
public class CommandPattern { 
    public static void main(String[] args) { 
        Command cmd = new ConcreteCommand(); 
        Invoker ir = new Invoker(cmd); 
        System.out.println("客户访问调用者的call()方法..."); 
        ir.call(); 
    } 
} 
 
//抽象命令 
interface Command { 
    public abstract void execute(); 
} 
 
//具体命令 
class ConcreteCommand implements Command { 
    private Receiver receiver; 
 
    ConcreteCommand() { 
        receiver = new Receiver(); 
    } 
 
    public void execute() { 
        receiver.action(); 
    } 
} 
 
//接收者 
class Receiver { 
    public void action() { 
        System.out.println("接收者的action()方法被调用..."); 
    } 
} 
 
//调用者 
class Invoker { 
    private Command command; 
 
    public Invoker(Command command) { 
        this.command = command; 
    } 
 
    public void setCommand(Command command) { 
        this.command = command; 
    } 
 
    public void call() { 
        System.out.println("调用者执行命令command..."); 
        command.execute(); 
    } 
} 

输出结果如下：

客户访问调用者的call()方法... 
调用者执行命令command... 
接收者的action()方法被调用... 

解决的问题

在软件系统中，行为请求者与行为实现者通常是一种紧耦合的关系，但某些场合，比如需要对行为进行记录、撤销或重做、事务等处理时，这种无法抵御变化的紧耦合的设计就不太合适。

模式组成

 

可以将系统中的相关操作抽象成命令，使调用者与实现者相关分离，其结构如下。

实例说明

实例概况

 

结合命令模式，实现一个课程视频的打开和关闭。

使用步骤

 

步骤1：声明执行命令的接口，拥有执行命令的抽象方法 execute()

interface Command { 
    void execute(); 
} 

步骤2：定义具体命令角色，创建打开课程链接 和 关闭课程连接

 
class OpenCourseVideoCommand implements Command { 
 
    private CourseVideo courseVideo; 
 
    public OpenCourseVideoCommand(CourseVideo courseVideo) { 
        this.courseVideo = courseVideo; 
    } 
 
    @Override 
    public void execute() { 
        courseVideo.open(); 
    } 
} 
 
 
class CloseCourseVideoCommand implements Command { 
 
    private CourseVideo courseVideo; 
 
    public CloseCourseVideoCommand(CourseVideo courseVideo) { 
        this.courseVideo = courseVideo; 
    } 
 
    @Override 
    public void execute() { 
        courseVideo.close(); 
    } 
} 

步骤3：定义接收者角色，执行命令功能的相关操作，是具体命令对象业务的真正实现者

class CourseVideo { 
 
    private String name; 
 
    public CourseVideo(String name) { 
        this.name = name; 
    } 
 
    public void open() { 
        System.out.println(this.name + "课程视频开放。"); 
    } 
 
    public void close() { 
        System.out.println(this.name + "课程视频关闭。"); 
    } 
} 

步骤4：创建User对象为请求的发送者，即请求者角色

class User { 
 
    private List commands = new ArrayList<>(); 
 
    public void addCommand(Command command) { 
        commands.add(command); 
    } 
 
    public void executeCommands() { 
        commands.forEach(Command::execute); 
        commands.clear(); 
    } 
} 

步骤5：测试执行

public class CommandPattern { 
 
    public static void main(String[] args) { 
        //命令接收者 
        CourseVideo courseVideo = new CourseVideo("设计模式系列"); 
 
        //创建命令 
        OpenCourseVideoCommand openCourseVideoCommand = new OpenCourseVideoCommand(courseVideo); 
        CloseCourseVideoCommand closeCourseVideoCommand = new CloseCourseVideoCommand(courseVideo); 
 
        //创建执行人 
        User user = new User(); 
 
        //添加命令 
        user.addCommand(openCourseVideoCommand); 
        user.addCommand(closeCourseVideoCommand); 
 
        //执行 
        user.executeCommands(); 
    } 
} 

输出结果

• 设计模式系列课程视频开放。
• 设计模式系列课程视频关闭。

优点

1. 降低系统的耦合度。命令模式能将调用操作的对象与实现该操作的对象解耦。
2. 增加或删除命令非常方便。采用命令模式增加与删除命令不会影响其他类，它满足“开闭原则”，对扩展比较灵活。
3. 可以实现宏命令。命令模式可以与组合模式结合，将多个命令装配成一个组合命令，即宏命令。
4. 方便实现 Undo 和 Redo 操作。命令模式可以与后面介绍的备忘录模式结合，实现命令的撤销与恢复。

缺点

可能产生大量具体命令类。因为计对每一个具体操作都需要设计一个具体命令类，这将增加系统的复杂性。

应用场景

命令执行过程较为复杂且可能存在变化，需要对执行命令动作本身进行额外操作，此时可以考虑使用命令模式

命令模式的扩展

 

在软件开发中，有时将命令模式与组合模式联合使用，这就构成了宏命令模式，也叫组合命令模式。宏命令包含了一组命令，它充当了具体命令与调用者的双重角色，执行它时将递归调用它所包含的所有命令，其具体结构图如下：

模版实现如下：

package com.niuh.designpattern.command.v2; 
 
import java.util.ArrayList; 
 
 
public class CompositeCommandPattern { 
    public static void main(String[] args) { 
        AbstractCommand cmd1 = new ConcreteCommand1(); 
        AbstractCommand cmd2 = new ConcreteCommand2(); 
        CompositeInvoker ir = new CompositeInvoker(); 
        ir.add(cmd1); 
        ir.add(cmd2); 
        System.out.println("客户访问调用者的execute()方法..."); 
        ir.execute(); 
    } 
} 
 
//抽象命令 
interface AbstractCommand { 
    public abstract void execute(); 
} 
 
//树叶构件: 具体命令1 
class ConcreteCommand1 implements AbstractCommand { 
    private CompositeReceiver receiver; 
 
    ConcreteCommand1() { 
        receiver = new CompositeReceiver(); 
    } 
 
    public void execute() { 
        receiver.action1(); 
    } 
} 
 
//树叶构件: 具体命令2 
class ConcreteCommand2 implements AbstractCommand { 
    private CompositeReceiver receiver; 
 
    ConcreteCommand2() { 
        receiver = new CompositeReceiver(); 
    } 
 
    public void execute() { 
        receiver.action2(); 
    } 
} 
 
//树枝构件: 调用者 
class CompositeInvoker implements AbstractCommand { 
    private ArrayList children = new ArrayList(); 
 
    public void add(AbstractCommand c) { 
        children.add(c); 
    } 
 
    public void remove(AbstractCommand c) { 
        children.remove(c); 
    } 
 
    public AbstractCommand getChild(int i) { 
        return children.get(i); 
    } 
 
    public void execute() { 
        for (Object obj : children) { 
            ((AbstractCommand) obj).execute(); 
        } 
    } 
} 
 
//接收者 
class CompositeReceiver { 
    public void action1() { 
        System.out.println("接收者的action1()方法被调用..."); 
    } 
 
    public void action2() { 
        System.out.println("接收者的action2()方法被调用..."); 
    } 
} 

输出结果如下：

• 客户访问调用者的execute()方法...
• 接收者的action1()方法被调用...
• 接收者的action2()方法被调用...

命令模式还可以同备忘录(Memento)模式组合使用，这样就变成了可撤销的命令模式

源码中的应用

• java.util.Timer类中scheduleXXX()方法
• java Concurrency Executor execute() 方法
• java.lang.reflect.Method invoke()方法
• org.springframework.jdbc.core.JdbcTemplate
• ......

在 JdbcTemplate 中的应用

在JdbcTemplate中命令模式的使用并没有遵从标准的命令模式的使用，只是思想相同而已。

 

在 Spring 的 JdbcTemplate 这个类中有 query() 方法，query() 方法中定义了一个内部类 QueryStatementCallback，QueryStatementCallback 又实现了 StatementCallback 接口，另外还有其它类实现了该接口，StatementCallback 接口中又有一个抽象方法 doInStatement()。在 execute() 中又调用了 query()。

StatementCallback充当的是命令角色，JdbcTemplate即充当调用者角色，又充当接收者角色。上面的类图只是为了方便理解，实际上，QueryStatementCallback 与 ExecuteStatementCallback是JdbcTemplate中方法的内部类，具体看源码中的内容。

部分源码分析

 

StatementCallback接口：

public interface StatementCallback { 
 T doInStatement(Statement stmt) throws SQLException, DataAccessException; 
} 

JdbcTemplate类：

public class JdbcTemplate extends JdbcAccessor implements JdbcOperations { 
 //相当于调用者发布的一个命令 
 @Override 
 public  List query(String sql, RowMapper rowMapper) throws DataAccessException { 
  return query(sql, new RowMapperResultSetExtractor(rowMapper)); 
 } 
 //命令发布后由具体的命令派给接收者进行执行 
 @Override 
 public  T query(final String sql, final ResultSetExtractor 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 + "]"); 
  } 
  //内部类，实现StatementCallback，相当于具体的命令 
  class QueryStatementCallback implements StatementCallback, 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()); 
 } 
 //相当于接收者，命令真正的执行者 
 @Override 
 public  T execute(StatementCallback 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()); 
  } 
 } 
} 

PS：以上代码提交在 Github ：

 

https://github.com/Niuh-Study/niuh-designpatterns.git