本章一開始舉了中國古代對婦女制定的 “三從四德” 的道德規範，形象地將女性在 “未嫁 出嫁 喪父” 三個不同的狀態下請示出門逛街獲得的處理，未嫁的時候，請示父親；出嫁了，請示丈夫；丈夫去世了，請示兒子。責任鏈就是：父親 丈夫 兒子。如果出嫁了，請示父親，會得到什麼結果？答案是：父親告訴他，你該去請示 ...
本章一開始舉了中國古代對婦女制定的 “三從四德” 的道德規範，形象地將女性在 “未嫁-> 出嫁 -> 喪父” 三個不同的狀態下請示出門逛街獲得的處理，未嫁的時候，請示父親；出嫁了，請示丈夫；丈夫去世了，請示兒子。責任鏈就是：父親 -> 丈夫 -> 兒子。如果出嫁了，請示父親，會得到什麼結果？答案是：父親告訴他，你該去請示你的丈夫。讀完還是蠻形象的。
其實，作者給我們闡述了這麼一個場景：一個請求到來的時候，請求方並不知道也不必知道誰去處理請求，責任鏈也不必關心誰發出的請求。請求來了，從第一個處理者開始，如果屬於這一層，就處理。不屬於？分發到下一個節點。下一個不能處理怎麼辦？再下一個。尋找處理者就是遍歷鏈表節點的過程。
為什麼這麼做？這樣做，就避免了請求和處理耦合在一起，代碼也簡潔了很多。
Talk is cheap, show me the code.
先創建一個女性介面：
public interface IWomen {
// 獲得個人狀態.
public int getType();
// 獲得個人請示
public String getRequest();
}
創建一個古代婦女：
public class Women implements IWomen {
/**
* 通過 int 類型的參數來描述婦女的個人狀況.
* <p/>
* 1 -> 未出嫁;
* 2 -> 出嫁;
* 3 -> 夫死;
*/
private int type = 0;
/**
* 婦女的請示
*/
private String request = "";
public Women(int type, String request) {
this.type = type;
switch (this.type) {
case 1:
this.request = "女兒的請示是： " + request;
break;
case 2:
this.request = "妻子的請求是： " + request;
break;
case 3:
this.request = "母親的請求是： " + request;
}
}
/**
* 獲取自己的狀態.
*
* @return
*/
public int getType() {
return this.type;
}
/**
* 獲取婦女的請求.
*
* @return
*/
public String getRequest() {
return this.request;
}
}
有處理權的人員介面：
public abstract class Handler {
public final static int FATHER_LEVEL_REQUEST = 1;
public final static int HUSBAND_LEVEL_REQUEST = 2;
public final static int SON_LEVEL_REQUEST = 3;
/**
* 能處理的級別
*/
private int level = 0;
/**
* 責任傳遞，下一個責任人是誰
*/
private Handler nextHandler;
/**
* 每個類都要說明一下自己能處理哪些請求
*/
public Handler(int level) {
this.level = level;
}
/**
* 處理女性的請求.
*
* @param women
*/
public final void HandleMessage(IWomen women) {
if (women.getType() == this.level) {
this.response(women);
} else {
if (null != this.nextHandler) {
this.nextHandler.HandleMessage(women);
} else {
// 沒有後續的處理人了.
System.out.println("\n-------沒有地方請示了，按不同意處理-------\n");
}
}
}
/**
* 如果不屬於該類處理的請求，應該將其設置到下一個需要請求的環節.
*
* @param handler
*/
public void setNextHandler(Handler handler) {
this.nextHandler = handler;
}
/**
* 有請求肯定要有回應
*
* @param women
*/
protected abstract void response(IWomen women);
}
父親類：
public class Father extends Handler {
public Father() {
super(Handler.FATHER_LEVEL_REQUEST);
}
@Override
protected void response(IWomen women) {
System.out.println("\n-------女兒向父親請示-------");
System.out.println(women.getRequest());
System.out.println("父親的回答是： 同意\n");
}
}
丈夫類：
public class Husband extends Handler {
public Husband() {
super(Handler.HUSBAND_LEVEL_REQUEST);
}
@Override
protected void response(IWomen women) {
System.out.println("-------妻子向丈夫請示-------");
System.out.println(women.getRequest());
System.out.println("丈夫的答覆是： 同意");
}
}
兒子類：
public class Son extends Handler {
public Son() {
super(Handler.SON_LEVEL_REQUEST);
}
@Override
protected void response(IWomen women) {
System.out.println("-------母親向兒子請示-------");
System.out.println(women.getRequest());
System.out.println("兒子的答覆是： 同意\n");
}
}
場景類：
public class Client {
public static void main(String[] args) {
Random random = new Random();
ArrayList<IWomen> arrayList = new ArrayList<IWomen>();
for (int i = 0; i < 5; i++) {
arrayList.add(new Women(random.nextInt(4), "我要去逛街"));
}
// 定義三個請求對象
Father father = new Father();
Husband husband = new Husband();
Son son = new Son();
father.setNextHandler(husband);
husband.setNextHandler(son);
for (IWomen women : arrayList) {
father.HandleMessage(women);
}
}
}
運行結果：
-------母親向兒子請示-------
母親的請求是： 我要去逛街
兒子的答覆是： 同意
-------妻子向丈夫請示-------
妻子的請求是： 我要去逛街
丈夫的答覆是： 同意
-------母親向兒子請示-------
母親的請求是： 我要去逛街
兒子的答覆是： 同意
-------沒有地方請示了，按不同意處理-------
-------妻子向丈夫請示-------
妻子的請求是： 我要去逛街
丈夫的答覆是： 同意在抽象類 Handler 中，我們設置了級別 level 的參數用來標示子類的等級；定義了 nextHandler 來制定當前節點的下一個處理節點。這樣，每個子類在生成實例對象的時候，通過指定下一個節點，就可以生成責任鏈了。
責任鏈模式的重點是在“鏈”上，由一條鏈去處理相似的請求在鏈中決定誰來處理這個請求，並返回相應的結果。其優點就是將請求和處理分開來了。請求者不需要知道誰將處理這個請求，處理者也不要知道誰發起了這個請求。兩者解耦，提高了系統的靈活性。
