public/liteFlow
1
0
Fork 0
mirror of https://gitee.com/dromara/liteFlow.git synced 2026-05-21 10:18:10 +08:00
Code Issues Packages Projects Releases Wiki Activity

封装参数为 bean

Browse Source
This commit is contained in:
gaibu
2022-06-11 10:54:18 +08:00
parent e5c5f27852
commit c6c05799b0
5 changed files with 375 additions and 154 deletions
Download Patch File Download Diff File Expand all files Collapse all files

93
liteflow-core/src/main/java/com/yomahub/liteflow/builder/prop/ChainPropBean.java Normal file
View File

@@ -0,0 +1,93 @@
package com.yomahub.liteflow.builder.prop;
import com.yomahub.liteflow.enums.ConditionTypeEnum;
/**
* 构建 chain 的中间属性
*/
public class ChainPropBean {
/**
* 执行规则
*/
String condValueStr;
/**
* 分组
*/
String group;
/**
* 是否抛出异常
*/
String errorResume;
/**
* 满足任意条件，执行完成
*/
String any;
/**
* 指定线程池
*/
String threadExecutorClass;
/**
* chain 类型
*/
ConditionTypeEnum conditionType;
public String getCondValueStr() {
return condValueStr;
}
public ChainPropBean setCondValueStr(String condValueStr) {
this.condValueStr = condValueStr;
return this;
}
public String getGroup() {
return group;
}
public ChainPropBean setGroup(String group) {
this.group = group;
return this;
}
public String getErrorResume() {
return errorResume;
}
public ChainPropBean setErrorResume(String errorResume) {
this.errorResume = errorResume;
return this;
}
public String getAny() {
return any;
}
public ChainPropBean setAny(String any) {
this.any = any;
return this;
}
public String getThreadExecutorClass() {
return threadExecutorClass;
}
public ChainPropBean setThreadExecutorClass(String threadExecutorClass) {
this.threadExecutorClass = threadExecutorClass;
return this;
}
public ConditionTypeEnum getConditionType() {
return conditionType;
}
public ChainPropBean setConditionType(ConditionTypeEnum conditionType) {
this.conditionType = conditionType;
return this;
}
}

91
liteflow-core/src/main/java/com/yomahub/liteflow/builder/prop/NodePropBean.java Normal file
View File

@@ -0,0 +1,91 @@
package com.yomahub.liteflow.builder.prop;
/**
* 构建 node 的中间属性
*/
public class NodePropBean {
/**
* id
*/
String id;
/**
* 名称
*/
String name;
/**
* 类
*/
String clazz;
/**
* 脚本
*/
String script;
/**
* 类型
*/
String type;
/**
* 脚本存放位置
*/
String file;
public String getId() {
return id;
}
public NodePropBean setId(String id) {
this.id = id;
return this;
}
public String getName() {
return name;
}
public NodePropBean setName(String name) {
this.name = name;
return this;
}
public String getClazz() {
return clazz;
}
public NodePropBean setClazz(String clazz) {
this.clazz = clazz;
return this;
}
public String getScript() {
return script;
}
public NodePropBean setScript(String script) {
this.script = script;
return this;
}
public String getType() {
return type;
}
public NodePropBean setType(String type) {
this.type = type;
return this;
}
public String getFile() {
return file;
}
public NodePropBean setFile(String file) {
this.file = file;
return this;
}
}

133
liteflow-core/src/main/java/com/yomahub/liteflow/parser/BaseFlowParser.java
View File

@@ -5,6 +5,8 @@ import cn.hutool.core.util.StrUtil;
import com.yomahub.liteflow.builder.LiteFlowChainBuilder;
import com.yomahub.liteflow.builder.LiteFlowConditionBuilder;
import com.yomahub.liteflow.builder.LiteFlowNodeBuilder;
import com.yomahub.liteflow.builder.prop.ChainPropBean;
import com.yomahub.liteflow.builder.prop.NodePropBean;
import com.yomahub.liteflow.enums.ConditionTypeEnum;
import com.yomahub.liteflow.enums.NodeTypeEnum;
import com.yomahub.liteflow.exception.EmptyConditionValueException;
@@ -18,76 +20,75 @@ import com.yomahub.liteflow.exception.NotSupportConditionException;
*/
public abstract class BaseFlowParser implements FlowParser {
/**
* 构建 node
*
* @param id id
* @param name 名称
* @param clazz 类
* @param script 脚本
* @param type 类型
* @param file 脚本存放位置
*/
public void buildNode(String id, String name, String clazz, String script, String type, String file) {
//初始化type
if (StrUtil.isBlank(type)) {
type = NodeTypeEnum.COMMON.getCode();
}
/**
* 构建 node
*
* @param nodePropBean 构建 node 的中间属性
*/
public void buildNode(NodePropBean nodePropBean) {
String id = nodePropBean.getId();
String name = nodePropBean.getName();
String clazz = nodePropBean.getClazz();
String script = nodePropBean.getScript();
String type = nodePropBean.getType();
String file = nodePropBean.getFile();
//检查nodeType是不是规定的类型
NodeTypeEnum nodeTypeEnum = NodeTypeEnum.getEnumByCode(type);
if (ObjectUtil.isNull(nodeTypeEnum)) {
throw new NodeTypeNotSupportException(StrUtil.format("type [{}] is not support", type));
}
//初始化type
if (StrUtil.isBlank(type)) {
type = NodeTypeEnum.COMMON.getCode();
}
//进行node的build过程
LiteFlowNodeBuilder.createNode().setId(id).setName(name).setClazz(clazz).setType(nodeTypeEnum).setScript(script).setFile(file).build();
}
//检查nodeType是不是规定的类型
NodeTypeEnum nodeTypeEnum = NodeTypeEnum.getEnumByCode(type);
if (ObjectUtil.isNull(nodeTypeEnum)) {
throw new NodeTypeNotSupportException(StrUtil.format("type [{}] is not support", type));
}
//进行node的build过程
LiteFlowNodeBuilder.createNode().setId(id).setName(name).setClazz(clazz).setType(nodeTypeEnum).setScript(script).setFile(file).build();
}
/**
* 构建 chain
*
* @param condValueStr 执行规则
* @param group 分组
* @param errorResume 是否抛出异常
* @param any 满足任意条件，执行完成
* @param threadExecutorClass 指定线程池
* @param conditionType chain 类型
* @param chainBuilder chainBuilder
*/
public void buildChain(String condValueStr
, String group
, String errorResume
, String any
, String threadExecutorClass
, ConditionTypeEnum conditionType
, LiteFlowChainBuilder chainBuilder) {
if (ObjectUtil.isNull(conditionType)) {
throw new NotSupportConditionException("ConditionType is not supported");
}
/**
* 构建 chain
*
* @param chainPropBean 构建 chain 的中间属性
* @param chainBuilder chainBuilder
*/
public void buildChain(ChainPropBean chainPropBean
, LiteFlowChainBuilder chainBuilder) {
String condValueStr = chainPropBean.getCondValueStr();
String group = chainPropBean.getGroup();
String errorResume = chainPropBean.getErrorResume();
String any = chainPropBean.getAny();
String threadExecutorClass = chainPropBean.getThreadExecutorClass();
ConditionTypeEnum conditionType = chainPropBean.getConditionType();
if (StrUtil.isBlank(condValueStr)) {
throw new EmptyConditionValueException("Condition value cannot be empty");
}
if (ObjectUtil.isNull(conditionType)) {
throw new NotSupportConditionException("ConditionType is not supported");
}
//如果是when类型的话，有特殊化参数要设置，只针对于when的
if (conditionType.equals(ConditionTypeEnum.TYPE_WHEN)) {
chainBuilder.setCondition(
LiteFlowConditionBuilder.createWhenCondition()
.setErrorResume(errorResume)
.setGroup(group)
.setAny(any)
.setThreadExecutorClass(threadExecutorClass)
.setValue(condValueStr)
.build()
).build();
} else {
chainBuilder.setCondition(
LiteFlowConditionBuilder.createCondition(conditionType)
.setValue(condValueStr)
.build()
).build();
}
}
if (StrUtil.isBlank(condValueStr)) {
throw new EmptyConditionValueException("Condition value cannot be empty");
}
//如果是when类型的话，有特殊化参数要设置，只针对于when的
if (conditionType.equals(ConditionTypeEnum.TYPE_WHEN)) {
chainBuilder.setCondition(
LiteFlowConditionBuilder.createWhenCondition()
.setErrorResume(errorResume)
.setGroup(group)
.setAny(any)
.setThreadExecutorClass(threadExecutorClass)
.setValue(condValueStr)
.build()
).build();
} else {
chainBuilder.setCondition(
LiteFlowConditionBuilder.createCondition(conditionType)
.setValue(condValueStr)
.build()
).build();
}
}
}

190
liteflow-core/src/main/java/com/yomahub/liteflow/parser/JsonFlowParser.java
View File

@@ -6,6 +6,8 @@ import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.parser.Feature;
import com.yomahub.liteflow.builder.LiteFlowChainBuilder;
import com.yomahub.liteflow.builder.prop.ChainPropBean;
import com.yomahub.liteflow.builder.prop.NodePropBean;
import com.yomahub.liteflow.enums.ConditionTypeEnum;
import com.yomahub.liteflow.flow.FlowBus;
import com.yomahub.liteflow.spi.holder.ContextCmpInitHolder;
@@ -38,105 +40,121 @@ import static com.yomahub.liteflow.common.ChainConstant._CLASS;
*/
public abstract class JsonFlowParser extends BaseFlowParser {
private final Logger LOG = LoggerFactory.getLogger(JsonFlowParser.class);
private final Logger LOG = LoggerFactory.getLogger(JsonFlowParser.class);
public void parse(String content) throws Exception {
parse(ListUtil.toList(content));
}
public void parse(String content) throws Exception {
parse(ListUtil.toList(content));
}
@Override
public void parse(List<String> contentList) throws Exception {
if (CollectionUtil.isEmpty(contentList)) {
return;
}
@Override
public void parse(List<String> contentList) throws Exception {
if (CollectionUtil.isEmpty(contentList)) {
return;
}
List<JSONObject> jsonObjectList = ListUtil.toList();
for (String content : contentList) {
//把字符串原生转换为json对象，如果不加第二个参数OrderedField，会无序
JSONObject flowJsonObject = JSONObject.parseObject(content, Feature.OrderedField);
jsonObjectList.add(flowJsonObject);
}
List<JSONObject> jsonObjectList = ListUtil.toList();
for (String content : contentList) {
//把字符串原生转换为json对象，如果不加第二个参数OrderedField，会无序
JSONObject flowJsonObject = JSONObject.parseObject(content, Feature.OrderedField);
jsonObjectList.add(flowJsonObject);
}
parseJsonObject(jsonObjectList);
}
parseJsonObject(jsonObjectList);
}
//json格式，解析过程
public void parseJsonObject(List<JSONObject> flowJsonObjectList) throws Exception {
//在相应的环境下进行节点的初始化工作
//在spring体系下会获得spring扫描后的节点，接入元数据
//在非spring体系下是一个空实现，等于不做此步骤
ContextCmpInitHolder.loadContextCmpInit().initCmp();
//json格式，解析过程
public void parseJsonObject(List<JSONObject> flowJsonObjectList) throws Exception {
//在相应的环境下进行节点的初始化工作
//在spring体系下会获得spring扫描后的节点，接入元数据
//在非spring体系下是一个空实现，等于不做此步骤
ContextCmpInitHolder.loadContextCmpInit().initCmp();
//先在元数据里放上chain
//先放有一个好处，可以在parse的时候先映射到FlowBus的chainMap，然后再去解析
//这样就不用去像之前的版本那样回归调用
//同时也解决了不能循环依赖的问题
flowJsonObjectList.forEach(jsonObject -> {
// 解析chain节点
JSONArray chainArray = jsonObject.getJSONObject(FLOW).getJSONArray(CHAIN);
//先在元数据里放上chain
//先放有一个好处，可以在parse的时候先映射到FlowBus的chainMap，然后再去解析
//这样就不用去像之前的版本那样回归调用
//同时也解决了不能循环依赖的问题
flowJsonObjectList.forEach(jsonObject -> {
// 解析chain节点
JSONArray chainArray = jsonObject.getJSONObject(FLOW).getJSONArray(CHAIN);
//先在元数据里放上chain
chainArray.forEach(o -> {
JSONObject innerJsonObject = (JSONObject) o;
FlowBus.addChain(innerJsonObject.getString(NAME));
});
});
//先在元数据里放上chain
chainArray.forEach(o -> {
JSONObject innerJsonObject = (JSONObject) o;
FlowBus.addChain(innerJsonObject.getString(NAME));
});
});
for (JSONObject flowJsonObject : flowJsonObjectList) {
// 当存在<nodes>节点定义时，解析node节点
if (flowJsonObject.getJSONObject(FLOW).containsKey(NODES)) {
JSONArray nodeArrayList = flowJsonObject.getJSONObject(FLOW).getJSONObject(NODES).getJSONArray(NODE);
String id, name, clazz, script, type, file;
for (int i = 0; i < nodeArrayList.size(); i++) {
JSONObject nodeObject = nodeArrayList.getJSONObject(i);
id = nodeObject.getString(ID);
name = nodeObject.getString(NAME);
clazz = nodeObject.getString(_CLASS);
type = nodeObject.getString(TYPE);
script = nodeObject.getString(VALUE);
file = nodeObject.getString(FILE);
for (JSONObject flowJsonObject : flowJsonObjectList) {
// 当存在<nodes>节点定义时，解析node节点
if (flowJsonObject.getJSONObject(FLOW).containsKey(NODES)) {
JSONArray nodeArrayList = flowJsonObject.getJSONObject(FLOW).getJSONObject(NODES).getJSONArray(NODE);
String id, name, clazz, script, type, file;
for (int i = 0; i < nodeArrayList.size(); i++) {
JSONObject nodeObject = nodeArrayList.getJSONObject(i);
id = nodeObject.getString(ID);
name = nodeObject.getString(NAME);
clazz = nodeObject.getString(_CLASS);
type = nodeObject.getString(TYPE);
script = nodeObject.getString(VALUE);
file = nodeObject.getString(FILE);
// 构建 node
buildNode(id, name, clazz, script, type, file);
}
}
// 构建 node
NodePropBean nodePropBean = new NodePropBean()
.setId(id)
.setName(name)
.setClazz(clazz)
.setScript(script)
.setType(type)
.setFile(file);
//解析每一个chain
JSONArray chainArray = flowJsonObject.getJSONObject(FLOW).getJSONArray(CHAIN);
chainArray.forEach(o -> {
JSONObject jsonObject = (JSONObject) o;
parseOneChain(jsonObject);
});
}
}
buildNode(nodePropBean);
}
}
//解析每一个chain
JSONArray chainArray = flowJsonObject.getJSONObject(FLOW).getJSONArray(CHAIN);
chainArray.forEach(o -> {
JSONObject jsonObject = (JSONObject) o;
parseOneChain(jsonObject);
});
}
}
/**
* 解析一个chain的过程
*/
private void parseOneChain(JSONObject chainObject) {
String condValueStr;
ConditionTypeEnum conditionType;
String group;
String errorResume;
String any;
String threadExecutorClass;
/**
* 解析一个chain的过程
*/
private void parseOneChain(JSONObject chainObject) {
String condValueStr;
ConditionTypeEnum conditionType;
String group;
String errorResume;
String any;
String threadExecutorClass;
//构建chainBuilder
String chainName = chainObject.getString(NAME);
LiteFlowChainBuilder chainBuilder = LiteFlowChainBuilder.createChain().setChainName(chainName);
//构建chainBuilder
String chainName = chainObject.getString(NAME);
LiteFlowChainBuilder chainBuilder = LiteFlowChainBuilder.createChain().setChainName(chainName);
for (Object o : chainObject.getJSONArray(CONDITION)) {
JSONObject condObject = (JSONObject) o;
conditionType = ConditionTypeEnum.getEnumByCode(condObject.getString(TYPE));
condValueStr = condObject.getString(VALUE);
errorResume = condObject.getString(ERROR_RESUME);
group = condObject.getString(GROUP);
any = condObject.getString(ANY);
threadExecutorClass = condObject.getString(THREAD_EXECUTOR_CLASS);
for (Object o : chainObject.getJSONArray(CONDITION)) {
JSONObject condObject = (JSONObject) o;
conditionType = ConditionTypeEnum.getEnumByCode(condObject.getString(TYPE));
condValueStr = condObject.getString(VALUE);
errorResume = condObject.getString(ERROR_RESUME);
group = condObject.getString(GROUP);
any = condObject.getString(ANY);
threadExecutorClass = condObject.getString(THREAD_EXECUTOR_CLASS);
// 构建 chain
buildChain(condValueStr, group, errorResume, any, threadExecutorClass, conditionType, chainBuilder);
}
}
ChainPropBean chainPropBean = new ChainPropBean()
.setCondValueStr(condValueStr)
.setGroup(group)
.setErrorResume(errorResume)
.setAny(any)
.setThreadExecutorClass(threadExecutorClass)
.setConditionType(conditionType);
// 构建 chain
buildChain(chainPropBean, chainBuilder);
}
}
}

22
liteflow-core/src/main/java/com/yomahub/liteflow/parser/XmlFlowParser.java
View File

@@ -4,6 +4,8 @@ import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.collection.ListUtil;
import cn.hutool.core.util.ObjectUtil;
import com.yomahub.liteflow.builder.LiteFlowChainBuilder;
import com.yomahub.liteflow.builder.prop.ChainPropBean;
import com.yomahub.liteflow.builder.prop.NodePropBean;
import com.yomahub.liteflow.enums.ConditionTypeEnum;
import com.yomahub.liteflow.flow.FlowBus;
import com.yomahub.liteflow.spi.holder.ContextCmpInitHolder;
@@ -92,7 +94,15 @@ public abstract class XmlFlowParser extends BaseFlowParser {
file = e.attributeValue(FILE);
// 构建 node
buildNode(id, name, clazz, script, type, file);
NodePropBean nodePropBean = new NodePropBean()
.setId(id)
.setName(name)
.setClazz(clazz)
.setScript(script)
.setType(type)
.setFile(file);
buildNode(nodePropBean);
}
}
@@ -126,8 +136,16 @@ public abstract class XmlFlowParser extends BaseFlowParser {
any = condE.attributeValue(ANY);
threadExecutorClass = condE.attributeValue(THREAD_EXECUTOR_CLASS);
ChainPropBean chainPropBean = new ChainPropBean()
.setCondValueStr(condValueStr)
.setGroup(group)
.setErrorResume(errorResume)
.setAny(any)
.setThreadExecutorClass(threadExecutorClass)
.setConditionType(conditionType);
// 构建 chain
buildChain(condValueStr, group, errorResume, any, threadExecutorClass, conditionType, chainBuilder);
buildChain(chainPropBean, chainBuilder);
}
}