設計模式系列—命令模式

作者：一角錢技術 2020-11-03 13:05:18

本篇和大家一起來學習命令模式相關內容。

模式定義

將一個請求封裝為一個對象，使發出請求的責任和執行請求的責任分割開。這樣兩者之間通過命令對象進行溝通，這樣方便將命令對象進行儲存、傳遞、調用、增加與管理。

在軟件開發系統中，常常出現“方法的請求者”與“方法的實現者”之間存在緊密的耦合關系。這不利于軟件功能的擴展與維護。例如，想對行為進行“撤銷、重做、記錄”等處理都很不方便，因此“如何將方法的請求者與方法的實現者解耦?”變得很重要，命令模式能很好地解決這個問題。

模版實現如下：

package com.niuh.designpattern.command.v1; 
 
/** 
 * <p> 
 * 命令模式 
 * </p> 
 */ 
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<Command> 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(); 
    } 
}

輸出結果

設計模式系列課程視頻開放。
設計模式系列課程視頻關閉。

優點

降低系統的耦合度。命令模式能將調用操作的對象與實現該操作的對象解耦。
增加或刪除命令非常方便。采用命令模式增加與刪除命令不會影響其他類，它滿足“開閉原則”，對擴展比較靈活。
可以實現宏命令。命令模式可以與組合模式結合，將多個命令裝配成一個組合命令，即宏命令。
方便實現 Undo 和 Redo 操作。命令模式可以與后面介紹的備忘錄模式結合，實現命令的撤銷與恢復。

缺點

可能產生大量具體命令類。因為計對每一個具體操作都需要設計一個具體命令類，這將增加系統的復雜性。

應用場景

命令執行過程較為復雜且可能存在變化，需要對執行命令動作本身進行額外操作，此時可以考慮使用命令模式

命令模式的擴展

在軟件開發中，有時將命令模式與組合模式聯合使用，這就構成了宏命令模式，也叫組合命令模式。宏命令包含了一組命令，它充當了具體命令與調用者的雙重角色，執行它時將遞歸調用它所包含的所有命令，其具體結構圖如下：

模版實現如下：

package com.niuh.designpattern.command.v2; 
 
import java.util.ArrayList; 
 
/** 
 * <p> 
 * 組合命令模式 
 * </p> 
 */ 
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<AbstractCommand> children = new ArrayList<AbstractCommand>(); 
 
    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> { 
 T doInStatement(Statement stmt) throws SQLException, DataAccessException; 
}

JdbcTemplate類：

public class JdbcTemplate extends JdbcAccessor implements JdbcOperations { 
 //相當于調用者發布的一個命令 
 @Override 
 public <T> List<T> query(String sql, RowMapper<T> rowMapper) throws DataAccessException { 
  return query(sql, new RowMapperResultSetExtractor<T>(rowMapper)); 
 } 
 //命令發布后由具體的命令派給接收者進行執行 
 @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 + "]"); 
  } 
  //內部類，實現StatementCallback，相當于具體的命令 
  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()); 
 } 
 //相當于接收者，命令真正的執行者 
 @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()); 
  } 
 } 
}

PS：以上代碼提交在 Github ：

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

責任編輯：姜華來源：今日頭條

命令模式