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

refactoring: 使用抽象工厂模式重构查找解析器的代码

Browse Source
This commit is contained in:
119431682@qq.com
2022-06-26 09:56:07 +08:00
parent aefc00afa8
commit 3a7ddaac23
6 changed files with 251 additions and 142 deletions
Download Patch File Download Diff File Expand all files Collapse all files

162
liteflow-core/src/main/java/com/yomahub/liteflow/core/FlowExecutor.java
View File

@@ -14,25 +14,27 @@ import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.ReUtil;
import cn.hutool.core.util.StrUtil;
import com.google.common.collect.Lists;
import com.yomahub.liteflow.slot.DataBus;
import com.yomahub.liteflow.flow.LiteflowResponse;
import com.yomahub.liteflow.slot.DefaultContext;
import com.yomahub.liteflow.slot.Slot;
import com.yomahub.liteflow.flow.element.Chain;
import com.yomahub.liteflow.flow.element.Node;
import com.yomahub.liteflow.enums.FlowParserTypeEnum;
import com.yomahub.liteflow.exception.*;
import com.yomahub.liteflow.flow.FlowBus;
import com.yomahub.liteflow.parser.*;
import com.yomahub.liteflow.flow.LiteflowResponse;
import com.yomahub.liteflow.flow.element.Chain;
import com.yomahub.liteflow.flow.element.Node;
import com.yomahub.liteflow.parser.FlowParser;
import com.yomahub.liteflow.parser.factory.FlowParserProvider;
import com.yomahub.liteflow.property.LiteflowConfig;
import com.yomahub.liteflow.property.LiteflowConfigGetter;
import com.yomahub.liteflow.spi.holder.ContextAwareHolder;
import com.yomahub.liteflow.slot.DataBus;
import com.yomahub.liteflow.slot.DefaultContext;
import com.yomahub.liteflow.slot.Slot;
import com.yomahub.liteflow.thread.ExecutorHelper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.*;
import java.util.concurrent.*;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.concurrent.Future;
/**
* 流程规则主要执行器类
@@ -43,19 +45,8 @@ public class FlowExecutor {
private static final Logger LOG = LoggerFactory.getLogger(FlowExecutor.class);
private static final String ZK_CONFIG_REGEX = "[\\w\\d][\\w\\d\\.]+\\:(\\d)+(\\,[\\w\\d][\\w\\d\\.]+\\:(\\d)+)*";
private static final String LOCAL_XML_CONFIG_REGEX = "^[\\w\\:\\-\\@\\/\\\\\\*]+\\.xml$";
private static final String LOCAL_JSON_CONFIG_REGEX = "^[\\w\\:\\-\\@\\/\\\\\\*]+\\.json$";
private static final String LOCAL_YML_CONFIG_REGEX = "^[\\w\\:\\-\\@\\/\\\\\\*]+\\.yml$";
private static final String FORMATE_XML_CONFIG_REGEX = "xml:.+";
private static final String FORMATE_JSON_CONFIG_REGEX = "json:.+";
private static final String FORMATE_YML_CONFIG_REGEX = "yml:.+";
private static final String PREFIX_FORMATE_CONFIG_REGEX = "xml:|json:|yml:";
private static final String CLASS_CONFIG_REGEX = "^\\w+(\\.\\w+)*$";
private LiteflowConfig liteflowConfig;
public FlowExecutor() {
@@ -90,6 +81,7 @@ public class FlowExecutor {
return;
}
// 获取配置文件地址，','或者';'分割
List<String> sourceRulePathList = Lists.newArrayList(liteflowConfig.getRuleSource().split("[,;]"));
FlowParser parser = null;
@@ -97,36 +89,16 @@ public class FlowExecutor {
List<String> rulePathList = new ArrayList<>();
for (String path : sourceRulePathList) {
try {
FlowParserTypeEnum pattern = matchFormatConfig(path);
if (ObjectUtil.isNotNull(pattern)) {
path = ReUtil.replaceAll(path, PREFIX_FORMATE_CONFIG_REGEX, "");
switch (pattern) {
case TYPE_XML:
parser = matchFormatParser(path, FlowParserTypeEnum.TYPE_XML);
parserNameSet.add(parser.getClass().getName());
break;
case TYPE_JSON:
parser = matchFormatParser(path, FlowParserTypeEnum.TYPE_JSON);
parserNameSet.add(parser.getClass().getName());
break;
case TYPE_YML:
parser = matchFormatParser(path, FlowParserTypeEnum.TYPE_YML);
parserNameSet.add(parser.getClass().getName());
break;
default:
String errorMsg = StrUtil.format("can't support the format {}", path);
throw new ErrorSupportPathException(errorMsg);
}
}
// 查找对应的解析器
parser = FlowParserProvider.lookup(path);
parserNameSet.add(parser.getClass().getName());
// 替换掉zk配置的前缀
path = ReUtil.replaceAll(path, PREFIX_FORMATE_CONFIG_REGEX, "");
rulePathList.add(path);
//支持多类型的配置文件，分别解析
if (liteflowConfig.isSupportMultipleType()) {
if (ObjectUtil.isNotNull(parser)) {
parser.parseMain(ListUtil.toList(path));
} else {
throw new ConfigErrorException("parse error, please check liteflow config property");
}
parser.parseMain(ListUtil.toList(path));
}
} catch (CyclicDependencyException e){
LOG.error(e.getMessage());
@@ -165,100 +137,6 @@ public class FlowExecutor {
}
}
/**
* 匹配路径配置，生成对应的解析器
*/
private FlowParser matchFormatParser(String path, FlowParserTypeEnum pattern) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
boolean isLocalFile = isLocalConfig(path);
if (isLocalFile) {
LOG.info("flow info loaded from local file,path={},format type={}", path, pattern.getType());
switch (pattern) {
case TYPE_XML:
return new LocalXmlFlowParser();
case TYPE_JSON:
return new LocalJsonFlowParser();
case TYPE_YML:
return new LocalYmlFlowParser();
default:
}
} else if (isClassConfig(path)) {
LOG.info("flow info loaded from class config,class={},format type={}", path, pattern.getType());
Class<?> c = Class.forName(path);
switch (pattern) {
case TYPE_XML:
return (XmlFlowParser) ContextAwareHolder.loadContextAware().registerBean(c);
case TYPE_JSON:
return (JsonFlowParser) ContextAwareHolder.loadContextAware().registerBean(c);
case TYPE_YML:
return (YmlFlowParser) ContextAwareHolder.loadContextAware().registerBean(c);
default:
}
} else if (isZKConfig(path)) {
LOG.info("flow info loaded from Zookeeper,zkNode={},format type={}", path, pattern.getType());
switch (pattern) {
case TYPE_XML:
return new ZookeeperXmlFlowParser(liteflowConfig.getZkNode());
case TYPE_JSON:
return new ZookeeperJsonFlowParser(liteflowConfig.getZkNode());
case TYPE_YML:
return new ZookeeperYmlFlowParser(liteflowConfig.getZkNode());
default:
}
}
LOG.info("load flow info error, path={}, pattern={}", path, pattern.getType());
return null;
}
/**
* 判定是否为本地文件
*/
private boolean isLocalConfig(String path) {
return ReUtil.isMatch(LOCAL_XML_CONFIG_REGEX, path)
|| ReUtil.isMatch(LOCAL_JSON_CONFIG_REGEX, path)
|| ReUtil.isMatch(LOCAL_YML_CONFIG_REGEX, path);
}
/**
* 判定是否为自定义class配置
*/
private boolean isClassConfig(String path) {
return ReUtil.isMatch(CLASS_CONFIG_REGEX, path);
}
/**
* 判定是否为zk配置
*/
private boolean isZKConfig(String path) {
return ReUtil.isMatch(ZK_CONFIG_REGEX, path);
}
/**
* 匹配文本格式，支持xml，json和yml
*/
private FlowParserTypeEnum matchFormatConfig(String path) {
if (ReUtil.isMatch(LOCAL_XML_CONFIG_REGEX, path) || ReUtil.isMatch(FORMATE_XML_CONFIG_REGEX, path)) {
return FlowParserTypeEnum.TYPE_XML;
} else if (ReUtil.isMatch(LOCAL_JSON_CONFIG_REGEX, path) || ReUtil.isMatch(FORMATE_JSON_CONFIG_REGEX, path)) {
return FlowParserTypeEnum.TYPE_JSON;
} else if (ReUtil.isMatch(LOCAL_YML_CONFIG_REGEX, path) || ReUtil.isMatch(FORMATE_YML_CONFIG_REGEX, path)) {
return FlowParserTypeEnum.TYPE_YML;
} else if (isClassConfig(path)) {
try {
Class<?> clazz = Class.forName(path);
if (ClassXmlFlowParser.class.isAssignableFrom(clazz)) {
return FlowParserTypeEnum.TYPE_XML;
} else if (ClassJsonFlowParser.class.isAssignableFrom(clazz)) {
return FlowParserTypeEnum.TYPE_JSON;
} else if (ClassYmlFlowParser.class.isAssignableFrom(clazz)) {
return FlowParserTypeEnum.TYPE_YML;
}
} catch (ClassNotFoundException e) {
LOG.error(e.getMessage());
}
}
return null;
}
//此方法就是从原有的配置源主动拉取新的进行刷新
//和FlowBus.refreshFlowMetaData的区别就是一个为主动拉取，一个为被动监听到新的内容进行刷新
public void reloadRule() {

33
liteflow-core/src/main/java/com/yomahub/liteflow/parser/factory/ClassParserFactory.java Normal file
View File

@@ -0,0 +1,33 @@
package com.yomahub.liteflow.parser.factory;
import com.yomahub.liteflow.parser.JsonFlowParser;
import com.yomahub.liteflow.parser.XmlFlowParser;
import com.yomahub.liteflow.parser.YmlFlowParser;
import com.yomahub.liteflow.spi.holder.ContextAwareHolder;
/**
* Class文件
* <p>
*
* @author junjun
*/
public class ClassParserFactory implements FlowParserFactory {
@Override
public JsonFlowParser createJsonParser(String path) throws Exception {
Class<?> c = Class.forName(path);
return (JsonFlowParser) ContextAwareHolder.loadContextAware().registerBean(c);
}
@Override
public XmlFlowParser createXmlParser(String path) throws Exception {
Class<?> c = Class.forName(path);
return (XmlFlowParser) ContextAwareHolder.loadContextAware().registerBean(c);
}
@Override
public YmlFlowParser createYmlParser(String path) throws Exception {
Class<?> c = Class.forName(path);
return (YmlFlowParser) ContextAwareHolder.loadContextAware().registerBean(c);
}
}

21
liteflow-core/src/main/java/com/yomahub/liteflow/parser/factory/FlowParserFactory.java Normal file
View File

@@ -0,0 +1,21 @@
package com.yomahub.liteflow.parser.factory;
import com.yomahub.liteflow.parser.JsonFlowParser;
import com.yomahub.liteflow.parser.XmlFlowParser;
import com.yomahub.liteflow.parser.YmlFlowParser;
/**
* Flow Parser 工厂接口
* <p>
*
* @author junjun
*/
public interface FlowParserFactory {
JsonFlowParser createJsonParser(String path) throws Exception;
XmlFlowParser createXmlParser(String path) throws Exception;
YmlFlowParser createYmlParser(String path) throws Exception;
}

122
liteflow-core/src/main/java/com/yomahub/liteflow/parser/factory/FlowParserProvider.java Normal file
View File

@@ -0,0 +1,122 @@
package com.yomahub.liteflow.parser.factory;
import cn.hutool.core.util.ReUtil;
import cn.hutool.core.util.StrUtil;
import com.yomahub.liteflow.core.FlowExecutor;
import com.yomahub.liteflow.exception.ConfigErrorException;
import com.yomahub.liteflow.exception.ErrorSupportPathException;
import com.yomahub.liteflow.parser.ClassJsonFlowParser;
import com.yomahub.liteflow.parser.ClassXmlFlowParser;
import com.yomahub.liteflow.parser.ClassYmlFlowParser;
import com.yomahub.liteflow.parser.FlowParser;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import static com.yomahub.liteflow.enums.FlowParserTypeEnum.*;
/**
* 解析器提供者
* <p>
*
* @author junjun
*/
public class FlowParserProvider {
private static final Logger LOG = LoggerFactory.getLogger(FlowExecutor.class);
private static final String LOCAL_XML_CONFIG_REGEX = "^[\\w\\:\\-\\@\\/\\\\\\*]+\\.xml$";
private static final String LOCAL_JSON_CONFIG_REGEX = "^[\\w\\:\\-\\@\\/\\\\\\*]+\\.json$";
private static final String LOCAL_YML_CONFIG_REGEX = "^[\\w\\:\\-\\@\\/\\\\\\*]+\\.yml$";
private static final String FORMATE_XML_CONFIG_REGEX = "xml:.+";
private static final String FORMATE_JSON_CONFIG_REGEX = "json:.+";
private static final String FORMATE_YML_CONFIG_REGEX = "yml:.+";
private static final String CLASS_CONFIG_REGEX = "^\\w+(\\.\\w+)*$";
/**
* 根据配置的地址找到对应的解析器
*
* @param path
* @return
*/
public static FlowParser lookup(String path) throws Exception {
if (isLocalConfig(path)) {
FlowParserFactory factory = new LocalParserFactory();
if (ReUtil.isMatch(LOCAL_XML_CONFIG_REGEX, path)) {
LOG.info("flow info loaded from local file,path={},format type={}", path, TYPE_XML.getType());
return factory.createXmlParser(path);
}
else if (ReUtil.isMatch(LOCAL_JSON_CONFIG_REGEX, path)) {
LOG.info("flow info loaded from local file,path={},format type={}", path, TYPE_JSON.getType());
return factory.createJsonParser(path);
}
else if (ReUtil.isMatch(LOCAL_YML_CONFIG_REGEX, path)) {
LOG.info("flow info loaded from local file,path={},format type={}", path, TYPE_YML.getType());
return factory.createYmlParser(path);
}
}
else if (isClassConfig(path)) {
FlowParserFactory factory = new ClassParserFactory();
Class<?> clazz = Class.forName(path);
if (ClassXmlFlowParser.class.isAssignableFrom(clazz)) {
LOG.info("flow info loaded from class config,class={},format type={}", path, TYPE_XML.getType());
return factory.createXmlParser(path);
}
else if (ClassJsonFlowParser.class.isAssignableFrom(clazz)) {
LOG.info("flow info loaded from class config,class={},format type={}", path, TYPE_JSON.getType());
return factory.createJsonParser(path);
}
else if (ClassYmlFlowParser.class.isAssignableFrom(clazz)) {
LOG.info("flow info loaded from class config,class={},format type={}", path, TYPE_YML.getType());
return factory.createYmlParser(path);
}
// 自定义类必须实现以上实现类，否则报错
String errorMsg = StrUtil.format("can't support the format {}", path);
throw new ErrorSupportPathException(errorMsg);
}
else if (isZKConfig(path)) {
FlowParserFactory factory = new ZookeeperParserFactory();
if (ReUtil.isMatch(FORMATE_XML_CONFIG_REGEX, path)) {
LOG.info("flow info loaded from Zookeeper,zkNode={},format type={}", path, TYPE_XML.getType());
return factory.createXmlParser(path);
}
else if (ReUtil.isMatch(FORMATE_JSON_CONFIG_REGEX, path)) {
LOG.info("flow info loaded from Zookeeper,zkNode={},format type={}", path, TYPE_JSON.getType());
return factory.createJsonParser(path);
}
else if (ReUtil.isMatch(FORMATE_YML_CONFIG_REGEX, path)) {
LOG.info("flow info loaded from Zookeeper,zkNode={},format type={}", path, TYPE_YML.getType());
return factory.createYmlParser(path);
}
}
// not found
throw new ConfigErrorException("parse error, please check liteflow config property");
}
/**
* 判定是否为本地文件
*/
private static boolean isLocalConfig(String path) {
return ReUtil.isMatch(LOCAL_XML_CONFIG_REGEX, path)
|| ReUtil.isMatch(LOCAL_JSON_CONFIG_REGEX, path)
|| ReUtil.isMatch(LOCAL_YML_CONFIG_REGEX, path);
}
/**
* 判定是否为自定义class配置
*/
private static boolean isClassConfig(String path) {
return ReUtil.isMatch(CLASS_CONFIG_REGEX, path);
}
/**
* 判定是否为zk配置
*/
private static boolean isZKConfig(String path) {
return ReUtil.isMatch(FORMATE_XML_CONFIG_REGEX, path)
|| ReUtil.isMatch(FORMATE_JSON_CONFIG_REGEX, path)
|| ReUtil.isMatch(FORMATE_YML_CONFIG_REGEX, path);
}
}

27
liteflow-core/src/main/java/com/yomahub/liteflow/parser/factory/LocalParserFactory.java Normal file
View File

@@ -0,0 +1,27 @@
package com.yomahub.liteflow.parser.factory;
import com.yomahub.liteflow.parser.*;
/**
* 本地文件
* <p>
*
* @author junjun
*/
public class LocalParserFactory implements FlowParserFactory {
@Override
public JsonFlowParser createJsonParser(String path) {
return new LocalJsonFlowParser();
}
@Override
public XmlFlowParser createXmlParser(String path) {
return new LocalXmlFlowParser();
}
@Override
public YmlFlowParser createYmlParser(String path) {
return new LocalYmlFlowParser();
}
}

28
liteflow-core/src/main/java/com/yomahub/liteflow/parser/factory/ZookeeperParserFactory.java Normal file
View File

@@ -0,0 +1,28 @@
package com.yomahub.liteflow.parser.factory;
import com.yomahub.liteflow.parser.*;
import com.yomahub.liteflow.property.LiteflowConfigGetter;
/**
* Class文件
* <p>
*
* @author junjun
*/
public class ZookeeperParserFactory implements FlowParserFactory {
@Override
public JsonFlowParser createJsonParser(String path) {
return new ZookeeperJsonFlowParser(LiteflowConfigGetter.get().getZkNode());
}
@Override
public XmlFlowParser createXmlParser(String path) {
return new ZookeeperXmlFlowParser(LiteflowConfigGetter.get().getZkNode());
}
@Override
public YmlFlowParser createYmlParser(String path) {
return new ZookeeperYmlFlowParser(LiteflowConfigGetter.get().getZkNode());
}
}