设计模式-行为型模式-责任链模式

定义

将请求沿着链传递，然后直到对象处理即可。

UML图

代码

基本的责任链

public class Test{
    public void test(int i, Request request){
        if(i == 1){
            Hander1.response(request);
        }
        
        if(i == 2){
            Hander2.response(request);
        }
        
        if(i == 3){
            Hander3.requese(request);
        }
    }
}

代码逻辑如上，只处理1，2,3情况，其余的情况都不处理。

责任链

// 对象
public class Level{
    private int level = 0;
    public Level(int level){
        this.level = level;
    }
    public boolean above(Level level){
        if(this.level >= level.level)
            return true;
        else
            return false;
    }
}

// 将对象进行封装
public class Request{
    Level level;
    public Request(Level level){
        this.level = level;
    }
    public Level getLevel(){
        return level;
    }
}

// 返回消息
public class Response{}

public abstract class Handler{
    private Handler nextHandler;
    public final Response handleRequest(Request request){
        Response response = null;
        // 根据处理器的优先级处理，如果优先级高，处理
        if(this.getHandlerLevel().above(request.getLevel())){
            // 如果寻找到处理器，进行处理
            response = this.response(request);
        }else{
            // 否则，进入下一个处理器
            if(this.nextHandler != null){
                this.nextHandler.handleRequest(request);
            }else{
                System.out.println("没有合适的处理器");
            }
        }
        return response;
    }
    // 设置下一个处理器
    public void setNextHandler(Handler handler){
        this.nextHandler = handler;
    }
    // 当前处理器
    protected abstract Level getHandlerLvel();
    // 进入处理器处理
    public abstract Response response(Request request);
}

// 第一个处理器
public class ConcreteHandler1 extends Handler{
    protected Level getHandlerLevel(){
        return new Level(1);
    }
    public Response response(Request request){
        System.out.println("处理1处理");
        return null;    // 下一个处理器为空
    }
}

// 第二个处理器
public class ConcreteHandler2 extends Handler{
    protected Level getHandlerLevel(){
        return new Level(3);
    }
    public Response response(Request request){
        System.out.println("处理1处理");
        return null;    // 下一个处理器为空
    }
}

// 第三个处理器
public class ConcreteHandler3 extends Handler{
    protected Level getHandlerLevel(){
        return new Level(5);
    }
    public Response response(Request request){
        System.out.println("处理1处理");
        return null;    // 下一个处理器为空
    }
}

// 最后定义场景
public class Client{
    public static void main(String[] args){
        // 新建处理器
        Handler handler1 = new ConcreteHandler1();
        Handler handler2 = new ConcreteHandler2();
        Handler handler3 = new ConcreteHandler3();
        
        // 设置下一个处理器
        // 处理器处理逻辑为先处理1，再处理2，再处理3
        handler1.setNextHandler(handler2);
        handler2.setNextHandler(handler3);
        
        // 进行处理
        Response response = handler1.handlerRequest(new Request(new Level(4)));
    }
}

总结

责任链模式核心在处理流，让对象在类之间流动，直到合适进行对象处理，并把下一个设置为空。
写法，当然就是新建几个处理器类，然后要处理的对象，处理类之间用next指向下一个，然后把处理的对象传入进去，如果找到合适的处理器，进行处理，并将下一个设置为空，完成责任链。
其中，几个处理器类可以抽象出一个抽象类，并把对象进行封装成一个类，以上为上方代码的设计思路。

应用

开发一个电商网站，支付过500元定金的用户，收到100元优惠卷，200元收到50元，没有支付过的，进入普通模式购买。
如果不用职责链，需要写入一大堆if语句。
将if语句拆分，使用职责链，将处理器类抽象出来，然后将购买的用户传入处理器，然后如果处理完成，下一个设置为空，返回结果。
另外一个应用，文件上传，使用的也是职责链。