设计模式之旅21--责任链模式

1. 定义

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

责任链模式的重点是在“链”上，由一条链去处理相似的请求在链中决定谁来处理这个请求，并返回相应的结果。

责任链模式

2. 使用场景

• 多个对象可以处理同一个请求，但是具体由哪个对象处理需要在运行时动态决定。
• 在处理对象不明确的前提下，向多个对象提交一个请求。
• 需要动态指定一组对象来处理请求。

3. 实现

抽象处理者：

/**
 * 抽象处理者
 * 抽象的处理者实现三个职责：
 * 1. 定义一个对外开放的请求的处理方法handleMessage模板方法（final）
 * 2. 定义一个链的编排方法setNext，设置下一个处理者
 * 3. 定义了具体的请求者必须实现的两个方法：定义自己能够处理的级别getHandlerLevel和具体的处理任务doSomething方法
 */
public abstract class Handler {

    private Handler mNextHandler;

    public final Response handleRequest(Request request) {
        Response response;
        //判断是否是自己的处理级别
        if (request.getRequestLevel() == this.getHandlerLevel()) {
            response = this.doSomething(request);
        } else if (this.mNextHandler != null) {
            //不属于自己的处理级别，交给下一个处理
            response = this.mNextHandler.handleRequest(request);
        } else {
            //没有适当的处理者,业务自行处理
            response = new Response("没有适当的处理者");
        }
        return response;
    }

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

    protected abstract int getHandlerLevel();

    protected abstract Response doSomething(Request request);
}

具体处理者：

public class ConcreteHandler1 extends Handler {
    @Override
    protected int getHandlerLevel() {
        return 1;
    }

    @Override
    protected Response doSomething(Request request) {
        return new Response(this.getClass().getSimpleName() + "处理了" + request.getRequest());
    }
}

public class ConcreteHandler2 extends Handler {
    @Override
    protected int getHandlerLevel() {
        return 2;
    }

    @Override
    protected Response doSomething(Request request) {
        return new Response(this.getClass().getSimpleName() + "处理了" + request.getRequest());
    }
}

public class ConcreteHandler3 extends Handler {
    @Override
    protected int getHandlerLevel() {
        return 3;
    }

    @Override
    protected Response doSomething(Request request) {
        return new Response(this.getClass().getSimpleName() + "处理了" + request.getRequest());
    }
}

相关框架代码：

/**
 * 请求
 */
public class Request {

    //请求等级
    private int mRequestLevel;
    //请求参数
    private String mRequest;
    
    public Request(int requestLevel, String request) {
        this.mRequestLevel = requestLevel;
        this.mRequest = request;
    }

    public int getRequestLevel() {
        return this.mRequestLevel;
    }

    public String getRequest() {
        return this.mRequest;
    }
}

/**
 * 相应
 */
public class Response {

    //相应内容
    private String mResult;

    public Response(String result) {
        this.mResult = result;
    }

    public String getReslust() {
        return this.mResult;
    }
}

场景类：

public class Client {

    public static void main(String[] args) {
        Handler handler1 = new ConcreteHandler1();
        Handler handler2 = new ConcreteHandler2();
        Handler handler3 = new ConcreteHandler3();

        //动态生成处理者的责任链
        handler1.setNextHandler(handler2);
        handler2.setNextHandler(handler3);

        //发送请求A
        Response response1 = handler1.handleRequest(new Request(1, "请求A"));
        System.out.println(response1.getReslust());

        //发送请求B
        Response response2 = handler1.handleRequest(new Request(2, "请求B"));
        System.out.println(response2.getReslust());

        //发送请求C
        Response response3 = handler1.handleRequest(new Request(3, "请求C"));
        System.out.println(response3.getReslust());
    }
}

运行结果：

ConcreteHandler1处理了请求A
ConcreteHandler2处理了请求B
ConcreteHandler3处理了请求C

4. 优点

• 责任链模式非常显著的优点是将请求和处理分开。请求者可以不用知道是谁处理的，处理者可以不用知道请求的全貌。
• 请求和处理解耦，提高了系统的灵活性。

5. 缺点

• 性能问题。每个请求都是从链头遍历到链尾,特别是在链比较长的时候,性能是一个非常大的问题。（观察者模式也有类似问题）
• 调试不很方便。特别是链条比较长，环节比较多的时候，由于采用了类似递归的方式，调试的时候逻辑可能比较复杂。