| 我的GitHub | 我的博客 | 我的微信 | 我的郵箱 |
|---|---|---|---|
| baiqiantao | baiqiantao | bqt20094 | baiqiantao@sina.com |
責任鏈模式
簡介
責任鏈模式是一種對象的行為模式。在責任鏈模式里，很多對象由每一個對象對其下家的引用而連接起來形成一條鏈，請求在這個鏈上【傳遞】，直到鏈上的某一個對象決定處理此請求。發出這個請求的客戶端並不知道鏈上的哪一個對象最終處理這個請求，這使得系統可以在不影響客戶端的情況下動態地重新組織和分配責任。
責任鏈模式屏蔽了請求的處理過程，你發起一個請求到底是誰處理的，這個你不用關心，只要你把請求拋給責任鏈的第一個處理者，最終會返回一個處理結果（當然也可以不做任何處理），作為請求者可以不用知道到底是需要誰來處理的，這是責任鏈模式的核心。
責任鏈就是從一個起點發起請求，然后沿着任務鏈依次傳遞給每一個節點上的對象，直到有一個節點處理這個請求為止。
使多個對象都有機會處理請求，從而避免了請求的發送者和接受者之間的耦合關系。將這些對象連成一條鏈，並沿着這條鏈傳遞該請求，直到有對象處理它為止。
現實中最適合責任鏈的應該就是部門領導之間的上報請求了。比如員工要申請一筆資金，會先向組長申請，額度如果在組長的范圍內，組長就批了，組長權限不夠就向主管申請，主管如果也額度不夠就向經理申請。這就形成了個責任鏈。
組長，主管，經理。每個人都是責任鏈上的一個節點。一個請求被層層轉達，直到被處理或沒有一個人能處理。普通員工，就是那個申請的發起者，並不需要知道到底最后是誰審批的，他只要拿到錢就行了。這樣就造成了請求者和處理者的解耦。
責任鏈有一個缺點是，大家在開發的時候要注意，調試不是很方便，特別是鏈條比較長，環節比較多的時候，由於采用了類似遞歸的方式，調試的時候邏輯可能比較復雜。
適用性
- 有多個對象可以處理一個請求，具體哪個對象處理該請求在運行時刻自動確定。
- 在請求的處理者不明確的情況下，向多個對象的一個提交請求。
- 需要動態指定一組對象處理請求。
角色
- Handler：抽象處理者角色，聲明一個處理請求的方法，並保持對下一個處理節點Handler對象的引用。
- ConcreteHandler: 具體的處理者，對請求進行處理，如果不處理就講請求轉發給下一個節點上的處理對象。
作用：請求會被鏈上的對象處理，但是客戶端不知道請求會被哪些對象處理
通過把請求從一個對象傳遞到鏈條中下一個對象的方式，直到請求被處理完畢，以實現對象間的解耦。
JDK中體現：ClassLoader的委托模型
簡單版案例
抽象處理者
public abstract class Handler {
protected Handler successor;
public abstract void handleRequest(String condition);
}實際處理者1
public class ConcreteHandler1 extends Handler {
@Override
public void handleRequest(String condition) {
if ("ConcreteHandler1".equals(condition)){
System.out.println("ConcreteHandler1 handled");
}else {
successor.handleRequest(condition);
}
}
}實際處理者2
public class ConcreteHandler2 extends Handler {
@Override
public void handleRequest(String condition) {
if ("ConcreteHandler2".equals(condition)) {
System.out.println("ConcreteHandler2 handled");
} else {
successor.handleRequest(condition);
}
}
}客戶端調用
組成一條責任鏈
public class Client {
public static void main(String[] args) {
ConcreteHandler1 concreteHandler1 = new ConcreteHandler1();
ConcreteHandler2 concreteHandler2 = new ConcreteHandler2();
concreteHandler1.successor = concreteHandler2;
concreteHandler2.successor = concreteHandler1;
concreteHandler1.handleRequest("ConcreteHandler2");
}
}簡單版中，傳遞的都是統一的字符串，處理也比較簡單。但是在實際開發中，責任鏈中的請求處理規則是不盡相同的，這種時候需要對請求進行封裝，同時對請求的處理規則也進行一個封裝，
復雜版案例
抽象處理者
public abstract class AbstractHandler {
protected AbstractHandler nextHandler;
public final void handleRequest(AbstractRequest request){
if (request.getRequestLevel()==getHandleLevel()){
handle(request);
}else {
if (nextHandler!=null){
nextHandler.handleRequest(request);
}else {
System.out.println("沒有對象能處理這個請求");
}
}
}
protected abstract int getHandleLevel();
protected abstract void handle(AbstractRequest request);
}三個處理者
public class Handler1 extends AbstractHandler {
@Override
protected int getHandleLevel() {
return 1;
}
@Override
protected void handle(AbstractRequest request) {
System.out.println("Handler1處理了請求："+request.getRequestLevel());
}
}public class Handler2 extends AbstractHandler {
@Override
protected int getHandleLevel() {
return 2;
}
@Override
protected void handle(AbstractRequest request) {
System.out.println("Handler2處理了請求："+request.getRequestLevel());
}
}public class Handler3 extends AbstractHandler {
@Override
protected int getHandleLevel() {
return 3;
}
@Override
protected void handle(AbstractRequest request) {
System.out.println("Handler3處理了請求："+request.getRequestLevel());
}
}抽象請求者
public abstract class AbstractRequest {
private Object obj;
public AbstractRequest(Object obj){
this.obj=obj;
}
public Object getContent(){
return obj;
}
public abstract int getRequestLevel();
}實現的三個請求
public class Request1 extends AbstractRequest {
public Request1(Object obj) {
super(obj);
}
@Override
public int getRequestLevel() {
return 1;
}
}public class Request2 extends AbstractRequest {
public Request2(Object obj) {
super(obj);
}
@Override
public int getRequestLevel() {
return 2;
}
}public class Request3 extends AbstractRequest {
public Request3(Object obj) {
super(obj);
}
@Override
public int getRequestLevel() {
return 3;
}
}客戶端調用
public class Client {
public static void main(String[] args) {
//構造三個處理對象
AbstractHandler handler1 = new Handler1();
AbstractHandler handler2 = new Handler2();
AbstractHandler handler3 = new Handler3();
//串成一個責任鏈
handler1.nextHandler = handler2;
handler2.nextHandler = handler3;
//構造三個請求
AbstractRequest request1 = new Request1("A");
AbstractRequest request2 = new Request2("B");
AbstractRequest request3 = new Request3("C");
handler1.handleRequest(request1);
handler1.handleRequest(request2);
handler1.handleRequest(request3);
}
}實際案例
抽象的領導
public abstract class Leader {
protected Leader nextLeader;
public final void handleRequest(int money) {
if (money < = getLimit()) {
handle(money);
} else {
if (nextLeader != null) {
nextLeader.handleRequest(money);
} else {
System.out.println(money + "沒人能批准");
}
}
}
public abstract int getLimit();
public abstract void handle(int money);
}三個具體的領導
public class GroupLeader extends Leader {
@Override
public int getLimit() {
return 5000;
}
@Override
public void handle(int money) {
System.out.println(money + "由組長批准");
}
}public class Director extends Leader {
@Override
public int getLimit() {
return 10000;
}
@Override
public void handle(int money) {
System.out.println(money + "由主管批准");
}
}public class Manager extends Leader {
@Override
public int getLimit() {
return 20000;
}
@Override
public void handle(int money) {
System.out.println(money + "由經理批准");
}
}員工申請
public class Test {
public static void main(String[] args) {
Leader groupLeader = new GroupLeader();
Leader director = new Director();
Leader manager = new Manager();
groupLeader.nextLeader = director;
director.nextLeader = manager;
groupLeader.handleRequest(4000);
groupLeader.handleRequest(12000);
groupLeader.handleRequest(30000);
}
}2016-04-21