Java進階篇設計模式之八 ----- 責任鏈模式和命令模式

時間 2019-11-10

標籤 java 進階設計模式之八責任命令欄目 Java 简体版

原文原文鏈接

前言

在上一篇中咱們學習告終構型模式的享元模式和代理模式。本篇則來學習下行爲型模式的兩個模式，責任鏈模式(Chain of Responsibility Pattern)和命令模式（Command Pattern）。html

責任鏈模式

簡介java

責任鏈模式顧名思義，就是爲請求建立了一個接收者對象的鏈。這種模式給予請求的類型，對請求的發送者和接收者進行解耦。這種類型的設計模式屬於行爲型模式。在這種模式中，一般每一個接收者都包含對另外一個接收者的引用。若是一個對象不能處理該請求，那麼它會把相同的請求傳給下一個接收者，依此類推。git

簡單的理解的話就是進行層級處理。生活中比較常見的是請假、出差、加薪等申請等等，而工做中比較常見的就是攔截器和過濾器。若是請假申請是用之前的那種方式，發起者須要和每一個負責人進行申請，會比較麻煩，可是如今通常是走OA流程，只需發起一個OA申請便可。這也是一種這種就是典型的責任鏈模式，發起者只需將請求請求發送到職責鏈上便可，無需關心處理細節和請求的傳遞。github

責任鏈模式主要由這三個角色組成，請求接收者接口(Handler)、請求實現者類(ConcreteHandler)和請求發送者(Client)。設計模式

請求接收者接口：定義能夠處理客戶端請求事項的接口，包含「可連接下一個一樣能處理請求」的對象引用。
請求實現者類：實現請求處理接口，並判斷對象自己是否可以處理本次請求，若是不能完成請求，則交由後繼者來處理。
請求發送者：將請求發送給第一個接收者對象，並等待請求的回覆。

這裏爲了方便理解，咱們使用一個簡單的示例來加以說明。
在某公司的某個部門中，爲了活躍部門氣氛，主管便徵求部門成員的意見，因而部門的成員踊躍提出建議，最終，主管採納了 xuwujing 提倡的建議，並將此建議進行上報，申請活動經費。
那麼咱們即可以根據這裏例子來使用責任鏈模式進行開發，首先加速有三級的領導，他們有個共同的特性，就是能夠處理各自級別的事情，那麼咱們即可以定義一個領導的抽象類，並定義一個抽象方法能夠處理事情，並設置一個級別的參數，那麼這個抽象類的代碼以下:ide

abstract class Learder{

   protected Learder learder;
   
   protected void setLearder(Learder learder){
       this.learder=learder;
   }
   
   protected Learder getLearder(){
       return learder;
   }
   
   abstract void handler(int  level);
}

定義好該抽象類以後，咱們須要設計不一樣的領導進行不一樣的處理，可是這些領導須要有個處理的能力，而且還要根據各自不一樣的權限進行處理，若是可以處理，到此流程就結束了，不然沒法處理則轉交給上級進行處理。
那麼代碼以下:性能

class Supervisor extends Learder{
    private String name;
    private String something;
    public Supervisor(String name,String something) {
       this.name=name;
       this.something=something;
   }
   
   @Override
   void handler(int level) {
       //若是級別在本身的處理範圍以內
       if(level>1){
           System.out.println("主管贊成了  "+name+"所述的<"+something+">事情!");
       }else{
           System.out.println("主管未能處理  "+name+"所述的<"+something+">事情!轉交給上級!");
           getLearder().handler(level);
       }
   }
}


class BranchManager extends Learder{
    private String name;
    private String something;
    public BranchManager(String name,String something) {
       this.name=name;
       this.something=something;
   }
   
   @Override
   void handler(int level) {
       boolean flag=true;
       //若是級別在本身的處理範圍以內
       if(level>0){
           //這就就直接設置贊成了
           if(flag){
               System.out.println("部門經理贊成了  "+name+"所述的<"+something+">事情!");
           }else{
               System.out.println("部門經理不一樣意  "+name+"所述的<"+something+">事情!");
           }
       }else{
           System.out.println("部門經理未能處理  "+name+"所述的<"+something+">事情!轉交給上級!");
           getLearder().handler(level);
       }
   }
}


class GeneralManager extends Learder{
    private String name;
    private String something;
    public GeneralManager(String name,String something) {
       this.name=name;
       this.something=something;
   }
   
   @Override
   void handler(int level) {
       boolean flag=false;
       //若是級別在本身的處理範圍以內
       if(level>-1){
           //這就就直接設置不一樣意了
           if(flag){
               System.out.println("總經理贊成了  "+name+"所述的<"+something+">事情!");
           }else{
               System.out.println("總經理不一樣意  "+name+"所述的<"+something+">事情!");
           }
           
       }else{
           System.out.println("總經理未能處理  "+name+"所述的<"+something+">事情!轉交給上級!");
           getLearder().handler(level);
       }
   }
}

最後咱們再來根據所須要走的流程來進行代碼測試。因爲在編寫請求類時，咱們並未指定誰是誰的上級，因此這裏咱們須要指定上下級關係，讓流程可以走下去。指定上級以後，咱們再來設置處理該事件的級別，最後再來進行運行。
那麼測試代碼以下:學習

public static void main(String[] args) {
       String name = "xuwujing";
       String something = "去聚餐";
       String something2 = "去旅遊";
       Learder learder1 =new Supervisor(name, something);
       Learder learder2 =new BranchManager(name, something);
       Learder learder3 =new GeneralManager(name, something);
       learder1.setLearder(learder2);
       learder2.setLearder(learder3);
       learder1.handler(1);
       
       Learder learder4 =new Supervisor(name, something2);
       Learder learder5 =new BranchManager(name, something2);
       Learder learder6 =new GeneralManager(name, something2);
       learder4.setLearder(learder5);
       learder5.setLearder(learder6);
       learder4.handler(0);

}

輸出結果:測試

主管未能處理  xuwujing所述的<去聚餐>事情!轉交給上級!
        部門經理贊成了  xuwujing所述的<去聚餐>事情!
        主管未能處理  xuwujing所述的<去旅遊>事情!轉交給上級!
        部門經理未能處理  xuwujing所述的<去旅遊>事情!轉交給上級!
        總經理不一樣意  xuwujing所述的<去旅遊>事情!

責任鏈模式優勢：this

耦合度低，請求者和執行者並無必然的聯繫；
靈活度高，能夠經過內部成員來進行更改它們執行的次序；
擴展性好，Handler的子類擴展很是方便。

責任鏈模式缺點：

會在某程度上下降程序的性能，設置不當的話可能會出現循環調用。
在鏈過長時，會下降代碼的閱讀性以及增長代碼的複雜度。

使用場景：

須要動態指定處理某一組請求時，在不肯定接受者的的狀況下，向多個對象發送請求時。

注意事項：

雖然責任鏈模式很靈活，可是犧牲的是必定的性能，由於責任鏈模式是層級處理，在處理數據的有必定的延遲，所因此須要低延遲的狀況下，不推薦使用責任鏈模式。

命令模式

簡介

命令模式顧名思義，是一種數據驅動的設計模式，它屬於行爲型模式。請求以命令的形式包裹在對象中，並傳給調用對象。調用對象尋找能夠處理該命令的合適的對象，並把該命令傳給相應的對象，該對象執行命令。
也就是將一個請求封裝成一個對象，從而能夠用不一樣的請求對客戶進行參數化。

命令模式主要由這三個角色組成，命令對象(command)、命令執行對象(received)和命令請求對象(invoker)。

命令對象：經過接口或抽象類聲明實現的方法。
命令執行對象：實現命令對象的方法，並將一個接收者和動做進行綁定，調用接收者相應的操做。
命令請求對象：用於執行這個請求，能夠動態的對命令進行控制。

這裏咱們依舊用一個簡單的示例來進行說明。
在某個學校中，學生須要遵從老師的命令，好比老師可讓學生去打掃教室衛生，去完成未作完的做業等等命令，可是學生的時間有限，只能在某個時間範圍內完成某一件事情，此時恰好有兩個老師對學生 xuwujing 說出了命令，李老師先讓 xuwujing 在放學後打掃教室，王老師讓 xuwujing 在回家前把未作完的做業作完並交給他，可是學校的門禁的時間有限，因而 xuwujing 就只打掃了教室，而後開溜了。。。
那麼根據這個示例，咱們可使用命令模式來完成。
首先，先定義一個學生類，並指定該學生能夠作的事情。
代碼以下:

class Student{
    void cleanClassRoom(String name){
        System.out.println(name+" 開始打掃教室...");
    }
    void doHomeWork(String name){
        System.out.println(name+" 開始作做業...");
    }
}

而後定義一個命令抽象類，並設置執行的方法。

abstract class Command{
    protected Student student;
    public Command(Student student){
        this.student = student;
    }
    abstract void execute(String name);
}

繼而再定義兩個命令執行對象，分別設置所需執行的命令。

class LiTeacher extends Command{
    public LiTeacher(Student student) {
        super(student);
    }
    @Override
    void execute(String name) {
        student.cleanClassRoom(name);
    }
}

class WangTeacher extends Command{
    public WangTeacher(Student student) {
        super(student);
    }
    @Override
    void execute(String name) {
        student.doHomeWork(name);
    }
}

最後再來定義一個命令請求對象，用於執行該請求，並對命令進行控制，好比新增命令、撤銷命令和執行命令等等。
那麼代碼以下:

class Invoker {
    private List<Command> commands = new ArrayList<Command>();
    
    public void setCommand(Command command) {
        if(commands.size()>0) {
            System.out.println("不執行 WangTeacher 的命令!");
        }else {
            commands.add(command);
        }
    }
    
    public void executeCommand(String name) {
        commands.forEach(command->{
            command.execute(name);
        });
    }
    
    public void undoCommand(Command command) {
        commands.remove(command);
        System.out.println("撤銷該命令!");
    }   
}

最後再來進行代碼的測試。
測試代碼以下:

public static void main(String[] args) {
        String name = "xuwujing";
        Student student = new  Student();
        Command command1 = new LiTeacher(student);
        Command command2 = new WangTeacher(student);
        Invoker invoker =new Invoker();
        invoker.setCommand(command1);
        invoker.setCommand(command2);
        invoker.executeCommand(name);
    }

輸出結果:

不執行 WangTeacher 的命令!
xuwujing 開始打掃教室...

命令模式優勢：

耦合度低，請求者和執行者並無必然的聯繫；
擴展性好，Command的子類能夠很是容易地擴展。

命令模式缺點：

若是命令過多的話，會增長系統的複雜度。

使用場景：

若是在有相似命令須要指定的，就能夠用命令模式，好比記錄日誌、撤銷操做命令等。

其它

音樂推薦

分享一首很輕快的輕音樂！

項目的代碼

java-study是本人在學習Java過程當中記錄的一些代碼，也包括以前博文中使用的代碼。若是感受不錯，但願順手給個start，固然若是有不足，也但願提出。
github地址: https://github.com/xuwujing/java-study

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。