巧妙的运用责任链模式，让你的代码高出一个逼格！

fatherlaw

发布于 2022-9-21 10:43

5981浏览

0收藏

一、介绍

什么是责任链模式？（Chain of Responsibility Pattern），简单的说，为请求者和接受者之间创建一条对象处理链路，避免请求发送者与接收者耦合在一起！

例如，如下图：

巧妙的运用责任链模式，让你的代码高出一个逼格！-鸿蒙开发者社区

从设计的角度看，责任链模式涉及到四个角色：

请求角色：可以是外部的请求或者内部的请求，最终体现就是一个请求数据体；
抽象处理器角色：定义处理的一些基本的规范；
具体处理器角色：实现或者继承抽象处理器，完成具体的计算任务；
接着角色：用于接受请求数据最终的处理结果；

下面我们一起来看看具体的实际应用！

二、示例

在实际开发中，经常避免不了会与其他公司进行接口对接，绝大部分请求参数都是经过加密处理再发送到互联网上，下面我们以对请求参数进行验证、封装处理为例，来诠释责任链模式的玩法，实现过程如下！

我们先编写一个加密工具类，采用AES加密算法

public class AESUtil {

    private static Logger log = LoggerFactory.getLogger(AESUtil.class);

    private static final String AES = "AES";

    private static final String AES_CVC_PKC = "AES/CBC/PKCS7Padding";

    static {
        Security.addProvider(new BouncyCastleProvider());
    }

    /**
     * 加密
     * @param content
     * @param key
     * @return
     * @throws Exception
     */
    public static String encrypt(String content, String key){
        try {
            SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(), AES);
            Cipher cipher = Cipher.getInstance(AES_CVC_PKC);
            IvParameterSpec iv = new IvParameterSpec(new byte[16]);
            cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec, iv);
            byte[] encrypted = cipher.doFinal(content.getBytes());
            return Base64.getEncoder().encodeToString(encrypted);
        }  catch (Exception e) {
            log.warn("AES加密失败,参数:{}，错误信息:{}", content, ExceptionUtils.getStackTrace(e));
            return "";
        }
    }

    /**
     * 解密
     * @param content
     * @param key
     * @return
     * @throws Exception
     */
    public static String decrypt(String content, String key){
        try {
            SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(), AES);
            Cipher cipher = Cipher.getInstance(AES_CVC_PKC);
            IvParameterSpec iv = new IvParameterSpec(new byte[16]);
            cipher.init(Cipher.DECRYPT_MODE, secretKeySpec, iv);
            byte[] encrypted = Base64.getDecoder().decode(content);
            byte[] original = cipher.doFinal(encrypted);
            return new String(original, "UTF-8");
        } catch (Exception e) {
            log.warn("AES解密失败,参数:{}，错误信息:{}", content, ExceptionUtils.getStackTrace(e));
            return "";
        }
    }


    public static void main(String[] args) throws Exception {
        String key = "1234567890123456";
        String content = "{\"userCode\":\"zhangsan\",\"userPwd\":\"123456\"}";
        String encryptContext = encrypt(content, "1234567890123456");
        System.out.println("加密后的内容：" + encryptContext);
        String decryptContext = decrypt(encryptContext, key);
        System.out.println("解密后的内容：" + decryptContext);
    }

}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.

执行结果如下：

加密后的内容：5ELORDsYKxCz6Ec377udct7dBMI74ZtJDCFL4B3cpoBsPC8ILH/aiaRFnZa/oTC5
解密后的内容：{"userCode":"zhangsan","userPwd":"123456"}1.
2.

其中加密后的内容可以看作为请求者传过来的参数！

同时，再创建一个上下文实体类ServiceContext，用于数据记录

/**
 * 上下文
 */
public class ServiceContext {

    /**
     * 请求参数
     */
    private String requestParam;

    /**
     * 解密后的数据
     */
    private String jsonData;

    /**
     * 用户账号
     */
    private String userCode;

    /**
     * 用户密码
     */
    private String userPwd;

    //省略set\get

    public ServiceContext(){
    }

    public ServiceContext(String requestParam){
        this.requestParam = requestParam;
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.

然后，创建一个处理器接口HandleIntercept

public interface HandleIntercept {

    /**
     * 对参数进行处理
     * @param context
     * @return
     */
    ServiceContext handle(ServiceContext context);

}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

紧接着，创建两个处理器实现类，用于参数解密、业务数据验证

/**
 * 解密请求数据
 */
public class DecodeDataHandle implements HandleIntercept {

    private String key = "1234567890123456";

    @Override
    public ServiceContext handle(ServiceContext context){
        String jsonData = AESUtil.decrypt(context.getRequestParam(), key);
        if(StringUtils.isEmpty(jsonData)){
            throw new IllegalArgumentException("解密失败");
        }
        context.setJsonData(jsonData);
        return context;
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.

/**
 * 验证业务数据并封装
 */
public class ValidDataHandle implements HandleIntercept {

    @Override
    public ServiceContext handle(ServiceContext context){
        String jsonData = context.getJsonData();
        JSONObject jsonObject = JSONObject.parseObject(jsonData);
        if(!jsonObject.containsKey("userCode")){
            throw new IllegalArgumentException("userCode不能为空");
        }
        context.setUserCode(jsonObject.getString("userCode"));
        if(!jsonObject.containsKey("userPwd")){
            throw new IllegalArgumentException("userPwd不能为空");
        }
        context.setUserPwd(jsonObject.getString("userPwd"));
        return context;
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.

最后创建一个处理链路管理器HandleChain

/**
 * 请求处理链路管理器
 */
public class HandleChain {
    
    private List<HandleIntercept> handleInterceptList = new ArrayList<>();

    /**
     * 添加处理器
     * @param handleIntercept
     */
    public void addHandle(HandleIntercept handleIntercept){
        handleInterceptList.add(handleIntercept);
    }

    /**
     * 执行处理
     * @param context
     * @return
     */
    public ServiceContext execute(ServiceContext context){
        if(!handleInterceptList.isEmpty()){
            for (HandleIntercept handleIntercept : handleInterceptList) {
                context =handleIntercept.handle(context);
            }
        }
        return context;
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.

写完之后，我们编写一个测试类ChainClientTest

public class ChainClientTest {

    public static void main(String[] args){
        //获取请求参数
        String requestParam = "5ELORDsYKxCz6Ec377udct7dBMI74ZtJDCFL4B3cpoBsPC8ILH/aiaRFnZa/oTC5";
        //封装请求参数
        ServiceContext serviceContext = new ServiceContext(requestParam);

        //添加处理链路
        HandleChain handleChain = new HandleChain();
        handleChain.addHandle(new DecodeDataHandle());//解密处理
        handleChain.addHandle(new ValidDataHandle());//数据验证处理

        //执行处理链,获取处理结果
        serviceContext = handleChain.execute(serviceContext);
        System.out.println("处理结果：" + JSONObject.toJSONString(serviceContext));
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.

执行之后结果如下：

处理结果：{"jsonData":"{\"userCode\":\"zhangsan\",\"userPwd\":\"123456\"}","requestParam":"5ELORDsYKxCz6Ec377udct7dBMI74ZtJDCFL4B3cpoBsPC8ILH/aiaRFnZa/oTC5","userCode":"zhangsan","userPwd":"123456"}1.

巧妙的运用责任链模式，让你的代码高出一个逼格！-鸿蒙开发者社区

可以很清晰的看到，从请求者发送数据经过处理器链路之后，数据都封装到上下文中去了！

如果想继续验证用户和密码是否合法，可以继续添加新的处理器，即可完成数据的处理验证！

如果是传统的方法，可能就是多个if，进行嵌套，类似如下：

if(condition){
    if(condition){
        if(condition){
   //业务处理
        }
    }
}1.
2.
3.
4.
5.
6.
7.

这种模式，最大的弊端就是可读性非常差，而且代码不好维护！

而责任链是从接口层进行封装处理和判断，可扩展性非常强！

三、应用

责任链模式的使用场景，这个就不多说了，最典型的就是 Servlet 中的 Filter，有了上面的分析，大家应该也可以理解 Servlet 中责任链模式的工作原理了，然后为什么一个一个的 Filter 需要配置在 web.xml 中，其实本质就是将 filter 注册到处理器中。

public class TestFilter implements Filter{

    public void doFilter(ServletRequest request, ServletResponse response,
            FilterChain chain) throws IOException, ServletException {
        chain.doFilter(request, response);
    }

    public void destroy(){}
    public void init(FilterConfig filterConfig) throws ServletException {}
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

四、总结

既然责任链模式这么好用，那什么时候用责任链模式？

在系统设计的时候，如果每个 if 都有一个统一的抽象，例如参数加密、系统数据验证、业务参数验证等等处理，可以将其抽象，使用对象处理进行链式调用，不仅实现优雅，而且易复用可扩展。

五、参考

1、五月的仓颉 - 责任链模式

分类

其他

标签

Java

已于2022-9-21 10:43:21修改

51CTO

51CTO博客

51CTO学堂