private String[] findNextNodeIds(String currentNodeId, Map<String, Set<String>> nodeMap) {
Assert.notNull(currentNodeId, "currentNodeId must not be null");
Set<String> set = nodeMap.get(currentNodeId);
if (set != null) {
String[] array = set.toArray(new String[0]);
return array;
} else {
return null;
}
}
private boolean checkPath(
Map<String, Set<String>> nodeMap, String startNodeId, List<String> accessPath) {
Assert.notNull(nodeMap, "nodeMap must not be null");
Assert.notNull(startNodeId, "startNodeId must not be null");
boolean flag = false;
if (accessPath == null) accessPath = new ArrayList<String>();
String tmpId = startNodeId;
if (accessPath.contains(tmpId)) {
logger.error(String.format("Service(%s) is existed!", tmpId));
flag = false;
// accessPath.add(tmpId);
// if (accessPath != null) {
// System.out.println("======");
//
// for (String ts : accessPath) {
// System.out.print(ts + "->");
// }
// System.out.println("");
// System.out.println("======");
// }
return flag;
}
accessPath.add(tmpId);
String[] findNextNodeIds = findNextNodeIds(tmpId, nodeMap);
if (findNextNodeIds == null && !(this.getEnd().getId().equals(tmpId))) {
logger.error(String.format("Service(%s) isn't reach end", tmpId));
flag = false;
} else if (findNextNodeIds == null && this.getEnd().getId().equals(tmpId)) {
flag = true;
} else if (findNextNodeIds != null && this.getEnd().getId().equals(tmpId)) {
logger.error(String.format("Service(%s) must not have next service", tmpId));
flag = false;
} else {
if (findNextNodeIds != null)
for (String sn : findNextNodeIds) {
List<String> tmpList = new ArrayList<String>(accessPath);
flag = checkPath(nodeMap, sn, tmpList);
if (flag == false) break;
}
accessPath = null;
}
if (accessPath != null) {
System.out.println("======");
Collection<SequenceFlowNode> sequenceFlowNodes = this.getServiceFlow().getSequenceFlowNodes();
if (sequenceFlowNodes == null) sequenceFlowNodes = new ArrayList<SequenceFlowNode>();
Map<String, SequenceFlowNode> previousMap = new HashMap<String, SequenceFlowNode>();
// Map<String, SequenceFlowNode> nextMap = new HashMap<String, SequenceFlowNode>();
for (SequenceFlowNode sn : sequenceFlowNodes) {
previousMap.put(sn.getSoueceRef().getId(), sn);
// Set<String> keySet = sn.getTargetTrueRef().keySet();
// for (String s : keySet) {
// nextMap.put(s, sn);
// }
//
// if (sn.getTargetFalseRef() != null)
// nextMap.put(sn.getTargetFalseRef().getId(), sn);
//
// if (sn.getTargetExceptionRef() != null)
// nextMap.put(sn.getTargetExceptionRef().getId(), sn);
}
int forkcount = 0;
for (String ts : accessPath) {
// 判断fork和join数目
SequenceFlowNode sn = previousMap.get(ts);
// System.out.println("ts:" + ts + "," + sn.getId());
if (sn != null && sn.getSequenceFlowType().equals(SequenceFlowType.FORK)) {
forkcount++;
} else if (sn != null && sn.getSequenceFlowType().equals(SequenceFlowType.JOIN)) {
forkcount--;
}
System.out.print(ts + "->");
}
if (forkcount < 0) {
flag = false;
logger.error(
String.format("ServiceFlow(%s) fork num or join num is invalid", this.getId()));
}
System.out.println("");
System.out.println("======");
}
return flag;
}
/**
* 描述:检查服务流定义的完整性
*
* @param
* @return
* @throws
* @see
* @since %I%
*/
public void validate() {
// boolean flag = false;
// 算法：
Map<String, Set<String>> nodeMap = new HashMap<String, Set<String>>();
Collection<SequenceFlowNode> sequenceflowNodes = this.getServiceFlow().getSequenceFlowNodes();
for (SequenceFlowNode node : sequenceflowNodes) {
ServiceNode soueceRef = node.getSoueceRef();
Map<String, ServiceNode> targetTrueRef = node.getTargetTrueRef();
ServiceNode targetFalseRef = node.getTargetFalseRef();
ServiceNode targetExceptionRef = node.getTargetExceptionRef();
ConditionNode condition = node.getCondition();
// 有condition出现，必须有 true target service和false target service
if (condition != null) {
Assert.notEmpty(
targetTrueRef,
String.format("sequenceFlow(%s) targetTrueRef must not be empty", node.getId()));
Assert.notNull(
targetFalseRef,
String.format("sequenceFlow(%s) targetFalseRef must not be null", node.getId()));
}
if (node.getSequenceFlowType().equals(SequenceFlowType.SERIAL)
|| node.getSequenceFlowType().equals(SequenceFlowType.JOIN)) {
Assert.isTrue(
node.getTargetTrueRef().keySet().size() == 1,
String.format("sequenceFlow(%s) getTargetTrueRef must be 1", node.getId()));
}
if (node.getSequenceFlowType().equals(SequenceFlowType.FORK)) {
Set<String> targetTrueRefSet = node.getTargetTrueRef().keySet();
for (String s : targetTrueRefSet) {
Assert.isTrue(
this.getEnd().getId().equals(s),
String.format(
"sequenceFlow(%s) fork target service must not be end service", node.getId()));
}
}
// todo 每个节点只能fork一次
Set<String> set = nodeMap.get(soueceRef.getId());
if (set == null) {
set = new HashSet<String>();
nodeMap.put(soueceRef.getId(), set);
}
if (targetTrueRef != null) {
set.addAll(targetTrueRef.keySet());
}
if (targetFalseRef != null) {
set.add(targetFalseRef.getId());
}
if (targetExceptionRef != null) {
set.add(targetExceptionRef.getId());
}
}
String startNodeId = this.getStart().getId();
// EndNode endNode = this.getEnd();
// 判断从start能否走到ends 之一
Assert.isTrue(checkPath(nodeMap, startNodeId), "some service flow path is error");
}
