责任链模式（Chain of Responsibility Pattern）

责任链模式是一种行为设计模式，它允许多个对象都有机会处理请求，从而避免了请求的发送者和接收者之间的耦合关系。请求沿着链传递，直到有一个对象处理它或者所有的对象都没有处理。

结构

• 处理者接口（Handler）： 定义了处理请求的方法和一个指向下一个处理者的引用。

public interface Handler {
    void setNextHandler(Handler nextHandler);
    void handleRequest(Request request);
}

• 具体处理者类（Concrete Handler）： 实现了处理者接口，具体处理请求的对象。

public class ConcreteHandlerA implements Handler {
    private Handler nextHandler;

    public void setNextHandler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public void handleRequest(Request request) {
        if (request.getType().equals("TypeA")) {
            System.out.println("Handled request of TypeA");
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        } else {
            System.out.println("Cannot handle the request");
        }
    }
}

• 请求类（Request）： 包含需要处理的请求的信息。

public class Request {
    private String type;

    public Request(String type) {
        this.type = type;
    }

    public String getType() {
        return type;
    }
}

优点和缺点

优点：

1. 松耦合： 请求发送者和接收者之间的关系解耦，请求的发送者不需要知道接收者的具体信息。
2. 灵活性： 可以动态地增加或修改处理请求的对象，灵活地组织责任链。
3. 可处理不确定数量的请求： 可以轻松地处理不确定数量的请求，只需在责任链中添加新的处理者对象即可。

缺点：

1. 性能问题： 请求可能会被责任链中的所有处理者都遍历一遍，可能影响性能。
2. 不能保证请求一定被处理： 如果责任链没有正确配置，或者某个处理者没有正确设置下一个处理者，请求可能无法被处理。

示例

以下是一个简单的责任链模式的示例，模拟了一个采购审批的场景。在这个示例中，Handler 是处理者接口，ConcreteHandler 是具体的处理者类，Request 是请求类。

// 处理者接口
public interface Handler {
    void setNextHandler(Handler nextHandler);
    void handleRequest(Request request);
}

// 具体处理者类
public class ConcreteHandler implements Handler {
    private Handler nextHandler;

    public void setNextHandler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public void handleRequest(Request request) {
        // 处理请求的逻辑
        if (/* 请求符合条件 */) {
            System.out.println("Handled the request");
        } else if (nextHandler != null) {
            // 将请求传递给下一个处理者
            nextHandler.handleRequest(request);
        } else {
            // 没有处理者能够处理请求
            System.out.println("No handler available for the request");
        }
    }
}

// 请求类
public class Request {
    private String type;

    public Request(String type) {
        this.type = type;
    }

    public String getType() {
        return type;
    }
}

// 客户端代码
public class Main {
    public static void main(String[] args) {
        Handler handlerA = new ConcreteHandler();
        Handler handlerB = new ConcreteHandler();

        handlerA.setNextHandler(handlerB);

        Request requestA = new Request("TypeA");
        Request requestB = new Request("TypeB");

        handlerA.handleRequest(requestA); // 输出：Handled the request
        handlerA.handleRequest(requestB); // 输出：No handler available for the request
    }
}

在这个示例中，ConcreteHandler 类实现了 Handler 接口，它可以处理满足条件的请求，如果请求不符合条件或者没有下一个处理者时，将请求传递给下一个处理者。客户端创建了两个处理者对象，将它们连接成责任链，并向其中一个处理者发送请求。如果请求符合第一个处理者的条件，它将被处理，否则请求会被传递给下一个处理者。