Chain of Responsibility(CoR) 是用一系列類(classes)試圖處理一個請求request,這些類之間是一個松散的耦合,唯一共同點是在他們之間傳遞request. 也就是說，來了一個請求，A類先處理，如果沒有處理，就傳遞到B類處理，如果沒有處理，就傳遞到C類處理，就這樣象一個鏈條(chain)一樣傳遞下去。
1) 抽象處理者角色（Handler）：它定義了一個處理請求的接口。當然對于鏈子的不同實現，也可以在這個角色中實現后繼鏈。
2) 具體處理者角色（Concrete Handler）：實現抽象角色中定義的接口，并處理它所負責的請求。如果不能處理則訪問它的后繼者。
至于類圖不放也罷。畢竟就是一個繼承或者實現。
純與不純
責任鏈模式的純與不純的區別，就像黑貓、白貓的區別一樣。不要刻意的去使自己的代碼來符合一個模式的公式。只要能夠使代碼降低耦合、提高重用，滿足系統需求并能很好的適應變化就好了。正所謂：管它黑貓白貓，抓住老鼠就是好貓！
純的責任鏈模式，規定一個具體處理者角色只能對請求作出兩種動作：自己處理；傳給下家。不能出現處理了一部分，把剩下的傳給了下家的情況。而且請求在責任鏈中必須被處理，而不能出現無果而終的結局。
反之，則就是不純的責任鏈模式。
不純的責任鏈模式還算是責任鏈模式嗎？比如一個請求被捕獲后，每個具體處理者都嘗試去處理它，不管結果如何都將請求再次轉發。我認為這種方式的實現，算不算是責任鏈模式的一種倒不重要，重要的是我們也能從中體味到責任鏈模式的思想：通過將多個處理者之間建立聯系，來達到請求與具體的某個處理者的解耦。

我在代碼中寫了一個Army的Handler類，其中實現它的有陸軍軍士長，陸軍上尉，陸軍上校和將軍，軍士長可以對士兵的請假做審核處理，上尉可以對士兵的破壞請求做處理，上校可以對士兵的諜報請求做處理，而將軍可以對士兵的開戰請求做處理。
handler：

    package pattern.chain;

public abstract class Army {
	protected Army army;

	public Army(Army army) {
		this.army = army;
	}
	Status s;
	public enum Status {
		JIA("請假"), PO("破壞"), DIE("諜報"), KAI("開戰");
		String value = "";

		private Status(String value) {
			this.value = value;
		}

		String getValue() {
			return this.value;
		}
	}

	public void setNext(Army army) {
		this.army = army;

	}

	protected abstract void handler(Status s);

	public void next() {
		try {
			Thread.sleep(200);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		if (army != null) {
			army.handler(s);
		}

	}
}

  

    
package pattern.chain;

public class General extends Army {

	public General(Army army) {
		super(army);
		// TODO Auto-generated constructor stub
	}

	@Override
	protected void handler(Status s) {
		this.s = s;
		if (Status.KAI.equals(s)) {
			System.out.println("將軍同意");

		} else {
			next();
		}
	}

}


  

    
package pattern.chain;

public class Colonel extends Army {

	public Colonel(Army army) {
		super(army);
		// TODO Auto-generated constructor stub
	}

	@Override
	protected void handler(Status ss) {
	this.s=ss;
		
		if (Status.DIE.equals(s)) {
			System.out.println("少校同意");
		} else {
			next();		}
	}

}

  

    

package pattern.chain;

public class Captain extends Army {

	public Captain(Army army) {
		super(army);
		// TODO Auto-generated constructor stub
	}

	@Override
	protected void handler(Status ss) {
		this.s = ss;

		if (Status.PO.equals(s)) {
			System.out.println("上尉同意");
		} else {
			next();
		}
	}

}


  

    
package pattern.chain;

public class Commander extends Army {

	public Commander(Army army) {
		super(army);
		// TODO Auto-generated constructor stub
	}

	@Override
	protected void handler(Status ss) {
		this.s = ss;

		if (Status.JIA.equals(s)) {
			System.out.println("士官長同意");
		} else {
			next();
		}
	}

}


  

Test:

    
package pattern.chain;

import pattern.chain.Army.Status;

public class Test {
	public static void main(String[] args) {
		Army gen = new General(null);
		Army col = new Colonel(gen);
		Army cap = new Captain(col);
		Army com = new Commander(cap);
		com.setNext(cap);
		cap.setNext(col);
		col.setNext(gen);
		com.handler(Status.KAI);
	}
}


  

責任鏈模式