Java中動態規則的實現方式

2020 年 8 月 25 日
筆記
JAVA, Programming, 規則引擎

背景

業務系統在應用過程中，有時候要處理「經常變化」的部分，這部分需求可能是「業務規則」，也可能是「不同的數據處理邏輯」，這部分動態規則的問題，往往需要可配置，並對性能和實時性有一定要求。

Java不是解決動態層問題的理想語言，在實踐中發現主要有以下幾種方式可以實現：

表達式語言（expression language）
動態語言（dynamic/script language language），如Groovy
規則引擎（rule engine）

表達式語言

Java Unified Expression Language，簡稱JUEL，是一種特殊用途的編程語言，主要在Java Web應用程序用於將表達式嵌入到web頁面。Java規範制定者和Java Web領域技術專家小組制定了統一的表達式語言。JUEL最初包含在JSP 2.1規範JSR-245中，後來成為Java EE 7的一部分，改在JSR-341中定義。

主要的開源實現有：OGNL ，MVEL ，SpEL，JUEL，Java Expression Language (JEXL)，JEval，Jakarta JXPath 等。

這裡主要介紹在實踐中使用較多的MVEL、OGNL和SpEL。

在Struts 2 的標籤庫中都是使用OGNL表達式訪問ApplicationContext中的對象數據，簡單示例：

Foo foo = new Foo();
foo.setName("test");
Map<String, Object> context = new HashMap<String, Object>();
context.put("foo",foo);
String expression = "foo.name == 'test'";
try {
    Boolean result = (Boolean) Ognl.getValue(expression,context);
    System.out.println(result);
} catch (OgnlException e) {
    e.printStackTrace();
}

MVEL

MVEL最初作為Mike Brock創建的 Valhalla項目的表達式計算器（expression evaluator），相比最初的OGNL、JEXL和JUEL等項目，而它具有遠超它們的性能、功能和易用性 – 特別是集成方面。它不會嘗試另一種JVM語言，而是着重解決嵌入式腳本的問題。

MVEL主要使用在Drools，是Drools規則引擎不可分割的一部分。

MVEL語法較為豐富，不僅包含了基本的屬性表達式，布爾表達式，變量複製和方法調用，還支持函數定義，詳情參見MVEL Language Guide 。

MVEL在執行語言時主要有解釋模式（Interpreted Mode）和編譯模式（Compiled Mode ）兩種：

解釋模式（Interpreted Mode）是一個無狀態的，動態解釋執行，不需要負載表達式就可以執行相應的腳本。
編譯模式（Compiled Mode）需要在緩存中產生一個完全規範化表達式之後再執行。

//解釋模式
Foo foo = new Foo();
foo.setName("test");
Map context = new HashMap();
String expression = "foo.name == 'test'";
VariableResolverFactory functionFactory = new MapVariableResolverFactory(context);
context.put("foo",foo);
Boolean result = (Boolean) MVEL.eval(expression,functionFactory);
System.out.println(result);

//編譯模式
Foo foo = new Foo();foo.setName("test");
Map context = new HashMap();
String expression = "foo.name == 'test'";
VariableResolverFactory functionFactory = new MapVariableResolverFactory(context);context.put("foo",foo);
Serializable compileExpression = MVEL.compileExpression(expression);
Boolean result = (Boolean) MVEL.executeExpression(compileExpression, context, functionFactory);

SpEL

SpEl(Spring表達式語言）是一個支持查詢和操作運行時對象導航圖功能的強大的表達式語言。它的語法類似於傳統EL，但提供額外的功能，最出色的就是函數調用和簡單字符串的模板函數。SpEL類似於Struts2x中使用的OGNL表達式語言，能在運行時構建複雜表達式、存取對象圖屬性、對象方法調用等等，並且能與Spring功能完美整合，如能用來配置Bean定義。

SpEL主要提供基本表達式、類相關表達式及集合相關表達式等，詳細參見Spring 表達式語言 (SpEL) 。

類似與OGNL，SpEL具有expression(表達式)，Parser（解析器），EvaluationContext(上下文）等基本概念；類似與MVEL，SpEl也提供了解釋模式和編譯模式兩種運行模式。

//解釋器模式
Foo foo = new Foo();
foo.setName("test");
// Turn on:
// - auto null reference initialization
// - auto collection growing
SpelParserConfiguration config = new SpelParserConfiguration(true,true);
ExpressionParser parser = new SpelExpressionParser(config);
String expressionStr = "#foo.name == 'test'";
StandardEvaluationContext context = new StandardEvaluationContext();
context.setVariable("foo",foo);
Expression expression = parser.parseExpression(expressionStr);
Boolean result = expression.getValue(context,Boolean.class);

//編譯模式
config = new SpelParserConfiguration(SpelCompilerMode.IMMEDIATE, RunSpel.class.getClassLoader());
parser = new SpelExpressionParser(config);
context = new StandardEvaluationContext();
context.setVariable("foo",foo);
expression = parser.parseExpression(expressionStr);
result = expression.getValue(context,Boolean.class);

規則引擎

一些規則引擎（rule engine）：aviator，easy-rules，drools，esper

aviator

AviatorScript 是一門高性能、輕量級寄宿於 JVM 之上的腳本語言。

使用場景包括：

規則判斷及規則引擎
公式計算
動態腳本控制
集合數據 ELT 等

public class Test {
   public static void main(String[] args) {
       String expression = "a+(b-c)>100";
       // 編譯表達式
       Expression compiledExp = AviatorEvaluator.compile(expression);

       Map<String, Object> env = new HashMap<>();
       env.put("a", 100.3);
       env.put("b", 45);
       env.put("c", -199.100);

       // 執行表達式
       Boolean result = (Boolean) compiledExp.execute(env);
       System.out.println(result);
   }
}

easy-rules

Easy Rules is a Java rules engine。

使用POJO定義規則：

@Rule(name = "weather rule", description = "if it rains then take an umbrella")
public class WeatherRule {

    @Condition
    public boolean itRains(@Fact("rain") boolean rain) {
        return rain;
    }
    
    @Action
    public void takeAnUmbrella() {
        System.out.println("It rains, take an umbrella!");
    }
}

Rule weatherRule = new RuleBuilder()
        .name("weather rule")
        .description("if it rains then take an umbrella")
        .when(facts -> facts.get("rain").equals(true))
        .then(facts -> System.out.println("It rains, take an umbrella!"))
        .build();

支持使用表達式語言（MVEL/SpEL）來定義規則：

weather-rule.yml example:

name: "weather rule"
description: "if it rains then take an umbrella"
condition: "rain == true"
actions:
  - "System.out.println(\"It rains, take an umbrella!\");"

MVELRuleFactory ruleFactory = new MVELRuleFactory(new YamlRuleDefinitionReader());
Rule weatherRule = ruleFactory.createRule(new FileReader("weather-rule.yml"));

觸發規則：

public class Test {
    public static void main(String[] args) {
        // define facts
        Facts facts = new Facts();
        facts.put("rain", true);

        // define rules
        Rule weatherRule = ...
        Rules rules = new Rules();
        rules.register(weatherRule);

        // fire rules on known facts
        RulesEngine rulesEngine = new DefaultRulesEngine();
        rulesEngine.fire(rules, facts);
    }
}

drools

An open source rule engine, DMN engine and complex event processing (CEP) engine for Java and the JVM Platform.

定義規則：

import com.lrq.wechatDemo.domain.User   // 導入類
dialect  "mvel"
rule "age"    // 規則名，唯一
    when
        $user : User(age<15 || age>60)  //規則的條件部分
    then
        System.out.println("年齡不符合要求！");
end

參考例子：

public class TestUser {
    private static KieContainer container = null;
    private KieSession statefulKieSession = null;

    @Test
    public void test(){
        KieServices kieServices = KieServices.Factory.get();
        container = kieServices.getKieClasspathContainer();
        statefulKieSession = container.newKieSession("myAgeSession");
        User user = new User("duval yang",12);
        statefulKieSession.insert(user);
        statefulKieSession.fireAllRules();
        statefulKieSession.dispose();
    }
}

esper

Esper is a component for complex event processing (CEP), streaming SQL and event series analysis, available for Java as Esper, and for .NET as NEsper.

一個例子：

public class Test {
    public static void main(String[] args) throws InterruptedException {
        EPServiceProvider epService = EPServiceProviderManager.getDefaultProvider();
 
        EPAdministrator admin = epService.getEPAdministrator();
 
        String product = Apple.class.getName();
        String epl = "select avg(price) from " + product + ".win:length_batch(3)";
 
        EPStatement state = admin.createEPL(epl);
        state.addListener(new AppleListener());
 
        EPRuntime runtime = epService.getEPRuntime();
 
        Apple apple1 = new Apple();
        apple1.setId(1);
        apple1.setPrice(5);
        runtime.sendEvent(apple1);
 
        Apple apple2 = new Apple();
        apple2.setId(2);
        apple2.setPrice(2);
        runtime.sendEvent(apple2);
 
        Apple apple3 = new Apple();
        apple3.setId(3);
        apple3.setPrice(5);
        runtime.sendEvent(apple3);
    }
}

drools和esper都是比較重的規則引擎，詳見其官方文檔。

動態JVM語言

Groovy

Groovy除了Gradle 上的廣泛應用之外，另一個大範圍的使用應該就是結合Java使用動態代碼了。Groovy的語法與Java非常相似，以至於多數的Java代碼也是正確的Groovy代碼。Groovy代碼動態的被編譯器轉換成Java位元組碼。由於其運行在JVM上的特性，Groovy可以使用其他Java語言編寫的庫。

Groovy可以看作給Java靜態世界補充動態能力的語言，同時Groovy已經實現了java不具備的語言特性：

函數字面值；
對集合的一等支持；
對正則表達式的一等支持；
對xml的一等支持；

Groovy作為基於JVM的語言，與表達式語言存在語言級的不同，因此在語法上比表達還是語言更靈活。Java在調用Groovy時，都需要將Groovy代碼編譯成Class文件。

Groovy 可以採用GroovyClassLoader、GroovyShell、GroovyScriptEngine和JSR223 等方式與Java語言集成。

一個使用GroovyClassLoader動態對json對象進行filter的例子：

public class GroovyFilter implements Filter {
    private static String template =  "" +
            "package com.alarm.eagle.filter;" +
            "import com.fasterxml.jackson.databind.node.ObjectNode;" +
            "def match(ObjectNode o){[exp]}";

    private static String method = "match";

    private String filterExp;

    private transient GroovyObject filterObj;

    public GroovyFilter(String filterExp) throws Exception {
        ClassLoader parent = Thread.currentThread().getContextClassLoader();
        GroovyClassLoader classLoader = new GroovyClassLoader(parent);
        Class clazz = classLoader.parseClass(template.replace("[exp]", filterExp));
        filterObj = (GroovyObject)clazz.newInstance();
    }

    public boolean filter(ObjectNode objectNode) {
        return (boolean)filterObj.invokeMethod(method, objectNode);
    }
}

Java每次調用Groovy代碼都會將Groovy編譯成Class文件，因此在調用過程中會出現JVM級別的問題。如使用GroovyShell的parse方法導致perm區爆滿的問題，使用GroovyClassLoader加載機制導致頻繁gc問題和CodeCache用滿，導致JIT禁用問題等，相關問題可以參考Groovy與Java集成常見的坑。

參考：

Java各種規則引擎：//www.jianshu.com/p/41ea7a43093c

Java中使用動態代碼：//brucefengnju.github.io/post/dynamic-code-in-java/

量身定製規則引擎，適應多變業務場景：//my.oschina.net/yygh/blog/616808?p=1

Tags: JAVA Programming 規則引擎