wezone
/
liteflow-demo
10
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

1.增加主链路编码，实现多个主链路

This commit is contained in:
chenweilong 2022-12-19 11:54:58 +08:00
parent 3a3540079b
commit 1e01f892a3
7 changed files with 148 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/main/java/com/example/liteflow/mysql/entity/BaseChainEntity.java
View File

@ -23,7 +23,11 @@ public class BaseChainEntity {
*/ */
@TableField("template_id") @TableField("template_id")
private String templateId; private String templateId;
/**
* 主链路编码
*/
@TableField("main_chain_code")
private String mainChainCode;
/** /**
* 链路名称 * 链路名称
*/ */

6
src/main/java/com/example/liteflow/mysql/entity/BaseNodeEntity.java
View File

@ -27,7 +27,11 @@ public class BaseNodeEntity {
*/ */
@TableField("template_id") @TableField("template_id")
private String templateId; private String templateId;
/**
* 主链路编码
*/
@TableField("main_chain_code")
private String mainChainCode;
/** /**
* 节点名称 * 节点名称
*/ */

6
src/main/java/com/example/liteflow/mysql/model/baseChain/BaseChainVO.java
View File

@ -1,5 +1,6 @@
package com.example.liteflow.mysql.model.baseChain; package com.example.liteflow.mysql.model.baseChain;
import com.baomidou.mybatisplus.annotation.TableField;
import lombok.Data; import lombok.Data;
import java.time.LocalDateTime; import java.time.LocalDateTime;
@ -13,7 +14,10 @@ public class BaseChainVO {
private String id; private String id;
private String templateId; private String templateId;
/**
* 主链路编码
*/
private String mainChainCode;
private String templateName; private String templateName;
private String chainName; private String chainName;

4
src/main/java/com/example/liteflow/mysql/model/node/BaseNodeVO.java
View File

@ -22,6 +22,10 @@ public class BaseNodeVO {
* 所属模板id * 所属模板id
*/ */
private String templateId; private String templateId;
/**
* 主链路编码
*/
private String mainChainCode;
/** /**
* 所属模板名称 * 所属模板名称
*/ */

5
src/main/java/com/example/liteflow/mysql/model/node/CreateNodeFrom.java
View File

@ -20,7 +20,10 @@ public class CreateNodeFrom {
* 所属模板id * 所属模板id
*/ */
private String templateId; private String templateId;
/**
* 主链路编码
*/
private String mainChainCode;
/** /**
* 节点名称 * 节点名称
*/ */

4
src/main/java/com/example/liteflow/mysql/model/node/UpdateNodeFrom.java
View File

@ -17,6 +17,10 @@ public class UpdateNodeFrom {
* 节点对应输出节点id * 节点对应输出节点id
*/ */
private String nodeContentId; private String nodeContentId;
/**
* 主链路编码
*/
private String mainChainCode;
/** /**
* 规则 * 规则
*/ */

208
src/main/java/com/example/liteflow/mysql/service/impl/BaseChainServiceImpl.java
View File

@ -27,6 +27,7 @@ import com.yomahub.liteflow.flow.FlowBus;
import com.yomahub.liteflow.flow.LiteflowResponse; import com.yomahub.liteflow.flow.LiteflowResponse;
import com.yomahub.liteflow.flow.element.Chain; import com.yomahub.liteflow.flow.element.Chain;
import lombok.extern.slf4j.Slf4j; import lombok.extern.slf4j.Slf4j;
import org.assertj.core.util.Lists;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import javax.annotation.Resource; import javax.annotation.Resource;
@ -89,79 +90,97 @@ public class BaseChainServiceImpl extends ServiceImpl<BaseChainMapper, BaseChain
String templateName = templateEntity.getTemplateName(); String templateName = templateEntity.getTemplateName();
String templateId = templateEntity.getId(); String templateId = templateEntity.getId();
List<BaseNodeEntity> nodeList = templateEntity.getBaseNodeEntityList(); List<BaseNodeEntity> nodeList = templateEntity.getBaseNodeEntityList();
// 将所有节点注入 Map<String, List<BaseNodeEntity>> nodeMap = new HashMap<>();
nodeList.forEach(node -> { nodeList.forEach(node -> {
String nodeType = node.getNodeType(); String mainChainCode = node.getMainChainCode();
String nodeId = node.getNodeId(); if (nodeMap.containsKey(mainChainCode)) {
String nodeName = node.getNodeName(); List<BaseNodeEntity> nodeMapList = nodeMap.get(mainChainCode);
String nodeClass = node.getNodeClass(); nodeMapList.add(node);
if (NodeEnum.CommonNode.getName().equals(nodeType)) { } else {
LiteFlowNodeBuilder.createCommonNode() ArrayList<BaseNodeEntity> nodeMapList = Lists.newArrayList(node);
.setId(nodeId) nodeMap.put(mainChainCode, nodeMapList);
.setName(nodeName)
.setClazz(nodeClass)
.build();
} else if (NodeEnum.IfNode.getName().equals(nodeType)) {
LiteFlowNodeBuilder.createIfNode()
.setId(nodeId)
.setName(nodeName)
.setClazz(nodeClass)
.build();
} }
}); });
// 输出节点 for (Map.Entry<String, List<BaseNodeEntity>> entry : nodeMap.entrySet()) {
Map<String, BaseNodeEntity> commonNodeMap = nodeList.stream() String mainChainCode = entry.getKey();
.filter(node -> NodeEnum.CommonNode.getName().equals(node.getNodeType())) List<BaseNodeEntity> mapNodeList = entry.getValue();
.collect(Collectors.toMap(BaseNodeEntity::getId, BaseNodeEntity -> BaseNodeEntity)); // 将所有节点注入
// 判断节点 mapNodeList.forEach(node -> {
List<BaseNodeEntity> ifNodeList = nodeList.stream().filter(node -> NodeEnum.IfNode.getName().equals(node.getNodeType())).collect(Collectors.toList()); String nodeType = node.getNodeType();
StringBuilder stringBuilder = new StringBuilder(); String nodeId = node.getNodeId();
int leftBracesNum = 0; String nodeName = node.getNodeName();
int num = 0; String nodeClass = node.getNodeClass();
for (BaseNodeEntity ifNode : ifNodeList) { if (NodeEnum.CommonNode.getName().equals(nodeType)) {
num++; LiteFlowNodeBuilder.createCommonNode()
leftBracesNum++; .setId(nodeId)
stringBuilder.append("IF("); .setName(nodeName)
String ifNodeId = ifNode.getNodeId(); .setClazz(nodeClass)
String nodeContentId = ifNode.getNodeContentId(); .build();
BaseNodeEntity commonNode = commonNodeMap.get(nodeContentId); } else if (NodeEnum.IfNode.getName().equals(nodeType)) {
if (ObjectUtil.isNotNull(commonNode)) { LiteFlowNodeBuilder.createIfNode()
String commonNodeId = commonNode.getNodeId(); .setId(nodeId)
stringBuilder.append(ifNodeId).append(",").append(commonNodeId); .setName(nodeName)
} else { .setClazz(nodeClass)
stringBuilder.append(ifNodeId).append(",defaultOutput"); .build();
}
});
// 输出节点
Map<String, BaseNodeEntity> commonNodeMap = mapNodeList.stream()
.filter(node -> NodeEnum.CommonNode.getName().equals(node.getNodeType()))
.collect(Collectors.toMap(BaseNodeEntity::getId, BaseNodeEntity -> BaseNodeEntity));
// 判断节点
List<BaseNodeEntity> ifNodeList = mapNodeList.stream().filter(node -> NodeEnum.IfNode.getName().equals(node.getNodeType())).collect(Collectors.toList());
StringBuilder stringBuilder = new StringBuilder();
int leftBracesNum = 0;
int num = 0;
for (BaseNodeEntity ifNode : ifNodeList) {
num++;
leftBracesNum++;
stringBuilder.append("IF(");
String ifNodeId = ifNode.getNodeId();
String nodeContentId = ifNode.getNodeContentId();
BaseNodeEntity commonNode = commonNodeMap.get(nodeContentId);
if (ObjectUtil.isNotNull(commonNode)) {
String commonNodeId = commonNode.getNodeId();
stringBuilder.append(ifNodeId).append(",").append(commonNodeId);
} else {
stringBuilder.append(ifNodeId).append(",defaultOutput");
}
if (num != ifNodeList.size()) {
stringBuilder.append(",");
} else {
stringBuilder.append(",defaultOutput");
}
} }
if (num != ifNodeList.size()) { for (int i = 0; i < leftBracesNum; i++) {
stringBuilder.append(","); stringBuilder.append(")");
} else { }
stringBuilder.append(",defaultOutput"); String chainName = mainChainCode + "_" + templateName;
log.info("templateName = {}, stringBuilder = {}", templateName, stringBuilder);
BaseChainEntity baseChainEntity = new BaseChainEntity();
baseChainEntity.setTemplateId(templateId);
baseChainEntity.setMainChainCode(mainChainCode);
baseChainEntity.setChainName(chainName);
baseChainEntity.setElData(stringBuilder.toString());
if (!FlowBus.containChain(templateName)) {
LiteFlowChainELBuilder.createChain()
.setChainId(chainName)
.setEL(stringBuilder.toString())
.build();
flowExecutor.reloadRule();
}
LambdaUpdateWrapper<BaseChainEntity> baseChainQueryWrapper = new LambdaUpdateWrapper<>();
baseChainQueryWrapper.eq(BaseChainEntity::getTemplateId, templateId)
.eq(BaseChainEntity::getChainName, chainName)
.eq(BaseChainEntity::getMainChainCode, mainChainCode)
.eq(BaseChainEntity::getEnableMark, EnableMarkEnum.Enable.getValue());
BaseChainEntity checkExists = this.getOne(baseChainQueryWrapper);
if (ObjectUtil.isNull(checkExists)) {
this.save(baseChainEntity);
} else {
checkExists.setElData(stringBuilder.toString());
this.updateById(checkExists);
} }
}
for (int i = 0; i < leftBracesNum; i++) {
stringBuilder.append(")");
}
log.info("templateName = {}, stringBuilder = {}", templateName, stringBuilder);
BaseChainEntity baseChainEntity = new BaseChainEntity();
baseChainEntity.setTemplateId(templateId);
baseChainEntity.setChainName(templateName);
baseChainEntity.setElData(stringBuilder.toString());
if (!FlowBus.containChain(templateName)) {
LiteFlowChainELBuilder.createChain()
.setChainId(templateName)
.setEL(stringBuilder.toString())
.build();
flowExecutor.reloadRule();
}
LambdaUpdateWrapper<BaseChainEntity> baseChainQueryWrapper = new LambdaUpdateWrapper<>();
baseChainQueryWrapper.eq(BaseChainEntity::getTemplateId, templateId)
.eq(BaseChainEntity::getEnableMark, EnableMarkEnum.Enable.getValue());
BaseChainEntity checkExists = this.getOne(baseChainQueryWrapper);
if (ObjectUtil.isNull(checkExists)) {
this.save(baseChainEntity);
} else {
checkExists.setChainName(templateName);
checkExists.setElData(stringBuilder.toString());
this.updateById(checkExists);
} }
}); });
} }
@ -199,33 +218,48 @@ public class BaseChainServiceImpl extends ServiceImpl<BaseChainMapper, BaseChain
@Override @Override
public void initMainChain() { public void initMainChain() {
log.info("进入【初始化主链路】方法"); log.info("进入【初始化主链路】方法");
String mainChainName = "mainChain";
LambdaQueryWrapper<BaseChainEntity> queryWrapper = new LambdaQueryWrapper<>(); LambdaQueryWrapper<BaseChainEntity> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(BaseChainEntity::getEnableMark, EnableMarkEnum.Enable.getValue()) queryWrapper.eq(BaseChainEntity::getEnableMark, EnableMarkEnum.Enable.getValue());
.ne(BaseChainEntity::getChainName, "mainChain");
List<BaseChainEntity> chainList = this.list(queryWrapper); List<BaseChainEntity> chainList = this.list(queryWrapper);
log.info("chainList size = {}", chainList.size()); log.info("chainList size = {}", chainList.size());
if (CollUtil.isNotEmpty(chainList)) { if (CollUtil.isNotEmpty(chainList)) {
StringJoiner elData = new StringJoiner(",", "THEN(", ")"); Map<String, List<BaseChainEntity>> nodeMap = new HashMap<>();
chainList.forEach(chain -> elData.add(chain.getChainName())); // 根据链路编码进行分类
if (!FlowBus.containChain(mainChainName)) { chainList.forEach(chain -> {
String mainChainCode = chain.getMainChainCode();
if (nodeMap.containsKey(mainChainCode)) {
List<BaseChainEntity> nodeMapList = nodeMap.get(mainChainCode);
nodeMapList.add(chain);
} else {
ArrayList<BaseChainEntity> nodeMapList = Lists.newArrayList(chain);
nodeMap.put(mainChainCode, nodeMapList);
}
});
// 生成链路
for (Map.Entry<String, List<BaseChainEntity>> entry : nodeMap.entrySet()) {
String mainChainCode = entry.getKey();
String chainName = mainChainCode + "_mainChain";
List<BaseChainEntity> nodeMapList = entry.getValue();
StringJoiner elData = new StringJoiner(",", "THEN(", ")");
nodeMapList.forEach(chain -> elData.add(chain.getChainName()));
log.info("elData = {}", elData);
LiteFlowChainELBuilder.createChain() LiteFlowChainELBuilder.createChain()
.setChainId(mainChainName) .setChainId(chainName)
.setEL(elData.toString()) .setEL(elData.toString())
.build(); .build();
flowExecutor.reloadRule(); flowExecutor.reloadRule();
} LambdaQueryWrapper<BaseChainEntity> mainQueryWrapper = new LambdaQueryWrapper<>();
LambdaQueryWrapper<BaseChainEntity> mainQueryWrapper = new LambdaQueryWrapper<>(); mainQueryWrapper.eq(BaseChainEntity::getChainName, chainName);
mainQueryWrapper.eq(BaseChainEntity::getChainName, mainChainName); BaseChainEntity mainChain = this.getOne(mainQueryWrapper);
BaseChainEntity mainChain = this.getOne(mainQueryWrapper); if (ObjectUtil.isNull(mainChain)) {
if (ObjectUtil.isNull(mainChain)) { mainChain = new BaseChainEntity();
mainChain = new BaseChainEntity(); mainChain.setChainName(chainName);
mainChain.setChainName(mainChainName); mainChain.setElData(elData.toString());
mainChain.setElData(elData.toString()); this.save(mainChain);
this.save(mainChain); } else {
} else { mainChain.setElData(elData.toString());
mainChain.setElData(elData.toString()); this.updateById(mainChain);
this.updateById(mainChain); }
} }
} }
} }