责任链模式

Posted 2021-03-15 milovetingting

个人博客

http://www.milovetingting.cn

责任链模式

模式介绍

责任链模式是行为型设计模式之一。

模式定义

使多个对象都有机会处理请求，从而避免了请求的发送者和接收者间的耦合。将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止。

使用场景

1. 多个对象可以处理同一请求，但具体由哪个对象处理则在运行时动态决定。

2. 在请求处理者不明确的情况下向多个对象的一个提交请求。

3. 需要动态指定 组对象处理请求。

简单使用

定义抽象请求类

public abstract class AbstractRequest {
    
    /**
     * 处理对象
     */
    private Object obj;

    public AbstractRequest(Object obj) {
        this.obj = obj;
    }

    /**
     * 获取处理对象
     * @return
     */
    public Object getContent() {
        return obj;
    }

    /**
     * 获取请求级别
     * @return
     */
    public abstract int getRequestLevel();
}

定义抽象处理类

public abstract class AbstractHandler {

    /**
     * 下一个处理者
     */
    AbstractHandler nextHandler;

    /**
     * 获取处理级别
     * 
     * @return
     */
    abstract int getHandlerLevel();

    /**
     * 处理请求
     * 
     * @param request
     */
    abstract void handle(AbstractRequest request);

    /**
     * 统一处理
     * 
     * @param request
     */
    public final void handleRequest(AbstractRequest request) {
        if (getHandlerLevel() == request.getRequestLevel()) {
            handle(request);
        } else {
            if (nextHandler != null) {
                nextHandler.handleRequest(request);
            } else {
                System.out.println("All of handler can not handle the request:" + request.getRequestLevel());
            }
        }
    }

}

定义具体请求类

public class Request1 extends AbstractRequest {

    public Request1(Object obj) {
        super(obj);
    }

    @Override
    public int getRequestLevel() {
        return 1;
    }

}

public class Request2 extends AbstractRequest {

    public Request2(Object obj) {
        super(obj);
    }

    @Override
    public int getRequestLevel() {
        return 2;
    }

}

public class Request3 extends AbstractRequest {

    public Request3(Object obj) {
        super(obj);
    }

    @Override
    public int getRequestLevel() {
        return 3;
    }

}

定义具体处理类

public class Handler1 extends AbstractHandler {

    @Override
    int getHandlerLevel() {
        return 1;
    }

    @Override
    void handle(AbstractRequest request) {
        System.out.println("Handler1 handle request:" + request.getRequestLevel());
    }

}

public class Handler2 extends AbstractHandler {

    @Override
    int getHandlerLevel() {
        return 2;
    }

    @Override
    void handle(AbstractRequest request) {
        System.out.println("Handler2 handle request:" + request.getRequestLevel());
    }

}

调用

public static void main(String[] args) {
        AbstractRequest request1 = new Request1("Request1");
        AbstractRequest request2 = new Request2("Request2");
        AbstractRequest request3 = new Request3("Request3");
        AbstractHandler handler1 = new Handler1();
        AbstractHandler handler2 = new Handler2();
        handler1.nextHandler = handler2;
        handler1.handleRequest(request1);
        handler1.handleRequest(request2);
        handler1.handleRequest(request3);
    }

输出结果

Handler1 handle request:1
Handler2 handle request:2
All of handler can not handle the request:3