• 规则引擎groovy

    规则引擎选型

    重量级方案：Acitivities、drools，适合复杂业务场景的规则引擎。

    轻量级方案：groovy脚本。

    groovy

    特点：

    动态性
    单纯的java语言是不具有动态性的，groovy恰恰弥补了这一缺憾，有了groovy你可以在程序运行时任意修改代码逻辑，不需要重新发布。
    语法糖
    groovy在语法上兼具java 语言和脚本语言特点，大大简化了语法。

    优点：

    学习曲线平缓，有丰富的语法糖，对于Java开发者非常友好；
    技术成熟，功能强大，易于使用维护，性能稳定，被业界看好；
    和Java兼容性强，可以无缝衔接Java代码，可以调用Java所有的库。可以在Groovy脚本中使用Java代码，兼容率高达90%，除了lambda、数组语法，其他Java语法基本都能兼容。

    原理：

            Groovy编译器先将.groovy文件编译成.class文件，然后调用JVM执行*.class文件，可以在Java项目中集成Groovy并充分利用Groovy的动态功能；

            Groovy兼容几乎所有的java语法，开发者完全可以将groovy当做Java来开发，甚至可以不使用Groovy的特有语法，仅仅通过引入Groovy并使用它的动态能力；

            Groovy可以直接调用项目中现有的Java类(通过import导入)，通过构造函数构造对象并直接调用其方法并返回结果。

    适用场景：

            Groovy适合在业务变化较多、较快的情况下进行一些可配置化的处理。适合规则数量相对较小的且不会频繁更新规则的规则引擎。

    Groovy与java集成

    GroovyClassLoader

    用 Groovy 的 GroovyClassLoader ，它会动态地加载一个脚本并执行它。GroovyClassLoader是一个Groovy定制的类装载器，负责加载解析Groovy脚本类。

    GroovyShell

    GroovyShell允许在Java类中（甚至Groovy类）求任意Groovy表达式的值。您可使用Binding对象输入参数给表达式，并最终通过GroovyShell返回Groovy表达式的计算结果。

    GroovyScriptEngine

    GroovyShell多用于推求对立的脚本或表达式，如果换成相互关联的多个脚本，使用GroovyScriptEngine会更好些。GroovyScriptEngine从您指定的位置（文件系统，URL，数据库，等等）加载Groovy脚本，并且随着脚本变化而重新加载它们。

    以GroovyClassLoader为例

    原理：GroovyClassLoader支持从文件、url或字符串中加载解析Groovy Class，实例化对象，反射调用指定方法。主要负责运行时处理Groovy脚本，将其编译、加载为Class对象的工作。

    1、引入jar包

    1.         <!-- groovy-all -->
    2.         <dependency>
    3.             <groupId>org.codehaus.groovy</groupId>
    4.             <artifactId>groovy-all</artifactId>
    5.             <version>3.0.12</version>
    6.             <type>pom</type>
    7.         </dependency>

    2、规则缓存工厂RuleCacheFactory

    核心代码：

    1.     private static Class buildGroovyClass(String groovyScript) throws RuleException {
    2.         // 每个class都new一个loader，便于垃圾回收
    3.         GroovyClassLoader groovyClassLoader = new GroovyClassLoader();
    4.         try {
    5.             // groovy脚本解析为class
    6.             return groovyClassLoader.parseClass(groovyScript);
    7.         } catch (CompilationFailedException e) {
    8.             log.error("groovy脚本解析为class异常！groovyScript={}", groovyScript, e);
    9.             throw new RuleException("groovy脚本解析为class异常！");
    10.         } finally {
    11.             try {
    12.                 groovyClassLoader.close();
    13.             } catch (IOException e) {
    14.                 log.error("GroovyClassLoader.close()异常！", e);
    15.             }
    16.         }
    17.     }

    RuleCacheFactory全部代码 ：

    1. import java.io.IOException;
    2. import java.util.Map;
    3. import java.util.concurrent.ConcurrentHashMap;
    4.  
    5. import groovy.lang.GroovyClassLoader;
    6. import lombok.extern.slf4j.Slf4j;
    7. import org.codehaus.groovy.control.CompilationFailedException;
    8. import yzh.exception.RuleException;
    9.  
    10. /**
    11.  * 规则缓存工厂
    12.  *
    13.  * @author yangzihe
    14.  * @date 2022/8/7
    15.  */
    16. @Slf4j
    17. public final class RuleCacheFactory {
    18.  
    19.     /**
    20.      * 规则脚本类缓存map  key-规则id value-规则脚本类
    21.      */
    22.     private static final Map ruleClassMap = new ConcurrentHashMap<>();
    23.  
    24.     /**
    25.      * 添加或更新规则脚本
    26.      *
    27.      * @param ruleId       规则id
    28.      * @param groovyScript 规则的groovy脚本
    29.      */
    30.     public static void addOrUpdateRuleClass(Long ruleId, String groovyScript) {
    31.         Class groovyClass = buildGroovyClass(groovyScript);
    32.         ruleClassMap.put(ruleId, groovyClass);
    33.     }
    34.  
    35.     /**
    36.      * 获取规则脚本类
    37.      *
    38.      * @param ruleId 规则id
    39.      *
    40.      * @return 规则脚本类
    41.      */
    42.     public static Class getRuleClass(Long ruleId) {
    43.         return ruleClassMap.get(ruleId);
    44.     }
    45.  
    46.     /**
    47.      * 删除规则脚本
    48.      *
    49.      * @param ruleId 规则id
    50.      */
    51.     public static void deleteRuleClass(Long ruleId) {
    52.         ruleClassMap.remove(ruleId);
    53.     }
    54.  
    55.     /**
    56.      * 构建groovy类
    57.      *
    58.      * @param groovyScript groovy脚本
    59.      *
    60.      * @return groovy类
    61.      *
    62.      * @throws RuleException
    63.      */
    64.     private static Class buildGroovyClass(String groovyScript) throws RuleException {
    65.         // 每个class都new一个loader，便于垃圾回收
    66.         GroovyClassLoader groovyClassLoader = new GroovyClassLoader();
    67.         try {
    68.             // groovy脚本解析为class
    69.             return groovyClassLoader.parseClass(groovyScript);
    70.         } catch (CompilationFailedException e) {
    71.             log.error("groovy脚本解析为class异常！groovyScript={}", groovyScript, e);
    72.             throw new RuleException("groovy脚本解析为class异常！");
    73.         } finally {
    74.             try {
    75.                 groovyClassLoader.close();
    76.             } catch (IOException e) {
    77.                 log.error("GroovyClassLoader.close()异常！", e);
    78.             }
    79.         }
    80.     }
    81.  
    82.     private RuleCacheFactory() {}
    83. }

    3、规则引擎RuleEngine

    1. /**
    2.  * groovy实现的规则引擎
    3.  *
    4.  * @author yangzihe
    5.  * @date 2022/8/7
    6.  */
    7. @Slf4j
    8. public class RuleEngine {
    9.  
    10.     /**
    11.      * 规则执行
    12.      *
    13.      * @param ruleId  规则id
    14.      * @param context 规则上下文
    15.      *
    16.      * @return 执行结果
    17.      */
    18.     public static RuleResult execute(Long ruleId, Map context) {
    19.         Class ruleClass = RuleCacheFactory.getRuleClass(ruleId);
    20.         if (ruleClass == null) {
    21.             log.error("规则class缓存中不存在！ruleId={}", ruleId);
    22.             return null;
    23.         }
    24.  
    25.         // 获取groovy对象
    26.         GroovyObject groovyObject = null;
    27.         try {
    28.             groovyObject = (GroovyObject) ruleClass.newInstance();
    29.         } catch (InstantiationException | IllegalAccessException e) {
    30.             log.error("创建GroovyObject实例异常！ruleId={}", ruleId, e);
    31.             throw new RuleException("创建GroovyObject实例异常");
    32.         }
    33.  
    34.         // 调用脚本的run方法且传参
    35.         Object result = null;
    36.         try {
    37.             result = groovyObject.invokeMethod("run", new Object[]{ruleId, context});
    38.         } catch (Exception e) {
    39.             log.error("规则执行异常！ruleId={}, context={}", ruleId, context, e);
    40.             throw new RuleException("规则执行异常");
    41.         }
    42.  
    43.         return (RuleResult) result;
    44.     }
    45. }

    4、规则执行测试

    1. import java.util.HashMap;
    2. import java.util.Map;
    3.  
    4. import lombok.extern.slf4j.Slf4j;
    5. import yzh.engine.bo.Rule;
    6. import yzh.engine.bo.RuleResult;
    7.  
    8. /**
    9.  * @author yangzihe
    10.  * @date 2022/8/21
    11.  */
    12. @Slf4j
    13. public class RuleEngineTest {
    14.     /**
    15.      * 规则执行测试
    16.      */
    17.     public static void main(String[] args) {
    18.         // 获取规则
    19.         Rule rule = new Rule();
    20.         rule.setRuleId(1L);
    21.         rule.setRuleCode("code1");
    22.         rule.setRuleName("规则1");
    23.  
    24.         // 获取规则脚本
    25.         RuleScript ruleScript = new RuleScript();
    26.  
    27.         ruleScript.setRule(rule);
    28.  
    29.         String runBody = RuleScriptUtils.buildRunBody();
    30.         ruleScript.setRunBody(runBody);
    31.  
    32.         String allMethod = RuleScriptUtils.buildAllMethod();
    33.         ruleScript.setAllMethod(allMethod);
    34.  
    35.         String groovyScript = ruleScript.getFullScript();
    36.         log.info("脚本：\n{}", groovyScript);
    37.         // 缓存规则class对象
    38.         RuleCacheFactory.addOrUpdateRuleClass(rule.getRuleId(), groovyScript);
    39.  
    40.         // 获取规则上下文
    41.         Map context = new HashMap<>();
    42.         context.put("name", "程序员");
    43.         context.put("age", 18);
    44.  
    45.         // 执行规则
    46.         RuleResult ruleResult = RuleEngine.execute(rule.getRuleId(), context);
    47.  
    48.         context.put("name", "程序员");
    49.         context.put("age", 40);
    50.         RuleResult ruleResult2 = RuleEngine.execute(rule.getRuleId(), context);
    51.     }
    52. }

    执行结果：

    1. 21:26:48.886 [main] INFO Rule_code1 - 规则执行，入参：{name=程序员, age=18}, 结果：RuleResult(ruleId=1, isHit=false, hitExpList=[1])
    2. 21:26:48.887 [main] INFO Rule_code1 - 规则执行，入参：{name=程序员, age=40}, 结果：RuleResult(ruleId=1, isHit=true, hitExpList=[1, 2])

    规则脚本：

    1. import java.util.*;
    2. import org.slf4j.Logger;
    3. import org.slf4j.LoggerFactory;
    4. import yzh.engine.bo.RuleResult;
    5.  
    6. @groovy.transform.CompileStatic
    7. public class Rule_code1 {
    8. 	private static final Logger log = LoggerFactory.getLogger(Rule_code1.class);
    9. 	// 上下文
    10. 	private Map context = null;
    11. 	// 命中的表达式id集合
    12. 	private List hitExpList = new ArrayList<>();
    13. 	// 执行入口
    14. 	public RuleResult run(Long ruleId, Map context) {
    15. 		this.context = context;
    16.  
    17. 		boolean isHit = exp_1() && exp_2();
    18.  
    19. 		RuleResult ruleResult = new RuleResult();
    20. 		ruleResult.setRuleId(ruleId);
    21. 		ruleResult.setIsHit(isHit);
    22. 		ruleResult.setHitExpList(hitExpList);
    23. 		log.info("规则执行，入参：{}, 结果：{}", context, ruleResult);
    24. 		return ruleResult;
    25. 	}
    26. 	// 表达式1
    27. 	private boolean exp_1() {
    28. 		String leftVar = (String) context.get("name");
    29. 		String rightVar = "程序员";
    30. 		boolean expHit = equalsString(leftVar, rightVar);
    31. 		if (expHit) {
    32. 			hitExpList.add(1L);
    33. 		}
    34. 		return expHit;
    35. 	}
    36. 	// 表达式2
    37. 	private boolean exp_2() {
    38. 		Long leftVar = (Long) context.get("age");
    39. 		Long rightVar = 35L;
    40. 		boolean expHit = greaterThanLong(leftVar, rightVar);
    41. 		if (expHit) {
    42. 			hitExpList.add(2L);
    43. 		}
    44. 		return expHit;
    45. 	}
    46. 	// 操作符函数
    47. 	private boolean equalsString(String leftVar, String rightVar) {
    48. 		if (leftVar == null) {
    49. 			return rightVar == null;
    50. 		}
    51. 		return leftVar.equals(rightVar);
    52. 	}
    53. 	// 操作符函数
    54. 	private boolean greaterThanLong(Long leftVar, Long rightVar) {
    55. 		if (leftVar == null) {
    56. 			return false;
    57. 		}
    58. 		return leftVar.compareTo(rightVar) > 0;
    59. 	}
    60.  
    61. }

    5、规则脚本RuleScript

    1. import java.util.List;
    2.  
    3. import lombok.Data;
    4. import yzh.engine.bo.Rule;
    5.  
    6. /**
    7.  * 规则脚本
    8.  *
    9.  * @author yangzihe
    10.  * @date 2022/8/20
    11.  */
    12. @Data
    13. public class RuleScript {
    14.  
    15.     /**
    16.      * 包名集合
    17.      */
    18.     private List packageList;
    19.     /**
    20.      * 规则
    21.      */
    22.     private Rule rule;
    23.     /**
    24.      * run方法体
    25.      */
    26.     private String runBody;
    27.     /**
    28.      * 所有方法
    29.      */
    30.     private String allMethod;
    31.  
    32.     /**
    33.      * 获取完整规则脚本
    34.      *
    35.      * @return 规则脚本
    36.      */
    37.     public String getFullScript() {
    38.         String scriptTemplate = RuleScriptUtils.buildScriptTemplate();
    39.         String importPackage = RuleScriptUtils.buildImportPackage(packageList);
    40.         String ruleCode = rule.getRuleCode();
    41.         return String.format(scriptTemplate, importPackage, ruleCode, ruleCode, runBody, allMethod);
    42.     }
    43.  
    44. }

     规则脚本工具类RuleScriptUtils

    1. package yzh.engine;
    2.  
    3. import java.util.List;
    4.  
    5. import lombok.extern.slf4j.Slf4j;
    6. import org.apache.commons.collections4.CollectionUtils;
    7.  
    8. import static yzh.engine.bo.ScriptConstant.CONTEXT;
    9. import static yzh.engine.bo.ScriptConstant.HIT_EXP_LIST;
    10. import static yzh.engine.bo.ScriptConstant.NEWLINE;
    11. import static yzh.engine.bo.ScriptConstant.RULE_RESULT_CLASS_NAME;
    12. import static yzh.engine.bo.ScriptConstant.TAB;
    13. import static yzh.engine.bo.ScriptConstant.TAB2;
    14. import static yzh.engine.bo.ScriptConstant.TAB3;
    15.  
    16. /**
    17.  * 规则脚本工具类
    18.  *
    19.  * @author yangzihe
    20.  * @date 2022/8/20
    21.  */
    22. @Slf4j
    23. public final class RuleScriptUtils {
    24.  
    25.     /**
    26.      * 构建脚本模板
    27.      *
    28.      * @return 脚本模板
    29.      */
    30.     public static String buildScriptTemplate() {
    31.         // %s
    32.         // @groovy.transform.CompileStatic
    33.         // public class Rule_%s {
    34.         //  private static final Logger log = LoggerFactory.getLogger(Rule_%s.class);
    35.         // 	// 上下文
    36.         // 	private Map context = null;
    37.         //  // 命中的表达式id集合
    38.         //  private List hitExpList = new ArrayList<>();
    39.         // 	// 执行入口
    40.         // 	public RuleResult run(Long ruleId, Map context) {
    41.         // %s
    42.         // 	}
    43.         // %s
    44.         // }
    45.         StringBuilder stringBuilder = new StringBuilder();
    46.  
    47.         // 1-%s：导包语句占位符
    48.         stringBuilder.append("%s").append(NEWLINE);
    49.  
    50.         // 使用groovy的静态编译：禁用了Groovy动态编程特征，例如：生成的字节码文件中不再含有实现动态编程的字节码指令"invoke dynamic"；
    51.         // 字节码文件也更小；生成的字节码将会和javac生成的字节码很相似，jvm执行性能接近。https://www.oschina.net/translate/new-groovy-20?cmp&p=2
    52.         stringBuilder.append("@groovy.transform.CompileStatic").append(NEWLINE);
    53.  
    54.         // 类名，2-%s：规则code占位符
    55.         stringBuilder.append("public class Rule_%s {").append(NEWLINE);
    56.  
    57.         // 成员变量声明，3-%s：规则code占位符
    58.         stringBuilder.append(TAB).append("private static final Logger log = LoggerFactory.getLogger(Rule_%s.class);").append(NEWLINE);
    59.         stringBuilder.append(TAB).append("// 上下文").append(NEWLINE);
    60.         stringBuilder.append(TAB).append("private Map ").append(CONTEXT).append(" = null;").append(NEWLINE);
    61.         stringBuilder.append(TAB).append("// 命中的表达式id集合").append(NEWLINE);
    62.         stringBuilder.append(TAB).append("private List ").append(HIT_EXP_LIST).append(" = new ArrayList<>();").append(NEWLINE);
    63.  
    64.         // 执行入口 run()方法声明
    65.         stringBuilder.append(TAB).append("// 执行入口").append(NEWLINE);
    66.         stringBuilder.append(TAB).append("public ").append(RULE_RESULT_CLASS_NAME).append(" run(Long ruleId, Map context) {").append(NEWLINE);
    67.         // 4-%s：run()方法体占位符
    68.         stringBuilder.append("%s").append(NEWLINE);
    69.         stringBuilder.append(TAB).append("}").append(NEWLINE);
    70.  
    71.         // 5-%s：所有方法的占位符
    72.         stringBuilder.append("%s").append(NEWLINE);
    73.  
    74.         stringBuilder.append("}").append(NEWLINE);
    75.  
    76.         return stringBuilder.toString();
    77.     }
    78.  
    79.     /**
    80.      * 构建导包语句
    81.      *
    82.      * @param packageList 包名集合
    83.      *
    84.      * @return 导包语句
    85.      */
    86.     public static String buildImportPackage(List packageList) {
    87.         StringBuilder stringBuilder = new StringBuilder();
    88.         // 公共类库
    89.         stringBuilder.append("import java.util.*;").append(NEWLINE);
    90.         stringBuilder.append("import org.slf4j.Logger;").append(NEWLINE);
    91.         stringBuilder.append("import org.slf4j.LoggerFactory;").append(NEWLINE);
    92.         stringBuilder.append("import yzh.engine.bo.RuleResult;").append(NEWLINE);
    93.         if (CollectionUtils.isEmpty(packageList)) {
    94.             return stringBuilder.toString();
    95.         }
    96.         for (String packageName : packageList) {
    97.             stringBuilder.append("import ").append(packageName).append(";").append(NEWLINE);
    98.         }
    99.         return stringBuilder.toString();
    100.     }
    101.  
    102.     /**
    103.      * 构建run()方法体
    104.      *
    105.      * @return run()方法体
    106.      */
    107.     public static String buildRunBody() {
    108.         StringBuilder stringBuilder = new StringBuilder();
    109.  
    110.         stringBuilder.append(TAB2).append("this.").append(CONTEXT).append(" = context;").append(NEWLINE);
    111.  
    112.         stringBuilder.append(NEWLINE);
    113.         stringBuilder.append(TAB2).append("boolean isHit = exp_1() && exp_2();").append(NEWLINE);
    114.         stringBuilder.append(NEWLINE);
    115.  
    116.         stringBuilder.append(TAB2).append("RuleResult ruleResult = new RuleResult();").append(NEWLINE);
    117.         stringBuilder.append(TAB2).append("ruleResult.setRuleId(ruleId);").append(NEWLINE);
    118.         stringBuilder.append(TAB2).append("ruleResult.setIsHit(isHit);").append(NEWLINE);
    119.         stringBuilder.append(TAB2).append("ruleResult.setHitExpList(hitExpList);").append(NEWLINE);
    120.         stringBuilder.append(TAB2).append("log.info(\"规则执行，入参：{}, 结果：{}\", context, ruleResult);").append(NEWLINE);
    121.         stringBuilder.append(TAB2).append("return ruleResult;");
    122.  
    123.         return stringBuilder.toString();
    124.     }
    125.  
    126.     /**
    127.      * 构建除run()方法外的其它所有方法
    128.      *
    129.      * @return 所有方法
    130.      */
    131.     public static String buildAllMethod() {
    132.         StringBuilder stringBuilder = new StringBuilder();
    133.  
    134.         String expMethod = buildExpMethod(1L);
    135.         String expMethod2 = buildExpMethod2(2L);
    136.         String operatorMethod = buildOperatorMethod();
    137.         String operatorMethod2 = buildOperatorMethod2();
    138.  
    139.         stringBuilder.append(expMethod);
    140.         stringBuilder.append(expMethod2);
    141.         stringBuilder.append(operatorMethod);
    142.         stringBuilder.append(operatorMethod2);
    143.  
    144.         return stringBuilder.toString();
    145.     }
    146.  
    147.     public static String buildExpMethod(Long expId) {
    148.         StringBuilder stringBuilder = new StringBuilder();
    149.  
    150.         stringBuilder.append(TAB).append("// 表达式").append(expId).append(NEWLINE);
    151.         stringBuilder.append(TAB).append("private boolean exp_").append(expId).append("() {").append(NEWLINE);
    152.         stringBuilder.append(TAB2).append("String leftVar = (String) context.get(\"name\");").append(NEWLINE);
    153.         stringBuilder.append(TAB2).append("String rightVar = \"程序员\";").append(NEWLINE);
    154.         stringBuilder.append(TAB2).append("boolean expHit = equalsString(leftVar, rightVar);").append(NEWLINE);
    155.         stringBuilder.append(TAB2).append("if (expHit) {").append(NEWLINE);
    156.         stringBuilder.append(TAB3).append("hitExpList.add(1L);").append(NEWLINE);
    157.         stringBuilder.append(TAB2).append("}").append(NEWLINE);
    158.         stringBuilder.append(TAB2).append("return expHit;").append(NEWLINE);
    159.         stringBuilder.append(TAB).append("}").append(NEWLINE);
    160.  
    161.         return stringBuilder.toString();
    162.     }
    163.  
    164.     public static String buildExpMethod2(Long expId) {
    165.         StringBuilder stringBuilder = new StringBuilder();
    166.  
    167.         stringBuilder.append(TAB).append("// 表达式").append(expId).append(NEWLINE);
    168.         stringBuilder.append(TAB).append("private boolean exp_").append(expId).append("() {").append(NEWLINE);
    169.         stringBuilder.append(TAB2).append("Long leftVar = (Long) context.get(\"age\");").append(NEWLINE);
    170.         stringBuilder.append(TAB2).append("Long rightVar = 35L;").append(NEWLINE);
    171.         stringBuilder.append(TAB2).append("boolean expHit = greaterThanLong(leftVar, rightVar);").append(NEWLINE);
    172.         stringBuilder.append(TAB2).append("if (expHit) {").append(NEWLINE);
    173.         stringBuilder.append(TAB3).append("hitExpList.add(2L);").append(NEWLINE);
    174.         stringBuilder.append(TAB2).append("}").append(NEWLINE);
    175.         stringBuilder.append(TAB2).append("return expHit;").append(NEWLINE);
    176.         stringBuilder.append(TAB).append("}").append(NEWLINE);
    177.  
    178.         return stringBuilder.toString();
    179.     }
    180.  
    181.     public static String buildOperatorMethod() {
    182.         StringBuilder stringBuilder = new StringBuilder();
    183.  
    184.         stringBuilder.append(TAB).append("// 操作符函数").append(NEWLINE);
    185.         stringBuilder.append(TAB).append("private boolean equalsString(String leftVar, String rightVar) {").append(NEWLINE);
    186.         stringBuilder.append(TAB2).append("if (leftVar == null) {").append(NEWLINE);
    187.         stringBuilder.append(TAB3).append("return rightVar == null;").append(NEWLINE);
    188.         stringBuilder.append(TAB2).append("}").append(NEWLINE);
    189.         stringBuilder.append(TAB2).append("return leftVar.equals(rightVar);").append(NEWLINE);
    190.         stringBuilder.append(TAB).append("}").append(NEWLINE);
    191.  
    192.         return stringBuilder.toString();
    193.     }
    194.  
    195.     public static String buildOperatorMethod2() {
    196.         StringBuilder stringBuilder = new StringBuilder();
    197.  
    198.         stringBuilder.append(TAB).append("// 操作符函数").append(NEWLINE);
    199.         stringBuilder.append(TAB).append("private boolean greaterThanLong(Long leftVar, Long rightVar) {").append(NEWLINE);
    200.         stringBuilder.append(TAB2).append("if (leftVar == null) {").append(NEWLINE);
    201.         stringBuilder.append(TAB3).append("return false;").append(NEWLINE);
    202.         stringBuilder.append(TAB2).append("}").append(NEWLINE);
    203.         stringBuilder.append(TAB2).append("return leftVar.compareTo(rightVar) > 0;").append(NEWLINE);
    204.         stringBuilder.append(TAB).append("}").append(NEWLINE);
    205.  
    206.         return stringBuilder.toString();
    207.     }
    208. }

    规则对象Rule

    1. package yzh.engine.bo;
    2.  
    3. import lombok.Data;
    4.  
    5. /**
    6.  * @author yangzihe
    7.  * @date 2022/8/7
    8.  */
    9. @Data
    10. public class Rule {
    11.  
    12.     /**
    13.      * 规则id
    14.      */
    15.     private Long ruleId;
    16.  
    17.     /**
    18.      * 规则编码
    19.      */
    20.     private String ruleCode;
    21.  
    22.     /**
    23.      * 规则名
    24.      */
    25.     private String ruleName;
    26.  
    27. }

    规则结果RuleResult

    1. package yzh.engine.bo;
    2.  
    3. import java.util.List;
    4.  
    5. import lombok.Data;
    6.  
    7. /**
    8.  * 规则结果
    9.  *
    10.  * @author yangzihe
    11.  * @date 2022/8/7
    12.  */
    13. @Data
    14. public class RuleResult {
    15.  
    16.     /**
    17.      * 规则id
    18.      */
    19.     private Long ruleId;
    20.  
    21.     /**
    22.      * 是否命中
    23.      */
    24.     private Boolean isHit;
    25.  
    26.     /**
    27.      * 命中的表达式id集合
    28.      */
    29.     private List hitExpList;
    30.  
    31. }

     脚本常量类ScriptConstant

    1. /**
    2.  * 脚本常量类
    3.  *
    4.  * @author yangzihe
    5.  * @date 2022/8/21
    6.  */
    7. public class ScriptConstant {
    8.  
    9.     /**
    10.      * 换行符
    11.      */
    12.     public static final String NEWLINE = System.getProperty("line.separator");
    13.  
    14.     public static final String TAB = "\t";
    15.     public static final String TAB2 = "\t\t";
    16.     public static final String TAB3 = "\t\t\t";
    17.  
    18.     /**
    19.      * 上下文变量名
    20.      */
    21.     public static final String CONTEXT = "context";
    22.  
    23.     /**
    24.      * 命中的表达式集合
    25.      */
    26.     public static final String HIT_EXP_LIST = "hitExpList";
    27.  
    28.     /**
    29.      * 规则结果类名
    30.      */
    31.     public static final String RULE_RESULT_CLASS_NAME = RuleResult.class.getSimpleName();
    32.  
    33. }

    RuleException

    1. public class RuleException extends RuntimeException {
    2.  
    3.     private static final long serialVersionUID = 6799975089755988273L;
    4.  
    5.     public RuleException() {
    6.         super("规则异常");
    7.     }
    8.  
    9.     public RuleException(String message) {
    10.         super(message);
    11.     }
    12.  
    13.     public RuleException(String message, Throwable e) {
    14.         super(message, e);
    15.     }
    16.  
    17.     public RuleException(Throwable e) {
    18.         super(e);
    19.     }
    20.  
    21. }

    参考：

    http://www.groovy-lang.org/integrating.html

    https://juejin.cn/post/6844903682639659015

    https://www.oschina.net/translate/new-groovy-20?cmp&p=2

  • 相关阅读:
    听书项目总结
    Mybatis常用代码
    包装类知识点
    21天学习挑战赛--第四天打卡（横竖屏切换）
    SSL知识讲解
    Springboot学生成绩管理系统idea开发mysql数据库web结构java编程计算机网页源码maven项目
    关于QTableWidget的it所占内存的释放问题
    HTTPS的加密原理
    全志G2D实现屏幕旋转，开机logo实现手动旋转。
    Python中的函数
  • 原文地址：https://blog.csdn.net/yzh_1346983557/article/details/126211611