设计模式-责任链模式

责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。

在这种模式中，通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推。

职责链可以是一条直线、一个环或者一个树形结构，最常见的职责链是直线型，即沿着一条单向的链来传递请求。链上的每一个对象都是请求处理者，责任链模式可以将请求的处理者组织成一条链，并让请求沿着链传递，由链上的处理者对请求进行相应的处理，客户端无须关心请求的处理细节以及请求的传递，只需将请求发送到链上即可，实现请求发送者和请求处理者解耦。

在责任链模式结构图中包含如下几个角色：

• Handler（抽象处理者）：定义一个处理请求的接口，一般为抽象类，请求处理方法为抽象方法，不同的具体处理者实现具体的请求处理。因为每一个处理者的下家还是一个处理者，因此在抽象处理者中定义了一个抽象处理者类型的对象，作为其对下家的引用。通过该引用，处理者可以连成一条链。
• ConcreteHandler（具体处理者）：它是抽象处理者的子类，可以处理用户请求，在具体处理者类中实现了抽象处理者中定义的抽象请求处理方法，在处理请求之前需要进行判断，看是否有相应的处理权限，如果可以处理请求就处理它，否则将请求转发给后继者；在具体处理者中可以访问链中下一个对象，以便请求的转发。

要形成链式调用，关键在于每一个处理者中有一个下一个处理者的引用。

代码实现如下:

抽象处理以及具体处理类

/**
 * <p>
 *抽象处理者角色
 * </p>
 *
 * @since 2022/3/22 9:01
 */
public interface Processor {
    boolean process(Product product, ProcessorChain processorChain);
}

/**
 * <p>
 * 具体处理人角色
 * </p>
 *
 * @since 2022/3/22 9:03
 */
public class LengthCheckProcessor implements Processor {

    @Override
    public boolean process(Product product, ProcessorChain processorChain) {
        Integer length = product.getLength();
        if (length < 100) {
            System.out.println("length ok");
            return processorChain.process(product, processorChain);
        }
        System.out.println("length false");
        return false;
    }
}

/**
 * <p>
 * 具体处理人角色
 * </p>
 *
 * @since 2022/3/22 9:03
 */
public class WidthCheckProcessor implements Processor {

    @Override
    public boolean process(Product product, ProcessorChain processorChain) {
        Integer width = product.getLength();
        if (width < 100) {
            System.out.println("width ok");
            return processorChain.process(product, processorChain);
        }
        System.out.println("width false");
        return false;
    }
}

构造责任链对象

/**
 * <p>
 * 构造链对象
 * </p>
 *
 * @since 2022/3/22 8:57
 */
public class ProcessorChain {
    private List<Processor> processors = new ArrayList<>();

    private int index = 0;

    public ProcessorChain addProcessor(Processor processor) {
        processors.add(processor);
        return this;
    }

    public boolean process(Product product, ProcessorChain processorChain) {
        if (index == processors.size()) {
            return true;
        }
        Processor processor = processors.get(index);
        index++;
        return processor.process(product, processorChain);
    }
}

具体处理业务对象类

/**
 * <p>
 * 产品类对象，具体业务对象
 * </p>
 *
 * @since 2022/3/22 8:56
 */
@Data
@AllArgsConstructor
public class Product {
    private Integer length;
    private Integer width;
}

测试客户端类

/**
 * <p>
 *代码demo，测试责任链对象
 * </p>
 *
 * @since 2022/3/22 9:08
 */
public class Client {
    public static void main(String[] args) {
        int[][] arrays = {{50, 50}, {100, 120}, {52, 42}};
        for (int[] array : arrays) {
            ProcessorChain processorChain = new ProcessorChain();
            processorChain.addProcessor(new LengthCheckProcessor());
            processorChain.addProcessor(new WidthCheckProcessor());
            Product product = new Product(array[0], array[1]);
            boolean checkResult = processorChain.process(product, processorChain);
            if (checkResult) {
                System.out.println("product ok");
            } else {
                System.out.println("product no ok");
            }

        }
    }
}