责任链模式示例

记一次责任链模式的使用，在传统的开发中，我们或多或少会遇到一些类似责任链的模式，比如过滤器，拦截器等等。

下面我们的责任链模式模拟简单拦截器的实现

1.标准的拦截器接口

public interface MethodInterceptor {
    /**
     * 标准拦截接口
     *
     * @param request  请求
     * @param response 返回
     * @return boolean
     * @date 2022/12/2 8:43
     * @author glq
     */
    boolean post(Map<String,Object> request, Map<String,Object> response);
}

2.自定义AuthInterceptor实现标准接口

public class AuthInterceptor implements MethodInterceptor {
    @Override
    public boolean post(Map<String, Object> request, Map<String, Object> response) {

        System.out.println("--------------放行系统权限-------");
        return true;
    }
}

3.自定义UserInterceptor实现标准接口

public class UserInterceptor implements MethodInterceptor {
    @Override
    public boolean post(Map<String, Object> request, Map<String, Object> response) {
        System.out.println("-----用户拦截----");
        Object user = request.get("user");
        return user != null;
    }
}

4.责任链核心抽象类Chain

public abstract class Chain {

    public abstract void execute(Map<String, Object> request, Map<String, Object> response);

    public abstract void setNext(Chain next);

    protected Chain next;

    protected MethodInterceptor methodInterceptor;

    @Override
    public String toString() {
        return "Chain{" +
                "next=" + next +
                '}';
    }
}

5.责任链实现类（多元化每种责任链的模式）

public class ChainImpl extends Chain {

    public ChainImpl(MethodInterceptor methodInterceptor) {
        super.methodInterceptor = methodInterceptor;
    }

    @Override
    public void setNext(Chain next) {
        super.next = next;
    }

    @Override
    public void execute(Map<String, Object> request, Map<String, Object> response) {
        boolean post = methodInterceptor.post(request, response);
        if (post) {
            if (next != null) {
                next.execute(request, response);
            }
        }

    }

    @Override
    public String toString() {
        return "ChainImpl{" +
                "next=" + next +
                '}';
    }
}

此处的设计思路是模拟拦截器的前置处理，上一个处理器返回true才会让后续的处理器执行，否则中断。

6.测试类

public class Test {
    public static void main(String[] args) {
        List<MethodInterceptor> methodInterceptors = new ArrayList<>();
        methodInterceptors.add(new UserInterceptor());
        methodInterceptors.add(new AuthInterceptor());
        methodInterceptors.add(new AuthInterceptor());
        Map<String, Object> request = new HashMap<>();
        Map<String, Object> response = new HashMap<>();
        Chain chain = null;
        Chain current = new ChainImpl(methodInterceptors.get(0));
        for (int i = 0; i < methodInterceptors.size(); i++) {
            if (i == 0) {
                chain = current;
            }
            if (i + 1 < methodInterceptors.size()) {
                Chain next = new ChainImpl(methodInterceptors.get(i + 1));
                current.setNext(next);
                current = next;
            }

        }
        request.put("user", "cat");
        chain.execute(request, response);


    }
}

核心思想就是把各个处理器串起来，当前处理器储存下一个处理器的内部地址，到最后一个就不存储了，说明责任链结束。

未注释 request.put("user", "cat");

打印:

-----用户拦截----

--------------放行系统权限-------

--------------放行系统权限-------

注释 request.put("user", "cat");

-----用户拦截----