java中避免集合死链调用
目录
1. 前言
开发过程中，一些集合 的变动会触发任务去改变 其他的集合，为了保障任务的正确执行，应避免出现死循环调用，即对集合之间的影响关系进行一些限制。怕日后遗忘，特在此记录。
2. 场景
A 集合影响 A 集合。
A 集合影响 B 集合，B 集合影响了 A 集合。
A 集合影响 B 集合，B 集合影响了 C 集合，C 集合影响了 A 集合。
A 集合影响 B 集合、C 集合，B 集合影响了 D 集合，C 集合影响了 E 集合，E 集合影响 A 集合。
3. 环境
3.1 开发环境准备
- JDK 1.8
- SpringBoot 2.x
- Mysql 8
- redis
3.2 数据准备
3.2.1 Mysql数据库表及数据
dp_process表
CREATE TABLE `dp_process` (
`ID` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL COMMENT 'ID',
`NAME` varchar(128) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '名称',
`CODE` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '代码',
`CATEGORY` varchar(512) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '类型 1=楼宇，2=房地产',
`IN_COLS` varchar(1024) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '输入集合',
`OUT_COLS` varchar(128) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '影响集合',
`REMARK` varchar(1024) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '备注',
`ENABLED` varchar(1) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '是否开启',
`STATUS` int DEFAULT NULL COMMENT '状态 数据状态：0=正常，1=删除，失效',
`CREATED_BY` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '创建人',
`CREATED_TIME` datetime DEFAULT NULL COMMENT '创建时间',
`UPDATED_BY` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '更新人',
`UPDATED_TIME` datetime DEFAULT NULL COMMENT '更新时间',
`REVISION` int DEFAULT '0' COMMENT '乐观锁',
PRIMARY KEY (`ID`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='数据处理 ';
dp_process 表中的数据
INSERT INTO `gccs`.`dp_process`(`ID`, `NAME`, `CODE`, `CATEGORY`, `IN_COLS`, `OUT_COLS`, `REMARK`, `ENABLED`, `STATUS`, `CREATED_BY`, `CREATED_TIME`, `UPDATED_BY`, `UPDATED_TIME`, `REVISION`) VALUES ('1', 'B', 'B', 'ly', 'A', 'B', 'B', '1', 0, NULL, NULL, NULL, NULL, 0);
INSERT INTO `gccs`.`dp_process`(`ID`, `NAME`, `CODE`, `CATEGORY`, `IN_COLS`, `OUT_COLS`, `REMARK`, `ENABLED`, `STATUS`, `CREATED_BY`, `CREATED_TIME`, `UPDATED_BY`, `UPDATED_TIME`, `REVISION`) VALUES ('2', 'D', 'D', 'ly', 'B', 'D', 'D', '1', 0, NULL, NULL, NULL, NULL, 0);
INSERT INTO `gccs`.`dp_process`(`ID`, `NAME`, `CODE`, `CATEGORY`, `IN_COLS`, `OUT_COLS`, `REMARK`, `ENABLED`, `STATUS`, `CREATED_BY`, `CREATED_TIME`, `UPDATED_BY`, `UPDATED_TIME`, `REVISION`) VALUES ('3', 'E', 'E', 'ly', 'B', 'E', 'E', '1', 0, NULL, NULL, NULL, NULL, 0);
INSERT INTO `gccs`.`dp_process`(`ID`, `NAME`, `CODE`, `CATEGORY`, `IN_COLS`, `OUT_COLS`, `REMARK`, `ENABLED`, `STATUS`, `CREATED_BY`, `CREATED_TIME`, `UPDATED_BY`, `UPDATED_TIME`, `REVISION`) VALUES ('4', 'G', 'G', 'ly', 'D', 'G', 'G', '1', 0, NULL, NULL, NULL, NULL, 0);
INSERT INTO `gccs`.`dp_process`(`ID`, `NAME`, `CODE`, `CATEGORY`, `IN_COLS`, `OUT_COLS`, `REMARK`, `ENABLED`, `STATUS`, `CREATED_BY`, `CREATED_TIME`, `UPDATED_BY`, `UPDATED_TIME`, `REVISION`) VALUES ('5', 'F', 'F', 'ly', 'D', 'F', 'F', '1', 0, NULL, NULL, NULL, NULL, 0);
3.2.2 redis库数据
| key | Value |
|---|---|
| A | [{ "id": "1","outCols": "B"}] |
| B | [{"id": "2","outCols": "D"},{"id": "3","outCols": "E"}] |
| D | [{"id": "4","outCols": "G"},{"id": "5","outCols": "F"}] |
4. 解决方式
通过递归的方式循环查询、对比。
本例主要牵扯到的知识点有：
- Stack (栈，先进后出)
- 递归
- redis简单增删操作
本文以修改方法代码为例，介绍如何实现防死链调用，非常简单。
/**
* @create 2021-07-08 更新 数据处理
* @param dpProcess 数据处理 模型
* @param updateNil 全字段更新(新增时此字段可以忽略): 是:Y 否:N {@link SystemConst.Whether}
* @return
*/
@Override
public int modify(DpProcess dpProcess, String updateNil){
// **省略一堆代码**
// 输入集合统一处理
operInclos(dpProcess, orignDpProcess.getInCols());
// **省略一堆代码**
}
operInclos() 方法 ：本文重点，主要做了数据校验、redis中数据更新等一系列操作
/**
* @create 输入集合统一处理 2021/7/11 14:13
* @param dpProcess 新数据处理对象
* @param oldClos 原数据处理对象中的输入集合
* @return
*/
private void operInclos(DpProcess dpProcess, String oldClos) {
// 新数据处理对象中的输入集合
String inCols = dpProcess.getInCols();
// 若新数据处理对象中的输入集合没有值，则直接跳过，不进行操作
if(StringUtils.isNotBlank(inCols)){
if(dpProcess.getInCols().contains(dpProcess.getOutCols())){
throw new ServiceException("数据处理流程配置输入流程调用了输出集合！");
}
// 数据类型转换
Set<String> set = new HashSet(Arrays.asList(inCols.split(",")));
// 循环遍历输入集合
for (String inClo : set) {
// 最终需要遍历的list
List<DpProcessVo> childFinalList = new ArrayList<>();
// 从redis中获取当前集合的影响关系
String dpProcessJson = (String) redisUtil.get(inClo);
// 如果redis中存储的集合影响关系不为空，做简单的遍历去重处理
if(StringUtils.isNotBlank(dpProcessJson)){
// redis中存储的集合影响关系列表
List<DpProcessVo> children = new ArrayList<>();
// 进行数据类型转换
children = JSONArray.parseArray(dpProcessJson, DpProcessVo.class);
for (DpProcessVo dpProcessVo1 : children) {
if(dpProcess.getId().equals(dpProcessVo1.getId())){
continue;
}
childFinalList.add(dpProcessVo1);
}
// 添加本次影响的集合
DpProcessVo dpProcess1 = new DpProcessVo();
dpProcess1.setId(dpProcess.getId());
dpProcess1.setOutCols(dpProcess.getOutCols());
childFinalList.add(dpProcess1);
}
// 如果redis中没有此输入集合的影响关系，则可以直接进行添加
else{
DpProcessVo dpProcess1 = new DpProcessVo();
dpProcess1.setId(dpProcess.getId());
dpProcess1.setOutCols(dpProcess.getOutCols());
childFinalList.add(dpProcess1);
}
// 验证数据处理流程配置输入流程是否调用了输出集合
Stack<DpProcessVo> nodeStack = new Stack<>();
// 设置模型
DpProcessVo dpProcessVoTop = new DpProcessVo();
dpProcessVoTop.setOutCols(inClo);
dpProcessVoTop.setId(dpProcess.getId());
nodeStack.add(dpProcessVoTop);
// 遍历需要进行死链校验的数据
for (DpProcessVo dpProcessVo : childFinalList) {
// 是否添加标识（默认为添加，如果集合为死链，则进行提示）
boolean addFlag = true;
// 循环遍历栈
for (DpProcessVo processVo : nodeStack) {
if(processVo.getOutCols().equals(dpProcessVo.getOutCols())){
addFlag = false;
break;
}
}
if(!addFlag){
throw new ServiceException("数据处理流程配置输入流程调用了输出集合！");
}
// 将dpProcessVo推到这个堆栈的顶部
nodeStack.push(dpProcessVo);
// 验证数据处理流程配置输入流程是否调用了输出集合
invaldClosInfo(nodeStack);
// 移除此堆栈顶部的对象并将该对象作为此函数的值返回
nodeStack.pop();
}
}
// 处理需要删除的集合
dealNeedDeleteCols(dpProcess, oldClos, set);
// 获取并设置最终的集合名称
String finallyCols = StringUtils.join(set.toArray(), ",");
dpProcess.setInCols(finallyCols);
// 省略一堆更新redis的操作
}
}
invaldClosInfo()方法： 递归深度遍历
/**
* @create 验证数据处理流程配置输入流程是否调用了输出集合 2021/7/20 22:10
* @param nodeStack 深度遍历栈
* @return void
*/
public void invaldClosInfo(Stack<DpProcessVo> nodeStack) {
// 查看此堆栈顶部的对象而不将其从堆栈中移除
DpProcessVo dpProcessVo = nodeStack.peek();
// 从redis中查找此集合影响的流程关系
String dpProcessJson = (String) redisUtil.get(dpProcessVo.getOutCols());
// 如果集合没有影响其他集合，则直接返回
if(StringUtils.isBlank(dpProcessJson)){
return;
}
//获得节点的子节点，对于二叉树就是获得节点的左子结点和右子节点
List<DpProcessVo> children = new ArrayList<>();
// redis中原来存储的信息
children = JSONArray.parseArray(dpProcessJson, DpProcessVo.class);
// 遍历集合影响的集合关系
for (DpProcessVo dpProcessVo1 : children) {
boolean addFlag = true;
for (DpProcessVo processVo : nodeStack) {
if(processVo.getOutCols().equals(dpProcessVo1.getOutCols())){
addFlag = false;
break;
}
}
if(!addFlag){
throw new ServiceException("数据处理流程配置输入流程调用了输出集合！");
}
// 将dpProcessVo推到这个堆栈的顶部
nodeStack.push(dpProcessVo1);
// 验证数据处理流程配置输入流程是否调用了输出集合
invaldClosInfo(nodeStack);
// 移除此堆栈顶部的对象并将该对象作为此函数的值返回
nodeStack.pop();
}
}
5.完整代码
记录代码，方便日后复习、调用、重构。
5.1Model
模型主要分两部分：数据处理模型和简化版的数据处理模型。
DpProcess：数据处理模型，数据完整的Sql操作
import com.alibaba.fastjson.annotation.JSONField;
import com.baomidou.mybatisplus.annotation.*;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import java.io.Serializable;
import java.util.Date;
/**
* <p>
* 数据处理
* </p>
*
* @since 2021-07-08
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@ApiModel(value="DpProcess对象", description="数据处理 ")
@TableName("dp_process")
public class DpProcess implements Serializable {
@TableField(exist = false)
public static final String ENABLED = "ENABLED";
@TableField(exist = false)
public static final String STATUS = "STATUS";
@TableField(exist = false)
public static final String CATEGORY = "CATEGORY";
private static final long serialVersionUID = 1L;
@ApiModelProperty(value = "ID")
@TableId(value = "ID", type = IdType.ASSIGN_ID)
private String id;
@ApiModelProperty(value = "名称")
@TableField("NAME")
private String name;
@ApiModelProperty(value = "代码")
@TableField("CODE")
private String code;
@ApiModelProperty(value = "类型 1=楼宇，2=房地产")
@TableField("CATEGORY")
private String category;
@ApiModelProperty(value = "输入集合")
@TableField("IN_COLS")
private String inCols;
@ApiModelProperty(value = "影响集合")
@TableField("OUT_COLS")
private String outCols;
@ApiModelProperty(value = "备注")
@TableField("REMARK")
private String remark;
@ApiModelProperty(value = "是否开启 0:否 1：是")
@TableField("ENABLED")
private String enabled;
@ApiModelProperty(value = "状态 数据状态：0=正常，1=删除，失效")
@TableField(value = "STATUS", fill = FieldFill.INSERT)
private Integer status;
@ApiModelProperty(value = "创建人")
@TableField(value = "CREATED_BY", fill = FieldFill.INSERT)
private String createdBy;
@ApiModelProperty(value = "创建时间")
@JSONField(format = "yyyy-MM-dd HH:mm:ss")
@TableField(value = "CREATED_TIME", fill = FieldFill.INSERT)
private Date createdTime;
@ApiModelProperty(value = "更新人")
@TableField(value = "UPDATED_BY", fill = FieldFill.UPDATE)
private String updatedBy;
@ApiModelProperty(value = "更新时间")
@JSONField(format = "yyyy-MM-dd HH:mm:ss")
@TableField(value = "UPDATED_TIME", fill = FieldFill.UPDATE)
private Date updatedTime;
@ApiModelProperty(value = "乐观锁")
@Version
@TableField(value = "REVISION", fill = FieldFill.INSERT)
private Integer revision;
}
DpProcessVo: 数据处理简单模型，处理redis数据结构数据。
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@ApiModel(value="DpProcessVo对象", description="数据处理简单模型 ")
public class DpProcessVo{
@ApiModelProperty(value = "ID")
private String id;
@ApiModelProperty(value = "影响集合")
private String outCols;
}
5.2 Controller
updateNil：让用户选择使用那种更新方式，也可以把接口一拆为二，主要看个人习惯。
/**
* @create 2021-07-08 更新 数据处理
* @param dpProcess 数据处理 模型
* @param updateNil 全字段更新(新增时此字段可以忽略): 是:Y 否:N {@link SystemConst.Whether}
* @return
*/
@ApiOperation(value="更新",notes = "更新")
@PostMapping("/modify")
public Result modify(
@ApiParam(name = "dpProcess", value = "数据处理 模型", required = true) @RequestBody DpProcess dpProcess,
@ApiParam(name = "updateNil", value = "全字段更新(新增时此字段可以忽略): 是:Y 否:不传或者随意传") @RequestParam(required = false) String updateNil) {
int addResult = dpProcessService.modify(dpProcess, updateNil);
if (addResult > 0) {
return new Result(CommonCode.SUCCESS, "更新成功！");
}
return new Result(CommonCode.FAIL, "更新失败！");
}
5.3 Service
没啥好说的，就是一个接口。
/**
* @create 2021-07-08 更新 数据处理
* @param dpProcess 数据处理 模型
* @param updateNil 全字段更新(新增时此字段可以忽略): 是:Y 否:N {@link SystemConst.Whether}
* @return
*/
int modify(DpProcess dpProcess, String updateNil);
5.4 Service 实现类
DpRecord：数据处理记录，不是本文重点，此处可直接忽略，相关说明 待 数据流程处理文章中提现。
/**
* @create 2021-07-08 更新 数据处理
* @param dpProcess 数据处理 模型
* @param updateNil 全字段更新(新增时此字段可以忽略): 是:Y 否:N {@link SystemConst.Whether}
* @return
*/
@Override
public int modify(DpProcess dpProcess, String updateNil){
if(dpProcess == null){
throw new ServiceException("数据处理模型不能为空！");
}
// 走更新方法
// 通过id查询数据处理 详情
DpProcess orignDpProcess = this.detail(dpProcess.getId());
if(dpProcess == null){
throw new ServiceException("数据处理模型信息不能为空！");
}
// 如果当前任务已存在，需要先进行取消
if("0".equals(dpProcess.getEnabled())){
if(defaultSchedulingConfigurer.hasTask(dpProcess.getId())){
defaultSchedulingConfigurer.cancelTriggerTask(dpProcess.getId());
}
// 根据数据处理ID查看数据库中是否有需要执行的数据处理记录
DpRecord dpRecord = dpRecordService.getNeedExecRecordByDppId(dpProcess.getId());
// 如果数据处理记录信息为空,则进行新增
if(dpRecord != null){
// 设置结束时间为当前时间
dpRecord.setEndTime(new Date());
// 运行失败
dpRecord.setSucceed("2");
dpRecord.setFailedResult("用户取消操作");
}
// 对数据处理记录进行更新或者保存
dpRecordService.addOrUpdate(dpRecord, null);
}
// 限制输出集合不能为空
dpProcess.setOutCols(StringUtils.isNotBlank(dpProcess.getOutCols()) ? dpProcess.getOutCols() : orignDpProcess.getOutCols());
if(StringUtils.isBlank(dpProcess.getOutCols())){
throw new ServiceException("数据影响集合不能为空！");
}
// 输入集合统一处理
operInclos(dpProcess, orignDpProcess.getInCols());
// 全字段更新
if(SystemConst.Whether.Yes.getCode().equals(updateNil)){
if(StringUtils.isBlank(dpProcess.getRemark())){
throw new ServiceException("数据处理备注不能为空！");
}
// 备注不能小于20字
if(dpProcess.getRemark().length() < 20){
throw new ServiceException("数据处理备注不能小于20字！");
}
return dpProcessMapper.alwaysUpdateSomeColumnById(dpProcess);
}
// 数据处理代码自动填充
dpProcess.setCode(StringUtils.isBlank(dpProcess.getCode()) ? orignDpProcess.getCode() : dpProcess.getCode());
return dpProcessMapper.updateById(dpProcess);
}
operInclos() ： 处理输入集合的方法
/**
* @create 输入集合统一处理 2021/7/11 14:13
* @param dpProcess 新数据处理对象
* @param oldClos 原数据处理对象中的而输入集合
* @return
*/
private void operInclos(DpProcess dpProcess, String oldClos) {
// 新数据处理对象中的输入集合
String inCols = dpProcess.getInCols();
// 若新数据处理对象中的输入集合没有值，则直接跳过，不进行操作
if(StringUtils.isNotBlank(inCols)){
if(dpProcess.getInCols().contains(dpProcess.getOutCols())){
throw new ServiceException("数据处理流程配置输入流程调用了输出集合！");
}
// 数据类型转换
Set<String> set = new HashSet(Arrays.asList(inCols.split(",")));
// 循环遍历输入集合
for (String inClo : set) {
// 最终需要遍历的list
List<DpProcessVo> childFinalList = new ArrayList<>();
// 从redis中获取当前集合的影响关系
String dpProcessJson = (String) redisUtil.get(inClo);
// 如果redis中存储的集合影响关系不为空，做简单的遍历去重处理
if(StringUtils.isNotBlank(dpProcessJson)){
// redis中存储的集合影响关系列表
List<DpProcessVo> children = new ArrayList<>();
// 进行数据类型转换
children = JSONArray.parseArray(dpProcessJson, DpProcessVo.class);
for (DpProcessVo dpProcessVo1 : children) {
if(dpProcess.getId().equals(dpProcessVo1.getId())){
continue;
}
childFinalList.add(dpProcessVo1);
}
// 添加本次影响的集合
DpProcessVo dpProcess1 = new DpProcessVo();
dpProcess1.setId(dpProcess.getId());
dpProcess1.setOutCols(dpProcess.getOutCols());
childFinalList.add(dpProcess1);
}
// 如果redis中没有此输入集合的影响关系，则可以直接进行添加
else{
DpProcessVo dpProcess1 = new DpProcessVo();
dpProcess1.setId(dpProcess.getId());
dpProcess1.setOutCols(dpProcess.getOutCols());
childFinalList.add(dpProcess1);
}
// 验证数据处理流程配置输入流程是否调用了输出集合
Stack<DpProcessVo> nodeStack = new Stack<>();
// 设置模型
DpProcessVo dpProcessVoTop = new DpProcessVo();
dpProcessVoTop.setOutCols(inClo);
dpProcessVoTop.setId(dpProcess.getId());
nodeStack.add(dpProcessVoTop);
// 遍历需要进行死链校验的数据
for (DpProcessVo dpProcessVo : childFinalList) {
// 是否添加标识（默认为添加，如果集合为死链，则进行提示）
boolean addFlag = true;
// 循环遍历栈
for (DpProcessVo processVo : nodeStack) {
if(processVo.getOutCols().equals(dpProcessVo.getOutCols())){
addFlag = false;
break;
}
}
if(!addFlag){
throw new ServiceException("数据处理流程配置输入流程调用了输出集合！");
}
// 将dpProcessVo推到这个堆栈的顶部
nodeStack.push(dpProcessVo);
// 验证数据处理流程配置输入流程是否调用了输出集合
invaldClosInfo(nodeStack);
// 移除此堆栈顶部的对象并将该对象作为此函数的值返回
nodeStack.pop();
}
}
// 处理需要删除的集合
dealNeedDeleteCols(dpProcess, oldClos, set);
// 获取并设置最终的集合名称
String finallyCols = StringUtils.join(set.toArray(), ",");
dpProcess.setInCols(finallyCols);
// 能走到这一步，说明所有的集合没有问题，可以进行更新操作了（再一次遍历是为了和上面的校验分开，避免部分数据被更新）
for (String inClo : set) {
List<DpProcessVo> dpProcessVoList = new ArrayList<>();
// 首先获取当前集合影响的数据处理对象
String dpProcessJson = (String) redisUtil.get(inClo);
if(StringUtils.isBlank(dpProcessJson)){
DpProcessVo dpProcessVo = new DpProcessVo();
dpProcessVo.setId(dpProcess.getId());
dpProcessVo.setOutCols(dpProcess.getOutCols());
dpProcessVoList.add(dpProcessVo);
// 进行数据的存储
redisUtil.set(inClo, JSONArray.toJSON(dpProcessVoList).toString());
continue;
}
// redis中原来存储的信息
List<DpProcessVo> dpProcessVos = JSONArray.parseArray(dpProcessJson, DpProcessVo.class);
// 把数据处理对象转换为HashSet
HashSet<DpProcessVo> hashSet = new HashSet(dpProcessVos);
// 当前集合影响的 其他集合列表
List<DpProcessVo> childFinalList = new ArrayList<>();
// 遍历redis中存储的集合影响关系，并进行简单去重处理
for (DpProcessVo dpProcessVo : hashSet) {
if(dpProcessVo.getId().equals(dpProcess.getId())){
continue;
}
childFinalList.add(dpProcessVo);
}
// 添加上本次影响的集合
DpProcessVo dpProcessVo = new DpProcessVo();
dpProcessVo.setId(dpProcess.getId());
dpProcessVo.setOutCols(dpProcess.getOutCols());
// 添加当前数据数据对象
childFinalList.add(dpProcessVo);
// 进行数据的存储
redisUtil.set(inClo, JSONArray.toJSON(childFinalList).toString());
}
}
}
invaldClosInfo() : 验证数据处理流程配置输入流程是否调用了输出集合
/**
* @create 验证数据处理流程配置输入流程是否调用了输出集合 2021/7/20 22:10
* @param nodeStack 深度遍历栈
* @return void
*/
public void invaldClosInfo(Stack<DpProcessVo> nodeStack) {
// 查看此堆栈顶部的对象而不将其从堆栈中移除
DpProcessVo dpProcessVo = nodeStack.peek();
// 从redis中查找此集合影响的流程关系
String dpProcessJson = (String) redisUtil.get(dpProcessVo.getOutCols());
// 如果集合没有影响其他集合，则直接返回
if(StringUtils.isBlank(dpProcessJson)){
return;
}
//获得节点的子节点，对于二叉树就是获得节点的左子结点和右子节点
List<DpProcessVo> children = new ArrayList<>();
// redis中原来存储的信息
children = JSONArray.parseArray(dpProcessJson, DpProcessVo.class);
// 遍历集合影响的集合关系
for (DpProcessVo dpProcessVo1 : children) {
boolean addFlag = true;
for (DpProcessVo processVo : nodeStack) {
if(processVo.getOutCols().equals(dpProcessVo1.getOutCols())){
addFlag = false;
break;
}
}
if(!addFlag){
throw new ServiceException("数据处理流程配置输入流程调用了输出集合！");
}
// 将dpProcessVo推到这个堆栈的顶部
nodeStack.push(dpProcessVo1);
// 验证数据处理流程配置输入流程是否调用了输出集合
invaldClosInfo(nodeStack);
// 移除此堆栈顶部的对象并将该对象作为此函数的值返回
nodeStack.pop();
}
}
dealNeedDeleteCols() : 主要处理--原数据为 A 集合影响 B 集合，修改为 C 集合影响了 B 集合，此时需要删除 A 对 B的影响关系
/**
* @create 处理需要删除的集合 2021/7/20 17:58
* @param dpProcess 数据处理模型
* @param oldClos 原来的数据处理模型中的集合信息
* @param set 最新的集合名称信息
* @return void
*/
private void dealNeedDeleteCols(DpProcess dpProcess, String oldClos, Set<String> set) {
if(StringUtils.isBlank(oldClos)){
return;
}
// 获取去重后的集合数组
List<String> newColsList = new ArrayList<>(set);
// 原来的集合数组
List<String> oldColsList = Arrays.asList(oldClos.split(","));
// 获取两个集合的差集
List<String> reduceList = oldColsList.stream().filter(item -> !newColsList.contains(item)).collect(toList());
if(reduceList == null || reduceList.size() == 0){
return;
}
for (String clos : reduceList) {
// 获取redis中的集合
String dpProcessJson = (String) redisUtil.get(clos);
if(StringUtils.isBlank(dpProcessJson)){
continue;
}
// redis中原来存储的信息
List<DpProcessVo> dpProcessVos = JSONArray.parseArray(dpProcessJson, DpProcessVo.class);
// 遍历删除的集合中影响的流程ID
HashSet<DpProcessVo> hashSet = new HashSet(dpProcessVos);
Iterator<DpProcessVo> it = hashSet.iterator();
while(it.hasNext()){
DpProcessVo dpProcessVo = it.next();
if(dpProcessVo.getId().equals(dpProcess.getId())){
it.remove();
}
}
// 如果当前集合影响的流程为空，则进行删除
if(hashSet.isEmpty()){
// 进行数据的存储
redisUtil.delete(clos);
continue;
}
// 进行数据的存储
redisUtil.set(clos, JSONArray.toJSON(hashSet.toArray()).toString());
}
}
6.测试
可通过单元测试等多种方式，本文提供简单的测试数据。
{
"category": "ly",
"code": "F",
"createdBy": "",
"createdTime": null,
"enabled": "1",
"id": "5",
"inCols": "D",
"name": "F",
"outCols": "L",
"remark": "F",
"revision": 0,
"status": 0,
"updatedBy": "",
"updatedTime": null
}
7.总结
仅对今日工作进行简单记录，代码还需进一步重构，记录永不止步。
java中避免集合死链调用的更多相关文章
- Java中的集合框架-Map
前两篇<Java中的集合框架-Commection(一)>和<Java中的集合框架-Commection(二)>把集合框架中的Collection开发常用知识点作了一下记录,从 ...
- 万字长文深入理解java中的集合-附PDF下载
目录 1. 前言 2. List 2.1 fail-safe fail-fast知多少 2.1.1 Fail-fast Iterator 2.1.2 Fail-fast 的原理 2.1.3 Fail- ...
- 菜鸟日记之 java中的集合框架
java中的集合框架图 如图所示:java中的集合分为两种Collection和Map两种接口 可分为Collection是单列集合和Map的双列集合 Collection单列集合:继承了Iterat ...
- C#与java中的集合区别
集合一般的操作 插入: add 删除: remove 查找: contains,remove java中的集合 注意哪些是接口,哪些是实现类 使用集合的时候 1. ...
- java中的集合操作类（未完待续）
申明: 实习生的肤浅理解,如发现有错误之处.还望大牛们多多指点 废话 事实上我写java的后台操作,我每次都会遇到一条语句:List<XXXXX> list = new ArrayList ...
- Java中的集合概述
Java中的集合类有两个重要的分支,分别是接口Collection(包括List,Set等)和接口Map. 由于HashSet的内部实现原理使用了HashMap,所以我们先来了解Map集合类. 1.H ...
- Java中的集合框架（上）
Java中的集合框架概述 集合的概念: Java中的集合类:是一种工具类,就像是容器,存储任意数量的具有共同属性的对象. 集合的作用: 1.在类的内部,对数据进行组织: 2.简单的快速的搜索大数据量的 ...
- Java中Set集合是如何实现添加元素保证不重复的？
Java中Set集合是如何实现添加元素保证不重复的? Set集合是一个无序的不可以重复的集合.今天来看一下为什么不可以重复. Set是一个接口,最常用的实现类就是HashSet,今天我们就拿HashS ...
- Java中各种集合（字符串类）的线程安全性！！！
Java中各种集合(字符串类)的线程安全性!!! 一.概念: 线程安全:就是当多线程访问时,采用了加锁的机制:即当一个线程访问该类的某个数据时,会对这个数据进行保护,其他线程不能对其访问,直到该线程读 ...
随机推荐
- awk-08-综合例子
分析nginx日志 1.统计访问IP次数 2.统计访问IP大于10次的 3.统计访问IP次数,并取出前几的访问数 4.统计时间段访问最多的IP 5.统计访问最多的10个页面 6.统计每个 URL 数量 ...
- Golang语言系列-02-常用数据类型
Go语言常用数据类型 Go 语言中有丰富的数据类型,除了基本的整型.浮点型.布尔型.字符串.byte/rune 之外, 还有数组.切片.函数.map.通道(channel).结构体等. Go语言的基本 ...
- Java-Collection、Map和Array之间的转换
1 List -> Map 设个User类: public class User { private String userName; private String userId; privat ...
- 使用Netcat实现通信和反弹Shell
一.概述 nc全称为netcat,所做的就是在两台电脑之间建立链接,并返回两个数据流 可运行在TCP或者UDP模式,添加参数 -u 则调整为udP,默认为tcp -v 参数,详细输出 -n参数,net ...
- python初始化定义空变量-小记
python初始化定义空变量 数值 digital_value = 0 字符串 str_value = "" 列表 list_value = [] 字典 ditc_value = ...
- Django静态文件配置 request对象 Django操作MySQL
Django中的文件介绍 render.HttpResponse和redirect 当我们想起手写一个项目,创建好应用并且注册之后,在urls.py文件先导入app文件夹下migrations下的vi ...
- SQL 练习39
查询各学生的年龄,只按年份来算 SELECT *,year(GETDATE())-YEAR(Sage)年龄 from Student
- SQL 练习28
查询平均成绩大于等于 85 的所有学生的学号.姓名和平均成绩 SELECT Student.SId,Student.Sname,平均成绩 FROM Student , (SELECT sid,AVG( ...
- SpringBoot返回枚举对象中的指定属性
枚举 package com.meeno.boot.oa.employee.enums; import com.alibaba.fastjson.annotation.JSONType; import ...
- Docker与数据：三种挂载方式
操作系统与存储 操作系统中将存储定义为 Volume(卷) ,这是对物理存储的逻辑抽象,以达到对物理存储提供有弹性的分割方式.另外,将外部存储关联到操作系统的动作定义为 Mount(挂载). Dock ...