首页 > 其他分享 >【进阶玩法】策略+责任链+组合实现合同签章

【进阶玩法】策略+责任链+组合实现合同签章

时间：2023-07-17 09:11:10浏览次数：38  
标签：26892 进阶 玩法 节点 2023 签章 main public

前置内容

  1. 掌握策略模式
  2. 掌握责任链模式
  3. 掌握类继承、接口的实现
  4. 掌握参数的传递与设置
  5. GitHub地址

ps：【文章由来】公司项目中所用的合同签章处理流程，本人基于责任链上使用策略模式进行优化。

签章的处理流程

  1. 合同文本初始化
  2. 合同文本生成
  3. 签章挡板是否开启
  4. 合同签章发送mq
  5. 合同签章流水更新
  6. 合同上传文件服务器
  7. 签章渠道选择
  8. 签章渠道的实际调用

执行的流程如下：

整个结构类似于递归调用。每个节点中依赖上一个节点的输入以及下一个节点的输出，在中间过程可以实现每个节点的自定义操作，比较灵活。

流程实现

GitHub地址

项目结构

DesignPatterns
└── src
    └── main
        └── java
            └── com.xbhog.chainresponsibility
				├── annotations
                │    └── ContractSign
				├── channel
				│    ├── ContractSignChannelImpl.java
                │    └── ContractSignChannel
				├── Config
                │    └── SignConfig
				├── Enum
                │    └── ContractSignEnum
                ├── impl
                │    ├── ContractSignCompactInitImpl.java
                │    ├── ContractSignGenerateImpl.java
				│    ├── ContractSignMockImpl.java	
                │    ├── ContractSignMqImpl.java
                │    ├── ContractSignSaveUploadImpl.java
                │    ├── ContractSignSerialImpl.java
                │    └── ContractSignTradeImpl.java
                ├── inter
                │    ├── Call
                │    ├── Chain
                │    ├── Interceptor
                │    └── Processor
                ├── pojo
                │    ├── ContractRequest.java
                │    └── ContractResponse.java
				├── ContractCall
				├── ContractChain
                └── ContractSignProcessor.java

项目类图

责任链+组合模式代码实现

工程结构

DesignPatterns
└── src
    └── main
        └── java
            └── com.xbhog.chainresponsibility
				├── channel
				│    ├── ContractSignChannelImpl.java
                │    └── ContractSignChannel
                ├── impl
                │    ├── ContractSignCompactInitImpl.java
                │    ├── ContractSignGenerateImpl.java
				│    ├── ContractSignMockImpl.java	
                │    ├── ContractSignMqImpl.java
                │    ├── ContractSignSaveUploadImpl.java
                │    ├── ContractSignSerialImpl.java
                │    └── ContractSignTradeImpl.java
                ├── inter
                │    ├── Call
                │    ├── Chain
                │    ├── Interceptor
                │    └── Processor
                ├── pojo
                │    ├── ContractRequest.java
                │    └── ContractResponse.java
				├── ContractCall
				├── ContractChain
                └── ContractSignProcessor.java

责任链中的对象定义

//请求
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class ContractRequest {

    private String name;

    private String age;

    private String status;
}
//响应
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class ContractResponse {
    private String status;

    private String mas;
}

定义流程中的请求及响应类，方便处理每个责任链的请求、返回信息。

责任链处理流程

/**
 * @author xbhog
 * @describe: 责任链+组合实现合同签章
 * @date 2023/7/11
 */
@Slf4j
@Component
public class ContractSignProcessor <T extends ContractRequest> implements Processor<T, ContractResponse> {

    @Resource(name = "contractSignCompactInitImpl")
    private Interceptor<T,ContractResponse> contractCompactInitImpl;
	......


    public ContractSignProcessor() {
    }

    @Override
    public ContractResponse process(T paramter) {
        //获取所有的监听器
        List<Interceptor<T,ContractResponse>> interceptorList = new ArrayList<>();
        interceptorList.add(contractCompactInitImpl);
        ......
        //开始签章
        log.info("签章开始");
        return new ContractCall(paramter,interceptorList).exectue();
    }
}

合同签章方法的主流程调用接口(入口)，该类中注入所有的节点实现类(如contractCompactInitImpl)，通过编排实现责任链流程。
在初始化节点之前，进行节点的封装以及数据请求的处理。例：contractCompactInitImpl-合同数据初始化节点

/**
 * @author xbhog
 * @describe: 合同数据请求、节点的实例化及方法执行
 * @date 2023/7/11
 */
public class ContractCall<T extends ContractRequest> implements Call<T, ContractResponse> {
    private final T originalRequest;
    private final List<Interceptor<T,ContractRequest>> interceptorList;

    public ContractCall(T originalRequest, List<Interceptor<T, ContractRequest>> interceptorList) {
        this.originalRequest = originalRequest;
        this.interceptorList = interceptorList;
    }

    @Override
    public T request() {
        return this.originalRequest;
    }

    @Override
    public ContractResponse exectue() {
        //实例化流程节点
        ContractChain<T> chain = new ContractChain(0,this.originalRequest,this.interceptorList);
        return chain.proceed(this.originalRequest);
    }
}

获取节点中的请求参数，实例化当前责任链节点(contractCompactInitImpl)，在执行节点中的proceed方法来获取当前节点的参数以及获取节点的信息。

/**
 * @author xbhog
 * @describe: 合同节点
 * @date 2023/7/11
 */
@Slf4j
public class ContractChain<T extends ContractRequest> implements Chain<T, ContractResponse> {
    private final Integer index;

    private final T request;

    private final List<Interceptor<T,ContractResponse>> interceptors;

    public ContractChain(Integer index, T request, List<Interceptor<T, ContractResponse>> interceptors) {
        this.index = index;
        this.request = request;
        this.interceptors = interceptors;
    }

    @Override
    public T request() {
        return this.request;
    }

    @Override
    public ContractResponse proceed(T request) {
        //控制节点流程
        if(this.index >= this.interceptors.size()){
            throw  new IllegalArgumentException("index越界");
        }
        //下一个节点参数设置
        Chain<T,ContractResponse> nextChain = new ContractChain(this.index + 1, request, this.interceptors);
        //获取节点信息
        Interceptor<T, ContractResponse> interceptor = this.interceptors.get(this.index);
        Class<? extends Interceptor> aClass = interceptor.getClass();
        log.info("当前节点：{}",aClass.getSimpleName());
        ContractResponse response = interceptor.process(nextChain);
        if(Objects.isNull(response)){
            throw new NullPointerException("intercetor"+interceptor+"return null");
        }
        return response;
    }
}

到此合同签章的架构流程已经确定，后续只要填充Interceptor具体的实现类即可。
在代码中ContractResponse response = interceptor.process(nextChain);来执行合同初始化节点的具体操作。

/**
 * @author xbhog
 * @describe: 合同文本初始化
 * @date 2023/7/12
 */
@Slf4j
@Component
public class ContractSignCompactInitImpl<T extends ContractRequest> implements Interceptor<T, ContractResponse> {
    public ContractSignCompactInitImpl() {
    }

    @Override
    public ContractResponse process(Chain<T,ContractResponse> chain) {
        log.info("=============执行合同文本初始化拦截器开始");
        //获取处理的请求参数
        T request = chain.request();
        request.setStatus("1");
        log.info("=============执行合同文本初始化拦截器结束");
        //进入下一个责任链节点
        ContractResponse response =  chain.proceed(request);
        if(Objects.isNull(response)){
            log.error("返回值的为空");
            response = ContractResponse.builder().status("fail").mas("处理失败").build();
        }
        //其他处理
        return response;
    }
}

测试验证

@SpringBootTest
class SPringBootTestApplicationTests {
    @Autowired
    @Qualifier("contractSignProcessor")
    private Processor<ContractRequest,ContractResponse> contractSignProcessor;

    @Test
    void contextLoads() {
        ContractRequest contractRequest = new ContractRequest();
        contractRequest.setName("xbhog");
        contractRequest.setAge("12");
        ContractResponse process = contractSignProcessor.process(contractRequest);
        System.out.println(process);
    }

}

在这里只需要调用合同签章入口的方法即可进入合同签章的流程。

2023-07-16 13:25:13.063  INFO 26892 --- [           main] c.e.s.c.ContractSignProcessor            : 签章开始
2023-07-16 13:25:13.067  INFO 26892 --- [           main] c.e.s.chainresponsibility.ContractChain  : 当前节点：ContractSignCompactInitImpl
2023-07-16 13:25:13.068  INFO 26892 --- [           main] c.e.s.c.i.ContractSignCompactInitImpl    : =============执行合同文本初始化拦截器开始
2023-07-16 13:25:13.069  INFO 26892 --- [           main] c.e.s.c.i.ContractSignCompactInitImpl    : =============执行合同文本初始化拦截器结束
2023-07-16 13:25:13.069  INFO 26892 --- [           main] c.e.s.chainresponsibility.ContractChain  : 当前节点：ContractSignGenerateImpl
2023-07-16 13:25:13.069  INFO 26892 --- [           main] c.e.s.c.impl.ContractSignGenerateImpl    : =============执行合同文本生成拦截器开始
2023-07-16 13:25:13.069  INFO 26892 --- [           main] c.e.s.c.impl.ContractSignGenerateImpl    : =============执行合同文本生成拦截器结束
2023-07-16 13:25:13.069  INFO 26892 --- [           main] c.e.s.chainresponsibility.ContractChain  : 当前节点：ContractSignMockImpl
2023-07-16 13:25:13.069  INFO 26892 --- [           main] c.e.s.c.impl.ContractSignMockImpl        : =============执行签章挡板拦截器开始
2023-07-16 13:25:13.069  INFO 26892 --- [           main] c.e.s.c.impl.ContractSignMockImpl        : =============执行签章挡板拦截器结束
2023-07-16 13:25:13.069  INFO 26892 --- [           main] c.e.s.chainresponsibility.ContractChain  : 当前节点：ContractSignMqImpl
2023-07-16 13:25:13.069  INFO 26892 --- [           main] c.e.s.c.impl.ContractSignMqImpl          : =============执行合同签章完成发送mq拦截器开始
2023-07-16 13:25:13.069  INFO 26892 --- [           main] c.e.s.chainresponsibility.ContractChain  : 当前节点：ContractSignSerialImpl
2023-07-16 13:25:13.069  INFO 26892 --- [           main] c.e.s.c.impl.ContractSignSerialImpl      : =============执行合同签章流水处理拦截器开始
2023-07-16 13:25:13.069  INFO 26892 --- [           main] c.e.s.chainresponsibility.ContractChain  : 当前节点：ContractSignSaveUploadImpl
2023-07-16 13:25:13.069  INFO 26892 --- [           main] c.e.s.c.impl.ContractSignSaveUploadImpl  : =============执行合同签章完成上传服务器拦截器开始
2023-07-16 13:25:13.069  INFO 26892 --- [           main] c.e.s.chainresponsibility.ContractChain  : 当前节点：ContractSignTradeImpl
2023-07-16 13:25:13.069  INFO 26892 --- [           main] c.e.s.c.impl.ContractSignTradeImpl       : =============执行签章渠道实际调用拦截器开始
2023-07-16 13:25:13.069  INFO 26892 --- [           main] c.e.s.c.channel.ContractSignChannelImpl  : 签章处理开始
2023-07-16 13:25:13.070  INFO 26892 --- [           main] c.e.s.c.impl.ContractSignSaveUploadImpl  : 开始上传服务器
2023-07-16 13:25:13.070  INFO 26892 --- [           main] c.e.s.c.impl.ContractSignSaveUploadImpl  : .............
2023-07-16 13:25:13.070  INFO 26892 --- [           main] c.e.s.c.impl.ContractSignSaveUploadImpl  : 上传服务器完成
2023-07-16 13:25:13.070  INFO 26892 --- [           main] c.e.s.c.impl.ContractSignSaveUploadImpl  : =============执行合同签章完成上传服务器拦截器结束
2023-07-16 13:25:13.070  INFO 26892 --- [           main] c.e.s.c.impl.ContractSignSerialImpl      : =============执行合同签章流水处理拦截器结束
2023-07-16 13:25:13.070  INFO 26892 --- [           main] c.e.s.c.impl.ContractSignMqImpl          : 发送MQ给下游处理数据
2023-07-16 13:25:13.070  INFO 26892 --- [           main] c.e.s.c.impl.ContractSignMqImpl          : =============执行合同签章完成发送mq拦截器结束
ContractResponse(status=success, mas=处理成功)

策略+责任链+组合代码实现

以下是完整的合同签章入口实现类：

/**
 * @author xbhog
 * @describe: 责任链+组合实现合同签章
 * @date 2023/7/11
 */
@Slf4j
@Component
public class ContractSignProcessor <T extends ContractRequest> implements Processor<T, ContractResponse> {

    @Resource(name = "contractSignCompactInitImpl")
    private Interceptor<T,ContractResponse> contractCompactInitImpl;

    @Resource(name = "contractSignGenerateImpl")
    private Interceptor<T,ContractResponse> contractGenerateImpl;

    @Resource(name = "contractSignMockImpl")
    private Interceptor<T,ContractResponse> contractSignMockImpl;

    @Resource(name = "contractSignMqImpl")
    private Interceptor<T,ContractResponse> contractSignMqImpl;

    @Resource(name = "contractSignSaveUploadImpl")
    private Interceptor<T,ContractResponse> contractSignSaveUploadImpl;

    @Resource(name = "contractSignSerialImpl")
    private Interceptor<T,ContractResponse> contractSignSerialImpl;

    @Resource(name = "contractSignTradeImpl")
    private Interceptor<T,ContractResponse> ContractSignTradeImpl;


    public ContractSignProcessor() {
    }

    @Override
    public ContractResponse process(T paramter) {
        //获取所有的监听器
        List<Interceptor<T,ContractResponse>> interceptorList = new ArrayList<>();
        interceptorList.add(contractCompactInitImpl);
        interceptorList.add(contractGenerateImpl);
        interceptorList.add(contractSignMockImpl);
        interceptorList.add(contractSignMqImpl);
        interceptorList.add(contractSignSerialImpl);
        interceptorList.add(contractSignSaveUploadImpl);
        interceptorList.add(ContractSignTradeImpl);
        //开始签章
        log.info("签章开始");
        return new ContractCall(paramter,interceptorList).exectue();
    }
}

可以看到，目前的合同签章的处理流程需要的节点数已经7个了，后续如果新增节点或者减少节点都需要对该类进行手动的处理；比如：减少一个节点的流程。

  1. 删除节点实现的注入
  2. 删除list中的bean实现类

为方便后续的拓展(懒是社会进步的加速器，不是)，在责任链，组合的基础上通过策略模式来修改bean的注入方式。
完整的项目结构和项目类图就是作者文章开始放的，可返回查看。
在第一部分的基础上增加的功能点如下

  1. 新增签章注解
  2. 新增签章节点枚举
  3. 新增签章配置类

签章注解实现

package com.example.springboottest.chainresponsibility.annotations;

import com.example.springboottest.chainresponsibility.Enum.ContractSignEnum;

import java.lang.annotation.*;

/**
 * @author xbhog
 * @describe:
 * @date 2023/7/15
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface ContractSign {
    ContractSignEnum.SignChannel SIGN_CHANNEL();

}

设置注解修饰对象的范围，主要是对bean的一个注入，所以类型选择type,

  • TYPE: 用于描述类、接口(包括注解类型) 或enum声明

设置注解的运行周期(有效范围)，一般是运行时有效，

  • RUNTIME：在运行时有效(大部分注解的选择)

设置该注解的数据类型，

  • ENUM：枚举类型，方便统一处理

枚举实现

package com.xbhog.chainresponsibility.Enum;

/**
 * @author xbhog
 * @describe:
 * @date 2023/7/15
 */
public class ContractSignEnum {
    public enum SignChannel {

        SIGN_INIT(1, "合同文本初始化"),
        SIGN_GENERATE(2, "合同文本生成"),
        SIGN_MOCK(3, "签章挡板"),
        SIGN_MQ(4, "合同签章完成发送MQ"),
        SIGN_TABLE(5, "合同签章表处理"),
        SIGN_UPLOAD(6, "合同签章完成上传服务器"),
        SIGN_TRADE(7, "签章渠道实际调用");

        private Integer code;
        private String info;

        SignChannel(Integer code, String info) {
            this.code = code;
            this.info = info;
        }
        ......
    }
}

对合同签章中的流程节点进行统一的配置。

签章配置类

在项目启动的时候，通过注解工具类AnnotationUtils扫描所有被ContractSign注解修饰的类，将这些类通过Map进行存储，方便后续的调用。

public class SignConfig {
    @Resource
    protected List<Interceptor> contractSignList;

    protected static final Map<Integer,Interceptor> CONTRACT_SIGN_MAP = new ConcurrentHashMap<>();

    @PostConstruct
    public void init(){
       contractSignList.forEach(interceptor -> {
           //查找这个接口的实现类上有没有ContractSign注解
           ContractSign sign = AnnotationUtils.findAnnotation(interceptor.getClass(), ContractSign.class);
           if(!Objects.isNull(sign)){
               CONTRACT_SIGN_MAP.put(sign.SIGN_CHANNEL().getCode(),interceptor);
           }
       });
    }

}

到此，简化了Bean的注入方式。

签章注解使用

以合同文本初始化ContractSignCompactInitImpl来说。

/**
 * @author xbhog
 * @describe: 合同文本初始化
 * @date 2023/7/12
 */
@Slf4j
@ContractSign(SIGN_CHANNEL = ContractSignEnum.SignChannel.SIGN_INIT)
@Component
public class ContractSignCompactInitImpl<T extends ContractRequest> implements Interceptor<T, ContractResponse> {
    public ContractSignCompactInitImpl() {
    }

    @Override
    public ContractResponse process(Chain<T,ContractResponse> chain) {
        log.info("=============执行合同文本初始化拦截器开始");
        //获取处理的请求参数
        T request = chain.request();
        request.setStatus("1");
        log.info("=============执行合同文本初始化拦截器结束");
        //进入下一个责任链节点
        ContractResponse response =  chain.proceed(request);
        if(Objects.isNull(response)){
            log.error("返回值的为空");
            response = ContractResponse.builder().status("fail").mas("处理失败").build();
        }
        //其他处理
        return response;
    }
}

在该实现类上绑定了枚举@ContractSign(SIGN_CHANNEL = ContractSignEnum.SignChannel.SIGN_INIT).
在合同签章入口类(**ContractSignProcessor**)中的变更如下：

@Slf4j
@Component
public class ContractSignProcessor <T extends ContractRequest> extends SignConfig implements Processor<T, ContractResponse> {

    public ContractSignProcessor() {
    }

    @Override
    public ContractResponse process(T paramter) {
        //获取所有的监听器
        List<Interceptor<T,ContractResponse>> interceptorList = new ArrayList<>();
        //获取排序后的结果，保证责任链的顺序，hashmap中key如果是数字的话，通过hashcode编码后是有序的
        for(Integer key : CONTRACT_SIGN_MAP.keySet()){
            interceptorList.add(CONTRACT_SIGN_MAP.get(key));
        }
        //开始签章
        log.info("签章开始");
        return new ContractCall(paramter,interceptorList).exectue();
    }
}

通过继承合同签章配置类(SignConfig)，来获取Map,遍历Map添加到list后进入责任链流程。
到此，整个策略+责任链+组合的优化方式结束了。

问题：
责任链中的顺序是怎么保证的？
相信认真看完的你能在文章或者代码中找到答案。

标签：26892,进阶,玩法,节点,2023,签章,main,public
From： https://www.cnblogs.com/xbhog/p/17559095.html

相关文章

  • Mysql进阶篇（二）之索引
    一.索引概述1.介绍索引是帮助MySQL高效获取数据的数据结构（有序）。在数据之外，数据库系统还维护着满足特定查找算法的数据结构，这些数据结构以某种方式引用（指向）数据，这样就可以在这些数据结构上实现高级查找算法，这种数据结构就是索引。2.演示表结构及其数据如下：假如我们要执......
  • Mysql进阶篇（二）之索引
    一.索引概述1.介绍索引是帮助MySQL高效获取数据的数据结构（有序）。在数据之外，数据库系统还维护着满足特定查找算法的数据结构，这些数据结构以某种方式引用（指向）数据，这样就可以在这些数据结构上实现高级查找算法，这种数据结构就是索引。2.演示表结构及其数据如下：假如我们要执行的SQL语......
  • UVM入门进阶4
    UVM结构回顾UVM结构UVM_TOPUVM中真正的树根是uvm_top。uvm_top是一个全局变量，是uvm_root的唯一一个实例(设计模式中的singleton，单态模式)，uvm_root派生于uvm_component，因此uvm_top本质是一个uvm_component。uvm_test_top的parent是uvm_top，而uvm_top的parent是null。uvm_root在......
  • UVM入门进阶2
    UVM入门和进阶2核心基类（uvm_object）在UVM世界的类库地图中除过事务接口类继承于uvm_port_base，其他所有的类都是从uvm_object类一步步继承来的域的自动化：UVM通过域的自动化，使得用户在注册UVM类的同时也可以声明今后会参与到对象复制、克隆、打印等操作的成员变量，可以以简化对象的......
  • UVM入门进阶3
    UVM组件UVM组件家族是从uvm_component类继承的来的类UVM_DRIVER1.uvm_driver类会从uvm_sequencer中获取事务，经过转化然后再接口中对DUT进行时序激励2.uvm_driver类是参数化类，在定义时需要声明参数的类型classuvm_driver#(typeREQ=uvm_sequence_item,typeRSP=REQ)extends......
  • UVM入门进阶1、2
    UVM入门进阶1创建对象的四种方法classtransextendsuvm_object...endclassclasstopextendsuvm_test//uvm_test继承于uvm_component...endclassclassobject_createextendstop;transt1,t2,t3,t4;`uvm_component_utils(object_create)func......
  • 全新版Jetpack进阶提升，系统性落地短视频App
    第1章课程介绍及学习指南2节｜27分钟第2章Navigation路由与框架搭建13节｜136分钟第3章Gradle插件开发与Navigation路由升级改造8节｜108分钟第4章Paging3fees流列表实战14节｜176分钟第5章Kotlin协程与新一代数据流处理框架Flow4节｜72分钟第6章列表视频自动播放方案设计与实......
  • ACM算法竞赛入门和进阶指南
    文章目录如下，将从以下八个方面展开，接下来进入正文。一、ACM竞赛ACM程序设计竞赛是三人组队赛，一场比赛5个小时，通常有10~13个问题，三人合力解决，比赛时三人只能使用一台电脑。每年有多个赛站，但每人一年只能参加两场区域赛(不算邀请赛、省赛)。二、入门方式可以参考下方回答。AC......
  • mysql进阶
    mysql高级1.存储引擎1.mysql体系结构 2.存储引擎简介a.存储引擎就是存储数据，建立索引，更新查询数据等技术的实现方式。存储引擎是基于表的，而不是基于库的，所以存储引擎也可以被称为表类型3.存储引擎的特点a.InnoDB:是一种兼顾高可靠性能的通用......
  • 【Netty】「优化进阶」（一）粘包半包问题及解决方案
    前言本篇博文是《从0到1学习Netty》中进阶系列的第一篇博文，主要内容是介绍粘包半包出现的现象和原因，并结合应用案例来深入讲解多种解决方案，往期系列文章请访问博主的Netty专栏，博文中的所有代码全部收集在博主的GitHub仓库中；粘包现象粘包是指多个独立的数据包被粘合在一起发送，......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99