程式師世界 >> 編程語言 >> JAVA編程 >> 關於JAVA >> 設計模式之責任連模式詳解

設計模式之責任連模式詳解

編輯：關於JAVA

定義：使多個對象都有機會處理請求，從而避免了請求的發送者和接收者之間的耦合關系。將這些對象連成一條鏈，並沿著這條鏈傳遞該請求，直到有對象處理它為止。

類型：行為類模式

類圖：

23種設計模式（11）：責任連模式

首先來看一段代碼：

public void test(int i, Request request){
	if(i==1){
		Handler1.response(request);
	}else if(i == 2){
		Handler2.response(request);
	}else if(i == 3){
		Handler3.response(request);
	}else if(i == 4){
		Handler4.response(request);
	}else{
		Handler5.response(request);
	}
}

代碼的業務邏輯是這樣的，方法有兩個參數：整數i和一個請求request，根據i的值來決定由誰來處理request，如果i==1，由Handler1來處理，如果i==2，由Handler2來處理，以此類推。在編程中，這種處理業務的方法非常常見，所有處理請求的類有if…else…條件判斷語句連成一條責任鏈來對請求進行處理，相信大家都經常用到。這種方法的優點是非常直觀，簡單明了，並且比較容易維護，但是這種方法也存在著幾個比較令人頭疼的問題：

代碼臃腫：實際應用中的判定條件通常不是這麼簡單地判斷是否為1或者是否為2，也許需要復雜的計算，也許需要查詢數據庫等等，這就會有很多額外的代碼，如果判斷條件再比較多，那麼這個if…else…語句基本上就沒法看了。
耦合度高：如果我們想繼續添加處理請求的類，那麼就要繼續添加else if判定條件；另外，這個條件判定的順序也是寫死的，如果想改變順序，那麼也只能修改這個條件語句。

既然缺點我們已經清楚了，就要想辦法來解決。這個場景的業務邏輯很簡單：如果滿足條件1，則由Handler1來處理，不滿足則向下傳遞；如果滿足條件2，則由Handler2來處理，不滿足則繼續向下傳遞，以此類推，直到條件結束。其實改進的方法也很簡單，就是把判定條件的部分放到處理類中，這就是責任連模式的原理。

責任連模式的結構

責任連模式的類圖非常簡單，它由一個抽象地處理類和它的一組實現類組成：

抽象處理類：抽象處理類中主要包含一個指向下一處理類的成員變量nextHandler和一個處理請求的方法handRequest，handRequest方法的主要主要思想是，如果滿足處理的條件，則有本處理類來進行處理，否則由nextHandler來處理。
具體處理類：具體處理類主要是對具體的處理邏輯和處理的適用條件進行實現。

了解了責任連模式的大體思想之後，再看代碼就比較好理解了：

class Level {
	private int level = 0;
	public Level(int level){
		this.level = level;
	};

	public boolean above(Level level){
		if(this.level >= level.level){
			return true;
		}
		return false;
	}
}

class Request {
	Level level;
	public Request(Level level){
		this.level = level;
	}

	public Level getLevel(){
		return level;
	}
}

class Response {

}

abstract class Handler {
	private Handler nextHandler;	
	public final Response handleRequest(Request request){
		Response response = null;

		if(this.getHandlerLevel().above(request.getLevel())){
			response = this.response(request);
		}else{
			if(this.nextHandler != null){
				this.nextHandler.handleRequest(request);
			}else{
				System.out.println("-----沒有合適的處理器-----");
			}
		}
		return response;
	}
	public void setNextHandler(Handler handler){
		this.nextHandler = handler;
	}
	protected abstract Level getHandlerLevel();
	public abstract Response response(Request request);
}

class ConcreteHandler1 extends Handler {
	protected Level getHandlerLevel() {
		return new Level(1);
	}
	public Response response(Request request) {
		System.out.println("-----請求由處理器1進行處理-----");
		return null;
	}
}

class ConcreteHandler2 extends Handler {
	protected Level getHandlerLevel() {
		return new Level(3);
	}
	public Response response(Request request) {
		System.out.println("-----請求由處理器2進行處理-----");
		return null;
	}
}

class ConcreteHandler3 extends Handler {
	protected Level getHandlerLevel() {
		return new Level(5);
	}
	public Response response(Request request) {
		System.out.println("-----請求由處理器3進行處理-----");
		return null;
	}
}

public class Client {
	public static void main(String[] args){
		Handler handler1 = new ConcreteHandler1();
		Handler handler2 = new ConcreteHandler2();
		Handler handler3 = new ConcreteHandler3();

		handler1.setNextHandler(handler2);
		handler2.setNextHandler(handler3);

		Response response = handler1.handleRequest(new Request(new Level(4)));
	}
}

代碼中Level類是模擬判定條件；Request，Response分別對應請求和響應；抽象類Handler中主要進行條件的判斷，這裡模擬一個處理等級，只有處理類的處理等級高於Request的等級才能處理，否則交給下一個處理者處理。在Client類中設置好鏈的前後執行關系，執行時將請求交給第一個處理類，這就是責任連模式，它完成的功能與前文中的if…else…語句是一樣的。