设计模式（六）——责任链模式

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

类图

类图比较简单

模板

抽象处理者

package ResponseChain;public abstract class Handler {private Handler nextHandler;////设置下一个处理者是谁public void seNext(Handler handler){this.nextHandler=handler;}//每个处理者都有一个处理级别protected abstract Level getHandlerLevel();//每个处理者都必须实现处理任务protected abstract Response echo(Request request);public final Response handleMsg(Request request){Response response=null;if(this.getHandlerLevel().equals(request.getRequestLevel())){response=this.echo(request);}else{if(this.nextHandler!=null){response = this.nextHandler.handleMsg(request);}else{//没有合适的处理者,业务自行处理}}return response;}}

抽象处理者有三个职责：

   1. 定义一个请求的处理方法handleMsg，唯一对外开放的方法；

   2. 定义一个链的编排方法setNext，设置下一个处理者；

   3. 定义具体的请求者必须实现的两个方法：

       3.1 定义自己的处理级别

       3.2 定义具体处理任务echo

具体实现类<举一例>

package ResponseChain;public class ConcreteHandler1 extends Handler{@Overrideprotected Level getHandlerLevel() {return Level.FIRST_LEVEL;}@Overrideprotected Response echo(Request request) {return new Response("ConcreteHandler1");}}

在处理者中涉及三个类：

    1. Level负责定义请求和处理级别；

    2. Request类负责封装请求；

    3. Response类负责封装结果；

这三个类需要根据业务进行实习。

Level

package ResponseChain;public enum Level {FIRST_LEVEL,SECOND_LEVEL,THIRD_LEVEL;}

Request

public class Request {private int level;public Request(int i){this.level=i;}//请求的等级public Level getRequestLevel(){if(1==level)return Level.FIRST_LEVEL;if(2==level)return Level.SECOND_LEVEL;elsereturn Level.THIRD_LEVEL;}}

Response

public class Response {public Response(String content){this.content=content;}private String content;public String getContent() {return content;}public void setContent(String content) {this.content = content;}@Overridepublic String toString() {return "我是~~ [content=" + content + "]";}}

场景类

public class Client {public static void main(String[] args) {Handler handler1 = new ConcreteHandler1();Handler handler2 = new ConcreteHandler2();Handler handler3 = new ConcreteHandler3();handler1.seNext(handler2);handler2.seNext(handler3);Response res1 = handler1.handleMsg(new Request(1));Response res2 = handler1.handleMsg(new Request(2));Response res3 = handler1.handleMsg(new Request(3));System.out.println(res1);System.out.println(res2);System.out.println(res3);}}

输出

我是~~ [content=ConcreteHandler1]我是~~ [content=ConcreteHandler2]我是~~ [content=ConcreteHandler3]

在实际应用中，一般会有一个封装类负责对责任链模式进行封装，也就是替代Client类，直接返回责任链中的第一个处理者，类似下面：

public static Handler getConcreteHandler(){Handler handler1 = new ConcreteHandler1();Handler handler2 = new ConcreteHandler2();Handler handler3 = new ConcreteHandler3();handler1.seNext(handler2);handler2.seNext(handler3);return handler1;}

优缺点

优点：把请求和处理分开，请求者可以不需要知道是谁处理的，处理者可以不用知道请求的全貌（在J2EE的开发中，可以剥离出无状态Bean由责任链处理），两者解耦，提高系统灵活性；

缺点：性能问题：从头到尾遍历，若链比较长时性能较低，且调试不方便。

使用举例

   1.  一个请求（如银行客户存款货币），一个处理者（只处理人民币），随着业务增长（需处理美元、日元等），处理者数量和类型都增加，这时就可以在处理者后面建立一个链，只需要通过扩展实现类就可以很好地解决这些需求的变更。

  2. 业务用户有两种，VIP和普通，两者处理不同，信息也不同，这个时候就可以用责任链模式，统一传递到一个处理入口，这样无论哪种用户只需要传入相关参数即可，扩展即QQ的各种会员啊之类的~只需要添加设置级别、添加实现类就可以实现了。

代码源自设计模式之禅