设计模式--责任链模式

Java工程源码

类图

---

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

---

优点
- 将请求和处理分开，两者解耦，提高系统灵活性

缺点
- 性能问题 每个请求都是从链头遍历到链尾，链比较长时，存在性能问题
- 调试不方便 因为采用了递归的方式

---

扩展
责任链模式核心是 作为请求者不用知道到底是需要谁来处理的

---

处理等级

public class Level {
    // 定义一个请求和处理等级
    private int n;

    public Level(int _n) {
        this.n = _n;
    }

    public void setLevel(int _n) {
        this.n = _n;
    }

    public int getLevel() {
        return n;
    }
}

请求

public class Request {
    //处理等级
    private Level level;

    public Request(Level _level) {
        this.level = _level;
    }

    /**
     * 获取请求的等级
     */
    public Level getRequestLevel() {
        return level;
    }
}

应答

public class Response {
    private int n;

    public Response(int _n) {
        this.n = _n;
    }

    // 处理返回数据
    public void show() {
        System.out.println("我是响应 n:" + n);
    }
}

抽象处理者

public abstract class Handler {
    /**
     * 下一个处理者
     */
    private Handler nextHandler;

    /**
     * 处理请求
     *
     * @param request 请求
     * @return 响应结果
     */
    public final Response handleMessage(Request request) {
        Response response = null;
        // 如果级别相同，处理任务
        if (getHandlerLevel().equals(request.getRequestLevel())) {
            System.out.println("找到了处理者：处理者Level" + getHandlerLevel().getLevel());
            //开始处理任务
            response = echo(request);
        }
        // 如果级别不同,责任链还有下一个处理者
        else if (nextHandler != null) {
            System.out.println("当前处理者：处理者Level:" + getHandlerLevel().getLevel());
            System.out.println(" ->下一个处理者：处理者Level:" + nextHandler.getHandlerLevel().getLevel());
            // 让下一个处理者接收请求，并返回处理响应
            response = nextHandler.handleMessage(request);
        }
        return response;
    }

    /**
     * 设置下一个处理者是谁
     *
     * @param _handler 下一个处理者
     */
    public void setNext(Handler _handler) {
        this.nextHandler = _handler;
    }

    /**
     * 每一个处理者有一个处理级别
     *
     * @return 处理级别
     */
    protected abstract Level getHandlerLevel();

    /**
     * 每一个处理者必须实现处理任务
     *
     * @param request 处理请求
     * @return 处理响应
     */
    protected abstract Response echo(Request request);
}

具体处理者

public class ConcreteHandler extends Handler {
    private Level level;
    private Response response;

    public ConcreteHandler(Level _level, Response _response) {
        //设置自己的处理级别
        this.level = _level;
        this.response = _response;
    }

    @Override
    protected Level getHandlerLevel() {
        return level;
    }

    @Override
    protected Response echo(Request request) {
        // 完成处理逻辑
        System.out.println("处理者Level"
                + getHandlerLevel().getLevel() + "开始处理请求");
        System.out.println("完成处理逻辑 request.level="
                + request.getRequestLevel().getLevel());
        return response;
    }
}

场景类

public class Client {
    public static void main(String[] args) {
        Level l1 = new Level(1);
        Level l2 = new Level(2);
        Level l3 = new Level(3);
        Handler handler1 = new ConcreteHandler(l1, new Response(1));// 处理者1
        Handler handler2 = new ConcreteHandler(l2, new Response(2));// 处理者2
        Handler handler3 = new ConcreteHandler(l3, new Response(3));// 处理者3
        // 形成责任链
        handler1.setNext(handler2);
        handler2.setNext(handler3);
        // 执行责任链，获取响应,可以从不同的处理者开始找请求的处理等级
//        Response response = handler1.handleMessage(new Request(l1));
//        Response response = handler1.handleMessage(new Request(l2));
//        Response response = handler2.handleMessage(new Request(l3));
        Response response = handler1.handleMessage(new Request(l3));
        if (response != null) {
            response.show();
        } else {
            System.out.println("没有处理者处理请求");
        }
    }
}

运行结果

当前处理者：处理者Level:1
 ->下一个处理者：处理者Level:2
当前处理者：处理者Level:2
 ->下一个处理者：处理者Level:3
找到了处理者：处理者Level3
处理者Level3开始处理请求
完成处理逻辑 request.level=3
我是响应 n:3