Java实现责任链模式

责任链模式是一种设计模式，用于处理请求的解耦。在责任链模式中，多个对象都有机会处理请求，从而避免了请求发送者和接收者之间的直接依赖关系。每个处理者都可以决定是否处理请求以及将请求传递给下一个处理者。

简介

责任链模式由一条链组成，每个处理者都有一个对下一个处理者的引用。当请求进入链中时，从链的开头开始依次询问每个处理者是否能够处理该请求。如果某个处理者能够处理请求，则处理请求并结束链，否则将请求传递给下一个处理者。这样，请求会在链上依次传递，直到有一个处理者能够处理请求或者到达链的末尾。

使用场景

责任链模式因为可以灵活地配置处理者的顺序和数量，而不需要修改客户端代码。所以责任链模式在项目实战中用处广泛。

JDK中的异常处理机制就使用了责任链模式。当某个方法抛出异常时，首先会在方法内部寻找try-catch块来捕获异常，如果没有找到，就会将异常向上一层抛出，直至找到合适的catch块处理。
Spring框架中的拦截器链机制也使用了责任链模式。拦截器链是通过将各个拦截器按照一定的顺序连接起来形成一个链条，在请求处理过程中按顺序调用每个拦截器的相应方法来完成一系列操作。

责任链模式还可以用于处理日志记录、用户权限验证等场景。

开发实例

现在我简单用Java代码实现责任链模式，帮助大家快速入门理解

定义责任链抽象类

首先需要定义责任链抽象类，其作用是定义一个抽象的责任链，将处理请求的对象串联起来，并且定义了处理请求的方法。

@Data
public abstract class AbstractHandler<T> {
    protected String name;

    protected AbstractHandler<T>  nextHandler;

    public AbstractHandler(String name){
        this.name = name;
    }

    public boolean hasNextHandler(){
        return nextHandler != null;
    }

    /**
     * 业务处理方法
     * @param t 传入参数
     * @return
     */
    public abstract T process(T t);
}

具体业务处理类

业务处理类1

/**
 * 将传入的数字加2
 */
public class AddTwoHandler extends AbstractHandler<Integer>{

    public AddTwoHandler(String name) {
        super(name);
    }

    @Override
    public Integer process(Integer t) {
        t = t + 2;
        if(hasNextHandler()) {
            return nextHandler.process(t);
        }
        return t;
    }
}

业务处理类2

/**
 * 将传入的数字乘3
 */
public class MultiThreeHandler extends AbstractHandler<Integer>{
    public MultiThreeHandler(String name) {
        super(name);
    }

    @Override
    public Integer process(Integer t) {
        t = t * 3;
        if(hasNextHandler()) {
            return nextHandler.process(t);
        }
        return t;
    }
}

业务处理类3

/**
 *  将传入的数字减1
 */
public class DecreaseOneHandler extends AbstractHandler<Integer>{
    public DecreaseOneHandler(String name) {
        super(name);
    }

    @Override
    public Integer process(Integer t) {
        t = t - 1;
        if(hasNextHandler()) {
            return nextHandler.process(t);
        }
        return t;
    }
}

代码测试

public class ChainTest {
    public static void main(String[] args) {
        AddTwoHandler two = new AddTwoHandler("加2");
        DecreaseOneHandler one = new DecreaseOneHandler("减1");
        MultiThreeHandler three = new MultiThreeHandler("乘3");

        two.nextHandler = one;
        one.nextHandler = three;

        Integer result = two.process(5);
        System.out.println(result);
    }
}

实现业务处理是，开始值是5，开始执行“加2”操作，之后执行“减1”操作，在之后执行“乘3”操作，最后输出结果18。

在不改变代码的情况下，如果修改链式的处理顺序，那结果也就完全不一样了，这就带来很多可扩展性，我们可以很灵活地改变处理者的顺序和添加新的处理者。