常用设计模式——责任链模式

设计模式系列

1、组合模式
2、策略模式
3、单例模式
4、原型模式
5、模板模式
6、观察者模式
7、享元模式
8、装饰着模式
9、门面模式
10、责任链模式
11、建造者模式
12、适配器模式

---

---

什么是责任链模式

顾名思义，责任链模式就是每个处理者都有各自的责任，他们的责任都各自不同，每个请求的处理都不同，或多或少。我们把每个处理者排成队，每个处理者按照它们各自的责任处理这个请求并且指定了下一个处理器是谁，形成一个链路。这种类型的设计模式属于行为模式。

码云地址：去看源码

示例

1、定义一个请求 Request

定义的这个请求对象中，包含了 是否登录、是否授权，是否认证的标识。

public class Request {

    private boolean login;
    private boolean authority;
    private boolean identify;

    public Request(boolean login, boolean authority, boolean identify) {
        this.login = login;
        this.authority = authority;
        this.identify = identify;
    }

    public boolean isLogin() {
        return login;
    }

    public void setLogin(boolean login) {
        this.login = login;
    }

    public boolean isAuthority() {
        return authority;
    }
    
    public void setAuthority(boolean authority) {
        this.authority = authority;
    }
    
    public boolean isIdentify() {
        return identify;
    }
    
    public void setIdentify(boolean identify) {
        this.identify = identify;
    }
}

2、定义抽象处理器

每次请求都会经过多个处理器，定义一个抽象处理器并且指定下一个处理器是谁。

public abstract class Handler {

    Handler next;

    public Handler(Handler next) {
        this.next = next;
    }

    public Handler getNext(){
        return next;
    }

    public abstract boolean process(Request request);
}

3、 定义处理器

这里定义了 三个 处理器，分别是 登录处理器、认证处理器、授权处理器。

1、登录处理器

模拟登录效果，主要设置 请求参数中的 login 为 true，说明用户已经登录成功。

public class LoginHandler extends Handler {
    public LoginHandler(Handler next) {
        super(next);
    }

    @Override
    public boolean process(Request request) {
        if(!request.isLogin()){
            System.out.println("正在登录，登录成功");
            request.setLogin(true);
            Handler next = getNext();
            if(Objects.nonNull(next)){
                return next.process(request);
            }else{
                return true;
            }
        }
        return false;
    }
}

2、认证处理器

模拟身份认证，用户经过了登录成功之后，需要校验用户身份是否合法访问资源。

public class IdentifyHandler extends Handler {

    public IdentifyHandler(Handler next) {
        super(next);
    }

    @Override
    public boolean process(Request request) {
        if(!request.isIdentify()){
            System.out.println("正在认证，认证成功");
            request.setIdentify(true);
            Handler next = getNext();
            if(Objects.nonNull(next)){
                return next.process(request);
            }
            return true;
        }
        return false;
    }
}

3、授权处理器

模拟授权，用户登录和身份认证之后，检查用户是否有访问该资源的权利。

public class AuthorityHandler extends Handler {
    public AuthorityHandler(Handler next) {
        super(next);
    }

    @Override
    public boolean process(Request request) {
        if(!request.isAuthority()){
            System.out.println("正在授权，授权成功");
            request.setAuthority(true);
            Handler next = getNext();
            if(Objects.nonNull(next)){
                return next.process(request);
            }else{
                return true;
            }
        }
        return false;
    }
}

4、测试

假如一个请求进来之后，我们要进行 登录、认证、授权检测，那么我们可以把 这三个 处理器 挨个排队，让它们挨个去按照自己的 责任 去处理，也就是 process() 方法。

public class ChainTest {

    public static void main(String[] args) {

        Request request = new Request(false, false, false);
        //挨个排队
        LoginHandler handlers = new LoginHandler(new AuthorityHandler(new IdentifyHandler(null)));
        System.out.println("第一次处理");
        handlers.process(request);
        System.out.println("第二次处理");
        handlers.process(request);
    }

}

总结

此文中加入责任链的方式比较简单，类似于一个链表的形式，告诉当前处理器下一个处理器是谁，则会依次去处理每个请求。也可以有其他方式去实现，比如使用一个 LinkedList 加入每个处理器到一个责任链中。