設計模式-責任鏈模式

來源：《設計模式之禪》

定義：使多個對象都有機會處理請求，避免請求者和接收者之間的耦合關係。將這些接收者連成一條鏈，並沿着這條連傳遞請求，直到有對象處理爲止。

處理類職責

1. 定義一個處理請求的方法，惟一對外開放的方法。

2. 定義處理鏈的下一個處理者。

3. 定於具體處理類的的處理級別及具體業務處理。

類圖：

代碼：

抽象請求對象:

/**
 * 
 */
package cc.rico.pattern.chain;

/**
 * @author rico
 * 抽象請求對象
 */
public abstract class AbstractRequest {
	private String level;
	
//	public AbstractRequest(String level) {
//		this.level = level;
//	}
	
	public String getLevel() {
		return level;
	}

	public void setLevel(String level) {
		this.level = level;
	}
	
	/**
	 * 讀取請求信息
	 * @return
	 */
	public abstract String getRequestMesage();
}

具體請求對象:

/**
 * 
 */
package cc.rico.pattern.chain;

/**
 * @author rico
 * 具體請求對象
 */
public class ConcreteRequest extends AbstractRequest {

//	public ConcreteRequest(String level) {
//		super(level);
//	}

	/* 讀取請求信息(non-Javadoc)
	 * @see cc.rico.pattern.chain.AbstractRequest#getRequestMesage()
	 */
	@Override
	public String getRequestMesage() {
		return "##ConcreteRequest.requestMessage";
	}
	
	
}

抽象請求處理類:

/**
 * 
 */
package cc.rico.pattern.chain;

/**
 * @author rico
 * 抽象請求處理類
 */
public abstract class AbstractHandler {
	// 請求處理級別
	public static final String LEVEL_FIRST = "1";
	public static final String LEVEL_SECOND = "2";
	public static final String LEVEL_THIRD = "3";
	// 
	protected String level = LEVEL_FIRST;
	
	// 下一個處理對象
	protected AbstractHandler nextHandler;
	
	public AbstractHandler(String level) {
		this.level = level;
	}
	
	/**
	 * 設置下一個請求處理對象
	 * @param nextHandler
	 */
	public void setNextHanlder(AbstractHandler nextHandler) {
		this.nextHandler = nextHandler;
	}

	public void setLevel(String level) {
		this.level = level;
	}
	
	/**
	 * 處理請求對象
	 * @param request
	 */
	public abstract void handle(AbstractRequest request);
}

具體請求處理類:

/**
 * 
 */
package cc.rico.pattern.chain;

/**
 * @author rico
 * 具體請求處理類
 */
public class ConcreteHandler1 extends AbstractHandler {

	public ConcreteHandler1() {
		super(AbstractHandler.LEVEL_FIRST);
	}

	/* (non-Javadoc)
	 * @see cc.rico.pattern.chain.AbstractHandler#handle(cc.rico.pattern.chain.AbstractRequest)
	 */
	@Override
	public void handle(AbstractRequest request) {
		if(this.level.equals(request.getLevel())) {			
			this.handleRequest();
		} else {
			if(this.nextHandler != null) {
				this.nextHandler.handle(request);
			} else {
				System.out.println("###沒法處理請求對象...");
			}
		}
	}
	
	/**
	 * 處理請求
	 */
	private void handleRequest() {
		System.out.println("###ConcreteHandler1.handleRequest...");
	}

}

/**    
     * 
     */
    package cc.rico.pattern.chain;
    
    /**
     * @author rico
     * 具體請求處理類
     */
    public class ConcreteHandler2 extends AbstractHandler {
    
    	public ConcreteHandler2() {
    		super(AbstractHandler.LEVEL_SECOND);
    	}
    
    	/* (non-Javadoc)
    	 * @see cc.rico.pattern.chain.AbstractHandler#handle(cc.rico.pattern.chain.AbstractRequest)
    	 */
    	@Override
    	public void handle(AbstractRequest request) {
    		if(this.level.equals(request.getLevel())) {			
    			this.handleRequest();
    		} else {
    			if(this.nextHandler != null) {
    				this.nextHandler.handle(request);
    			} else {
    				System.out.println("###沒法處理請求對象...");
    			}
    		}
    	}
    	
    	/**
    	 * 處理請求
    	 */
    	private void handleRequest() {
    		System.out.println("###ConcreteHandler2.handleRequest...");
    	}
    
    }

場景類:

/**
 * 
 */
package cc.rico.pattern.chain;

/**
 * @author rico
 * 場景類
 */
public class Client {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		AbstractHandler handler1 = new ConcreteHandler1();
		AbstractHandler handler2 = new ConcreteHandler2();
		handler1.setNextHanlder(handler2);
		
		AbstractRequest request = new ConcreteRequest();
		request.setLevel(AbstractHandler.LEVEL_SECOND);
		
		handler1.handle(request);
	}

}

責任鏈優勢：

     將請求者和處理者分開，避免請求者和接收者之間的耦合關係，提升系統的靈活性。

責任鏈缺點：

1. 性能問題，處理鏈比較長是，從鏈頭遍歷到鏈尾，性能消耗。

1. 調試不方便，因爲採用了遞歸方式，調試業務複雜功能比較複雜。

擴展：