package com.ycl.scheme;
|
|
import com.ycl.scheme.entity.BlockCode;
|
import com.ycl.scheme.entity.Keyword;
|
import com.ycl.scheme.entity.Scheme;
|
import com.ycl.scheme.service.SchemeService;
|
import groovy.lang.GroovyClassLoader;
|
import org.apache.commons.lang3.StringUtils;
|
import org.springframework.stereotype.Component;
|
|
import java.util.ArrayList;
|
import java.util.List;
|
import java.util.regex.Matcher;
|
import java.util.regex.Pattern;
|
|
|
@Component
|
|
public class SchemeRunnerBuilder {
|
|
private static final String packageName = SchemeRunnerBuilder.class.getPackage().getName();
|
|
private static final String BLOCK_SPLIT_KEY = "数据源";
|
|
private static final String SOURCE_KEY = "数据源";
|
|
private static final String EXPRESSION_KEY = "条件";
|
|
private static final String RESULT_KEY = "结果";
|
|
|
private List<Keyword> keywordTemplates;
|
|
|
|
|
private SchemeService schemeService;
|
|
|
public SchemeRunnerBuilder(SchemeService schemeService) {
|
this.schemeService = schemeService;
|
}
|
|
public void build(Scheme scheme) {
|
this.keywordTemplates = schemeService.findKeywordTemplates();
|
|
List<BlockText> blockTexts = splitBlock(scheme.getInputText());
|
|
List<BlockCode> blockCodes = this.createBlockCode(blockTexts);
|
|
StringBuilder csb = new StringBuilder();
|
csb.append("package " + packageName + ";\n");
|
csb.append("import java.util.List;\n");
|
csb.append("import java.util.ArrayList;\n");
|
csb.append("import java.util.ArrayList;\n");
|
csb.append("import com.ycl.scheme.service.SchemeService;\n");
|
csb.append("import com.ycl.scheme.AbstractSchemeRunner;\n");
|
csb.append("import java.time.LocalDateTime;\n");
|
csb.append("import java.time.LocalDate;\n");
|
csb.append("");
|
csb.append("class scheme_" + scheme.getId() + " extends AbstractSchemeRunner {\n");
|
csb.append("SchemeService service;\n");
|
csb.append(" @Override\n");
|
csb.append(" void run(SchemeService service){\n");
|
csb.append(" this.service = service;\n");
|
csb.append(" "+ this.getConditionText(blockCodes));
|
// String cod = this.getCondition(bl);
|
String body = "";
|
String conditionLine = " if(";
|
for (int i=0;i<blockCodes.size();i++) {
|
BlockCode blockCode = blockCodes.get(i);
|
conditionLine +=blockCode.getName();
|
if(i+1 < blockCodes.size()){
|
conditionLine += blockCode.getLogic();
|
}else{
|
conditionLine +="){\n";
|
}
|
body += blockCode.getCode();
|
}
|
|
csb.append(" service.doAction(" + scheme.getId() + ")\n");
|
csb.append(" }\n");
|
|
csb.append("}\n");
|
csb.append("\n");
|
csb.append(body);
|
csb.append("}\n");
|
|
String code = csb.toString();
|
|
scheme.setOutCode(code);
|
|
AbstractSchemeRunner runner = this.createRunner(code);
|
scheme.setRunner(runner);
|
|
|
|
System.out.println(scheme.getOutCode());
|
}
|
|
private boolean buildTest(){
|
|
return true;
|
}
|
|
private String getConditionText(List<BlockCode> blockCodes){
|
StringBuilder csb= new StringBuilder();
|
csb.append(" if(");
|
|
for(int i=0;i<blockCodes.size();i++){
|
BlockCode bc = blockCodes.get(i);
|
String logic = "";
|
if(i<blockCodes.size()-1){
|
logic=bc.getLogic();
|
}else{
|
logic ="";
|
}
|
csb.append(bc.getName()+"() " + logic );
|
}
|
|
csb.append("){\n");
|
|
return csb.toString();
|
|
}
|
|
private List<BlockCode> createBlockCode(List<BlockText> blockTexts){
|
List<BlockCode> blockCodes = new ArrayList<>();
|
for(int i=0;i<blockTexts.size();i++){
|
BlockText text = blockTexts.get(i);
|
BlockCode code = new BlockCode();
|
AbstractBlockCodeBuilder builder = null;
|
if(StringUtils.isBlank(text.getResult().trim())){
|
builder = new CanalTriggerBuilder(text,this.keywordTemplates,i);
|
|
}else{
|
builder = new SqlQueryBuilder(text,this.keywordTemplates,i);
|
}
|
code =builder.build();
|
blockCodes.add(code);
|
}
|
|
return blockCodes;
|
}
|
|
|
|
|
private List<BlockText> splitBlock(String script) {
|
|
String[] blocks = script.split(BLOCK_SPLIT_KEY);
|
|
List<String> res = new ArrayList<>();
|
List<BlockText> blockTexts = new ArrayList<>();
|
for (String s : blocks) {
|
if (StringUtils.isNotBlank(s)) {
|
BlockText blockText = new BlockText();
|
s = BLOCK_SPLIT_KEY + s;
|
|
// String regex1 = SOURCE_KEY + "\\s*:\\s*(.*?)" +EXPRESSION_KEY;
|
String regex1 = SOURCE_KEY + "\\s*:\\s*(.*?)\\s*" + EXPRESSION_KEY;
|
String regex2 = EXPRESSION_KEY + "\\s*:\\s*(.*?)\\s*" + RESULT_KEY;
|
String regex3 = RESULT_KEY + "\\s*:\\s*(.*?)\\s*\n";
|
|
Pattern p1 = Pattern.compile(regex1);
|
Matcher matcher1 = p1.matcher(s);
|
if (matcher1.find()) {
|
String m1 = matcher1.group(1);
|
blockText.setSource(m1);
|
} else {
|
throw new RuntimeException("数据源的定义");
|
}
|
|
Pattern p2 = Pattern.compile(regex2);
|
Matcher matcher2 = p2.matcher(s);
|
if (matcher2.find()) {
|
String m2 = matcher2.group(1);
|
blockText.setExpression(m2);
|
} else {
|
throw new RuntimeException("没有找到条件的定义");
|
}
|
|
Pattern p3 = Pattern.compile(regex3);
|
Matcher matcher3 = p3.matcher(s);
|
if (matcher3.find()) {
|
int idx = matcher3.end();
|
String m3 = matcher3.group(1);
|
blockText.setResult(m3);
|
|
String logic = s.substring(idx).trim();
|
blockText.setLogic(logic);
|
} else {
|
throw new RuntimeException("没有找到结果的定义");
|
}
|
|
blockTexts.add(blockText);
|
}
|
}
|
|
return blockTexts;
|
}
|
|
public AbstractSchemeRunner createRunner(String code){
|
AbstractSchemeRunner runner =null;
|
try{
|
GroovyClassLoader classLoader = new GroovyClassLoader();
|
|
Class<AbstractSchemeRunner> runnerClass = classLoader.parseClass(code);
|
|
runner = runnerClass.newInstance();
|
|
return runner;
|
}catch (Exception e){
|
System.out.println(e.getMessage());
|
System.out.println(code);
|
|
throw new RuntimeException("构建groovy类时发生错误");
|
}
|
|
}
|
|
}
|
