通用接口开放平台设计与实现——（40）API服务之职责链设计模式的运用_使用设计模式 完成相关接口平台的设计

上篇使用简单粗暴方式，实现了API服务接口的视乎框架，灵活性和扩展性欠佳，我们是不是可以借鉴netty优秀的设计思路，采用职责链的设计模式，来实现接口处理器的灵活装配和数据处理呢？
​

有了这个想法，然后动手尝试改造，实现了以下一系列接口与类。

实现过程中也不断查看netty的相应实现，实际上，rest接口，比消息要简单得多，并没有完全照搬，做了一些简化工作，例如并未实现Context对象。
​

HttpChain对应于Pipeline，内部直接使用JDK自己的LinkedList，实现了双向链表。
​

随着实现地深入，发现api服务和消息差异比较大，参照netty实现并不是明智的选择。
​

停下来反思了下，Filter的设计与实现思路，与我们的需求非常吻合。
​

因此参照Filter的思路，重新实现了一版，核心代码如下：
​

API过滤器链条，主要是参照了MockFilterChain的实现代码

/**
 *
 * API过滤器链条
 * @author wqliu
 * @date 2022-2-12 15:00
 **/
public class ApiFilterChain {

    /**
     * 请求
     */
    private ApiRequest request;

    /**
     * 响应
     */
    private ApiResponse response=new ApiResponse();


    /**
     * 过滤器集合
     */
    private final List<ApiFilter> filters;

    /**
     * 过滤器迭代器
     */
    private Iterator<ApiFilter> iterator;

    public ApiFilterChain(){
        filters= Collections.EMPTY_LIST;
    }

    public ApiFilterChain(ApiFilter...filters){
        this.filters = Arrays.asList(filters);

    }


    /**
     * 获取请求
     *
     * @return {@link ApiRequest}
     */
    public ApiRequest getRequest(){
        return this.request;
    }

    /**
     * 获取响应
     *
     * @return {@link ApiResponse}
     */
    public ApiResponse getResponse(){
        return this.response;
    }


    /**
     * 执行过滤
     *
     * @param request  请求
     * @param response 响应
     */
    public void doFilter(ApiRequest request,ApiResponse response){
        //如迭代器为空，则初始化
        if (this.iterator == null) {
            this.iterator = this.filters.iterator();
        }

        //集合中还有过滤器，则继续往下传递
        if (this.iterator.hasNext()) {
            ApiFilter nextFilter = this.iterator.next();
            nextFilter.doFilter(request, response, this);
        }

        //将处理结果更新到属性中
        this.request = request;
        this.response = response;
    }


    /**
     * 重置
     */
    public void reset() {
        this.request = null;
        this.response = null;
        this.iterator = null;
    }
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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

定义我们自己的过滤器接口

/**
 * API过滤器
 * @author wqliu
 * @date 2022-2-12 15:26
 **/
public interface ApiFilter {

    /**
     * 初始化
     */
    default void init()  {    }

    /**
     * 执行过滤
     *
     * @param request  请求
     * @param response 应答
     * @param chain    链条
     */
    void doFilter(ApiRequest request, ApiResponse response, ApiFilterChain chain) ;

    /**
     * 销毁
     */
    default void destroy() {
    }
}

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

​

定义两个简单的过滤器，用于调试整体框架

/**
 * @author wqliu
 * @date 2022-2-12 16:01
 **/
@Slf4j
@Component
public class ValidateDataFilter implements ApiFilter {
    @Override
    public void doFilter(ApiRequest request, ApiResponse response, ApiFilterChain chain) {
        log.info("进入数据验证过滤器");
        chain.doFilter(request,response);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

/**
 * @author wqliu
 * @date 2022-2-12 16:01
 **/
@Slf4j
@Component
public class LogFilter implements ApiFilter {
    @Override
    public void doFilter(ApiRequest request, ApiResponse response, ApiFilterChain chain) {
        log.info("进入日志过滤器");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

在服务中使用我们自己实现的过滤器链来实现

/**
 * '
 * API服务技术框架实现
 *
 * @author wqliu
 * @date 2022-2-10 14:44
 **/
@Service
public class ApiRestServiceFilterImpl implements ApiRestService {
    private ApiFilterChain filterChain;
    // @Autowired
    // private DefaultHttpChain httpChain;
    //
    // @Autowired
    // private ValidateRequestHandler basicValidateRequestHandler;
    //
    // @Autowired
    // private OperationSuccessResponseHandler operationSuccessResponseHandler;

    public ApiRestServiceFilterImpl(ValidateDataFilter validateDataFilter, LogFilter logFilter) {
        filterChain=new ApiFilterChain(validateDataFilter,logFilter);

    }

    @Override
    public ApiResponse handle(ApiRequest apiRequest) {
        ApiResponse apiResponse = new ApiResponse();
        try {
            filterChain.doFilter(apiRequest,apiResponse);
            apiResponse = this.filterChain.getResponse();
            apiResponse.setExecuteResult(ApiServiceExecuteResultEnum.SUCCESS.name());
        } catch (CustomException ex) {
            //自定义异常处理
            apiResponse.setExecuteResult(ApiServiceExecuteResultEnum.ERROR.name());
            apiResponse.setErrorCode("S00");
            apiResponse.setErrorMessage(ex.getMessage());
        } catch (ApiException ex) {
            //自定义异常处理
            apiResponse.setExecuteResult(ApiServiceExecuteResultEnum.ERROR.name());
            apiResponse.setErrorCode(ex.getErrorCode());
            apiResponse.setErrorMessage(ex.getMessage());
        } catch (Exception ex) {
            //非预期异常处理
            apiResponse.setExecuteResult(ApiServiceExecuteResultEnum.ERROR.name());
            apiResponse.setErrorCode("S99");
            apiResponse.setErrorMessage("未定义异常：" + ex.getMessage());
        } finally {
           //需要重置，为下次请求服务
            filterChain.reset();

        }

        return apiResponse;
    }
}

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