java设计模式之责任链模式

一、责任链模式简介 责任链模式是对象的行为模式。使多个对象都有机会处理请求，从而避免请求的发送者和接受者直接的耦合关系。将这些对象连成一条链，沿着这条链传递该请求，直到有一个对象处理它为止。责任链模式强调的是每一个对象及其对下家的引用来组成一条链，利用这种方式将发送者和接收者解耦。 角色： 1、抽象处理者角色(Handler)： 定义出一个处理请求的接口。如果需要，接口可以定义出一个方法以设定和返回对下家的引用。这个角色通常由一个Java抽象类或者Java接口实现。 2、具体处理者角色(ConcreteHandler)： 具体处理者接到请求后，可以选择将请求处理掉，或者将请求传给下家。由于具体处理者持有对下家的引用，因此，如果需要，具体处理者可以访问下家。 模板示例： 1、抽象处理者角色 public abstract class Handler { /** * 持有后继的责任对象 */ protected Handler successor; /** * 示意处理请求的方法，传入一个参数 */ public abstract void handlerRequest(String condition); /** * 取值方法 */ public Handler getSuccessor() { return successor; } /** * 赋值方法，设置后继的责任对象 */ public void setSuccessor(Handler successor) { this.successor = successor; } } 2、具体处理者角色 public class ConcreteHandler1 extends Handler { @Override public void handlerRequest(String condition) { // 如果是自己的责任，就自己处理，否则负责传给下家处理 if(condition.equals("ConcreteHandler1")){ System.out.println( "ConcreteHandler1 handled "); return ; }else{ System.out.println( "ConcreteHandler1 passed "); getSuccessor().handlerRequest(condition); } } } public class ConcreteHandler2 extends Handler { @Override public void handlerRequest(String condition) { // 如果是自己的责任，就自己处理，否则负责传给下家处理 if(condition.equals("ConcreteHandler2")){ System.out.println( "ConcreteHandler2 handled "); return ; }else{ System.out.println( "ConcreteHandler2 passed "); getSuccessor().handlerRequest(condition); } } } public class ConcreteHandlerN extends Handler { /** * 这里假设n是链的最后一个节点必须处理掉。 * 在实际情况下，可能出现环，或者是树形， * 这里并不一定是最后一个节点。 * */ @Override public void handlerRequest(String condition) { System.out.println( "ConcreteHandlerN handled"); } }3、测试方法 public class Client { public static void main(String[] args) { Handler handler1 = new ConcreteHandler1(); Handler handler2 = new ConcreteHandler2(); Handler handlern = new ConcreteHandlerN(); //链起来handler1-->handler2-->handlern handler1.setSuccessor(handler2); handler2.setSuccessor(handlern); //假设这个请求是ConcreteHandler2的责任 handler1.handlerRequest("ConcreteHandler2"); } } 使用案例分析： 举这样一个例子，在玩具工厂的生产车间，流水线就是一条责任链，假如一个玩具飞机有外壳装配员，引擎装配员，螺旋桨装配员，模型包装员组成。当这个物件飞机流到谁那里，谁就负责安装他负责的这一部分，这部分安装完成后流到下一个环节，直到所有环境完成。这个是一个生产的责任链。还有一个质量检测链，质量检测也分多部，外壳检测，引擎检测，螺旋桨检测，包装检测。当产品留到检测员那里检测自己负责的那一块，如果有问题直接拎出来，如果没问题则传给下一个检测员，直到所有检测完成。这两个都是责任链，但是区别是，生成责任链每个人都会处理，并处理一部分；而质量检测责任链经过判断，要么处理掉，要么不处理流下去。这就是责任链的两种分类，后一种叫做纯的责任链，前一种叫做不纯的责任链，纯的责任链在实际应用中很少存在，常见的为不纯的责任链，上面的模型是模拟纯的责任链来处理的。 实际使用案例： 责任链模式在现实中使用的很多，常见的就是OA系统中的工作流。 在java中的实际应用有Servlet中的过滤器（Filter），Struts2的拦截器（Interceptor）。Struts2本身在Servlet中也是以Filter的形式出现的，所以Struts2的结构图中，也可以明显看出Filter和Interceptor这两条链的存在。 二、示例演示 1、定义请求级别的接口： // 全局变量，接口类型 interface Levels { public static final int LEVEL_01 = 1; public static final int LEVEL_02 = 2; public static final int LEVEL_03 = 3; } 2、定义请求的抽象类 // 抽象请求类 abstract class AbstractRequest { private String content = null; public AbstractRequest(String content) { this.content = content; } public String getContent() { return this.content; } // 获得请求的级别 public abstract int getRequestLevel(); }

3、定义请求的具体实现

// 具体请求类01 class Request01 extends AbstractRequest { public Request01(String content) { super(content); } @Override public int getRequestLevel() { return Levels.LEVEL_01; } } // 具体请求类02 class Request02 extends AbstractRequest { public Request02(String content) { super(content); } @Override public int getRequestLevel() { return Levels.LEVEL_02; } } // 具体请求类03 class Request03 extends AbstractRequest { public Request03(String content) { super(content); } @Override public int getRequestLevel() { return Levels.LEVEL_03; } }

4、定义处理请求的抽象类 // 抽象处理者类， abstract class AbstractHandler { // 责任链的下一个节点，即处理者 private AbstractHandler nextHandler = null; // 捕获具体请求并进行处理，或是将请求传递到责任链的下一级别 public final void handleRequest(AbstractRequest request) { // 若该请求与当前处理者的级别层次相对应，则由自己进行处理 if (this.getHandlerLevel() == request.getRequestLevel()) { this.handle(request); } else { // 当前处理者不能胜任，则传递至职责链的下一节点 if (this.nextHandler != null) { System.out.println("当前 处理者-0" + this.getHandlerLevel() + " 不足以处理 请求-0" + request.getRequestLevel()); // 这里使用了递归调用 this.nextHandler.handleRequest(request); } else { System.out.println("职责链上的所有处理者都不能胜任该请求..."); } } } // 设置责任链中的下一个处理者 public void setNextHandler(AbstractHandler nextHandler) { this.nextHandler = nextHandler; } // 获取当前处理者的级别 protected abstract int getHandlerLevel(); // 定义链中每个处理者具体的处理方式 protected abstract void handle(AbstractRequest request); } 5、实现具体的请求处理类 // 具体处理者-01 class Handler01 extends AbstractHandler { @Override protected int getHandlerLevel() { return Levels.LEVEL_01; } @Override protected void handle(AbstractRequest request) { System.out.println("处理者-01 处理 " + request.getContent() + "\n"); } } // 具体处理者-02 class Handler02 extends AbstractHandler { @Override protected int getHandlerLevel() { return Levels.LEVEL_02; } @Override protected void handle(AbstractRequest request) { System.out.println("处理者-02 处理 " + request.getContent()+ "\n"); } } // 具体处理者-03 class Handler03 extends AbstractHandler { @Override protected int getHandlerLevel() { return Levels.LEVEL_03; } @Override protected void handle(AbstractRequest request) { System.out.println("处理者-03 处理 " + request.getContent()+ "\n"); } } 6、测试类 // 测试类 public class Client { public static void main(String[] args) { // 创建指责链的所有节点 AbstractHandler handler01 = new Handler01(); AbstractHandler handler02 = new Handler02(); AbstractHandler handler03 = new Handler03(); // 进行链的组装，即头尾相连，一层套一层 handler01.setNextHandler(handler02); handler02.setNextHandler(handler03); // 创建请求并提交到指责链中进行处理 AbstractRequest request01 = new Request01("请求-01"); AbstractRequest request02 = new Request02("请求-02"); AbstractRequest request03 = new Request03("请求-03"); // 每次提交都是从链头开始遍历 handler01.handleRequest(request01); handler01.handleRequest(request02); handler01.handleRequest(request03); } } 7、结果： 处理者-01 处理 请求-01 当前 处理者-01 不足以处理 请求-02 处理者-02 处理 请求-02 当前 处理者-01 不足以处理 请求-03 当前 处理者-02 不足以处理 请求-03 处理者-03 处理 请求-03 8、分析： 在上面抽象处理者 AbstractHandler 类的 handleRequest() 方法中，被 protected 修饰，并且该方法中调用了两个必须被子类覆盖实现的抽象方法，这里是使用了模板方法模式（Template Mehtod）。其实在这里，抽象父类的 handleRequest() 具备了请求传递的功能，即对某些请求不能处理时，马上提交到下一结点（处理者）中，而每个具体的处理者仅仅完成了具体的处理逻辑，其他的都不用理。 三、总结 1、处理者在运行时动态确定是我们在 Client 中组装的链所引起的，因为具体的职责逻辑就在链中一一对应起来； 2、因为不确定请求的具体处理者是谁，所以我们把所有可能的处理者组装成一条链，在遍历的过程中就相当于向每个处理者都提交了这个请求，等待其审查。并且在审查过程中，即使不是最终处理者，也可以进行一些请求的“包装”操作（这种功能类似于装饰者模式）； 3、处理者集合的动态指定跟上面的第1、2点类似，即在 Client 类中创建了所有可能的处理者。 4、改变内部的传递规则 每个处理者都可以去动态地指定他的继任者。 5、可以从职责链任何一关开始。 6、用与不用的区别 不用职责链的结构，反映在代码上即使我们需要在一个类中去写上很多if….else语句。 如果用了职责链，相当于我们面对的是一个黑箱，我们只需要认识其中的一个处理者，然后让黑箱内部去负责传递就好了。