责任链设计模式一 概念

责任链设计模式就是将原本复杂的混合在一起的处理逻辑进行拆分，按照业务、相关性等因素拆分到多个处理器中，每个处理器只负责一部分逻辑处理；在执行的时候，一个处理器接一个处理器的从前到后的执行，在结构上看就像一个链条，这也是责任链名字的由来。

责任链设计模式能够让代码结构更清晰，更易于应对日后的功能扩展。

场景举例

比如一张优惠券，在使用的时候，后台代码要根据下单信息来判断这张优惠券是否可用，涉及判断的条件非常多，判断因素假设包含：

1、坎级，比如这张优惠券需要满100减10，满200减20，那么当前订单金额是否满足100元或200元；

2、品牌或品类，比如这张优惠券只能用在购买康师傅品牌的商品；

3、支付类型，只能线上支付时使用这张优惠券；

4、可用对象，只有购买平台自售商品才能使用这张优惠券，购买三方店铺商品则不能使用这张优惠券（类似京东某些券只能购买平台自营商品）。

实际上的业务可能包含更多条件和因素，实际的判断逻辑也会更复杂。

如果我们将这些平铺直叙的堆砌到代码里，实际可能一个类中按照不同因素，添加多个方法，最终有一个入口方法组织这些方法来判断。

代码类似于：

//判断坎级方法
public boolean 坎级(Coupon c) {
    ...
}

//判断品牌或品类方法
public boolean 品牌或品类(Coupon c) {
    ...
}

//判断支付类型方法
public boolean 支付类型(Coupon c) {
    ...
}

//判断可用对象方法
public boolean 可用对象(Coupon c) {
    ...
}

//判断优惠券是否可用入口方法
public boolean 入口(Coupon c) {
    坎级(Coupon c)
    品牌或品类(Coupon c)
    支付类型(Coupon c)
    可用对象(Coupon c)
    return 结果
}

上面这种写法相对还能够接受，但是如果有的开发者直接一个大方法包含了所有逻辑（搞一个5000行代码的方法），这对以后业务变更后的升级改造挖下了一个大大的坑。

那么我们用责任链如何改造呢？

1、首先定义接口，接口中定义handle方法

public interface IHandler {

    boolean handle();
}

2、按照业务需要实现4个处理器，都实现了IHandler 接口，并实现了handle方法

import java.util.Random;

/**
 * 坎级
 */
public class HandlerA implements IHandler {
    @Override
    public boolean handle() {
        Random r = new Random();
        //生成随机整数,能被2整除表示业务逻辑为true,否则为false
        boolean b = r.nextInt(10)%2 == 0;
        System.out.println("exec 坎级:" + b);
        return b;
    }
}

import java.util.Random;

/**
 * 品牌或品类
 */
public class HandlerB implements IHandler {
    @Override
    public boolean handle() {
        Random r = new Random();
        boolean b = r.nextInt(10)%2 == 0;
        System.out.println("exec 品牌或品类:" + b);
        return b;
    }
}

import java.util.Random;

/**
 * 支付类型
 */
public class HandlerC implements IHandler {
    @Override
    public boolean handle() {
        Random r = new Random();
        boolean b = r.nextInt(10)%2 == 0;
        System.out.println("exec 支付类型:" + b);
        return b;
    }
}

import java.util.Random;

/**
 * 可用对象
 */
public class HandlerD implements IHandler {
    @Override
    public boolean handle() {
        Random r = new Random();
        boolean b = r.nextInt(10)%2 == 0;
        System.out.println("exec 可用对象:" + b);
        return b;
    }
}

3、责任链执行

import java.util.ArrayList;
import java.util.List;

public class Client {

    void handle(List<IHandler> hl) {
        System.out.println("---全部执行---");
        for(IHandler h:hl) {
            //不管每个处理器的验证结果是否为true，都会把处理器执行一遍
            h.handle();
        }
    }

    void handle2(List<IHandler> hl) {
        System.out.println("---某个执行器验证不通过则退出执行---");
        for(IHandler h:hl) {
            //如果验证不通过直接退出执行
            if(!h.handle()) {
                break;
            }
        }
    }

    public static void main(String[] args) {
        List<IHandler> hl = new ArrayList<>();
        IHandler ha = new HandlerA();
        IHandler hb = new HandlerB();
        IHandler hc = new HandlerC();
        IHandler hd = new HandlerD();
        hl.add(ha);
        hl.add(hb);
        hl.add(hc);
        hl.add(hd);
        Client c = new Client();
        c.handle(hl);
        c.handle2(hl);
    }
}

我们的责任链的每个处理器用的list来保存，就是main函数的这段代码：

List<IHandler> hl = new ArrayList<>();
        IHandler ha = new HandlerA();
        IHandler hb = new HandlerB();
        IHandler hc = new HandlerC();
        IHandler hd = new HandlerD();
        hl.add(ha);
        hl.add(hb);
        hl.add(hc);
        hl.add(hd);

然后在handle方法中使用循环依次执行，最终形成了一个链条执行的效果。

这里的demo实现了两个handle方法，handle方法是不管每个处理器的验证结果是否为true，都会把处理器执行一遍，handle2方法是某个执行器验证不通过则退出执行，这个可以按照实际的业务场景需要来定。

其实责任链还有一种模式，就是每个handler类都持有下一个handle，也就是在上面demo的HandlerA 、HandlerB、HandlerC、HandlerD中定义一个IHandler接口类型的元素，这样每个处理器就可以保存这个处理器之后的处理器，这样再当前hander类执行完handle方法后，可以直接调用下一个handler的handle方法，这种更像是一种责任链。代码如下：

  IHandler ha = new HandlerA();
        IHandler hb = new HandlerB();
        IHandler hc = new HandlerC();
        IHandler hd = new HandlerD();
        ha.setHandle(hb);
        hb.setHandle(hc);
        hc.setHandle(hd);       

这样不使用list，也可以是多个处理器形成一个链条。

总结：

责任链就是将复杂的处理逻辑进行拆分，拆分成多个的处理器来逐个处理，各个处理器形成一个链条，每个处理器处理完后再传递给后续处理器继续处理。

责任链设计模式适用于复杂的逻辑判断处理的场景。