设计模式-责任链模式

来源：《设计模式之禅》

定义：使多个对象都有机会处理请求，避免请求者和接收者之间的耦合关系。将这些接收者连成一条链，并沿着这条连传递请求，直到有对象处理为止。

处理类职责

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. 调试不方便，由于采用了递归方式，调试业务复杂功能比较复杂。

扩展：