這款輕量級規則引擎，真香！

作者：老三 2023-08-09 08:01:38

開發前端

在一些輕量級的需要規則引擎的場景下，AviatorScript 真的太香了，尤其是它的擴展性，支持通過Java自定義函數，我甚至可以在腳本里查詢數據庫、查詢Redis、調用外部接口……這樣就可以像搭積木一樣搭建想要的功能。

簡介

AviatorScript 是一門高性能、輕量級寄宿于 JVM （包括 Android 平臺）之上的腳本語言。

它起源于2010年，作者對當時已有的一些產品不是很滿意，所以自己擼了一個，它是Groovy的一個定制化的子集。

圖片

相比較一些傳統的規則引擎，比如Drools、Jess、JRules，它更加輕量級，而且性能更好，同時能力開放，擴展很方便。

我們來看（吹）看（吹）AviatorScript的特點：

它支持數字、字符串、正則表達式、布爾值等基本類型，并且可以使用所有 Java 運算符進行運算。
還有一個內置的東西叫做 bigint 和 decimal，可以處理超大整數和高精度運算。而且我們還可以通過運算符重載讓它們使用普通的算術運算符 +-*/。
語法非常齊全，可以用它來寫多行數據、條件語句、循環語句，還能處理詞法作用域和異常處理等等。
如果我們喜歡函數式編程，還有一個叫做 Sequence 抽象的東西，可以讓你更方便地處理集合。
還有一個輕量化的模塊系統，方便我們組織代碼。
如果我們需要調用 Java 方法，也沒問題，可以用多種方式方便地調用 Java 方法，還有一個完整的腳本 API可以讓你從 Java 調用腳本。
性能也是超出想象的好，如果使用 ASM 模式，它會直接將腳本翻譯成 JVM 字節碼，解釋模式還可以在 Android 等非標準 Java 平臺上運行。

AviatorScript可以用在各種場景，比如規則判斷和規則引擎、公式計算、動態腳本控制，甚至集合數據 ELT 等等。可以說相當全能了。

快速開始

AviatorScript 是一門寄生在 JVM (Hosted on the JVM）上的語言，類似 clojure/scala/kotlin 等等，我們從寫個Hello World開始。

創建一個SpringBoot項目，引入依賴，這里選擇的是最新版本

<dependency>
            <groupId>com.googlecode.aviator</groupId>
            <artifactId>aviator</artifactId>
            <version>5.3.3</version>
        </dependency>

PS:可以看到aviator的groupId有一個googlecode,但是它和Google可沒什么關系，這是因為早期aviator托管在Google的一個開源項目托管平臺Google Code。

在項目的resource目錄下創建一個目錄script，在script目錄下創建腳本hello.av

println("Hello, AviatorScript!");

編寫一個單元測試，運行腳本

@Test
    void testHello() throws Exception {
        //獲取路徑
        ClassPathResource resource = new ClassPathResource("script/hello.av");
        String scriptPath = resource.getPath();
        //編譯
        Expression exp = AviatorEvaluator.getInstance().compileScript(scriptPath);
        //執行
        exp.execute();
    }

最后執行一下，就可以看到輸出：

Hello, AviatorScript!

我們也可以直接把腳本定義成字符串，用compile()來進行編譯

@Test
    void testHelloStr() throws Exception {
        //定義腳本
        String script="println(\"Hello, AviatorScript!\");";
        //編譯
        Expression exp = AviatorEvaluator.getInstance().compile(script);
        //執行
        exp.execute();
    }

AviatorScript有一個Idea插件，支持直接編譯運行Aviator腳本，比較方便。

Aviator插件

但不足之處，這個插件已經不怎么維護了，只兼容到了Idea2021版本。

Idea插件

AviatorScript腳本的運行，分為兩步，編譯和執行。

編譯執行

編譯支持編譯腳本文件和腳本文本，分別使用compileScript和compile方法。

編譯產生的 Expression 對象，最終都是調用 execute() 方法執行。

這里有個重要能力，execute 方法可以接受一個變量列表組成的 map，來注入執行的上下文：

String expression = "a-(b-c) > 100";
        Expression compiledExp = AviatorEvaluator.compile(expression);
        //上下文
        double a=100.3,b=45,c= -199.100;
        Map<String, Object> cnotallow=new HashMap<>();
        context.put("a",a);
        context.put("b",b);
        context.put("c",c);
        //通過注入的上下文執行
        Boolean result = (Boolean) compiledExp.execute(context);
        System.out.println(result);

我們實現一些規則的判斷就是基于這個能力，把一些參數下上下文傳進去，然后進行邏輯判斷。

基本語法

我們在來看看AviatorScript的基本語法，它的語法相當簡潔，比較接近于數學表達式的形式。

基本類型及運算

AviatorScript 支持常見的類型，如數字、布爾值、字符串等等，同時將大整數、BigDecimal、正則表達式也作為一種基本類型來支持。

數字

AviatorScript 支持數字類型，包括整數和浮點數，以及高精度計算（BigDecimal）。數字類型可以進行各種算術運算。

整數和算術運算

整數類型，對應Java中的long類型，可以表示范圍為 -9223372036854774808 ~ 9223372036854774807 的整數。整數可以使用十進制或十六進制表示。

let a = 99;
let b = 0xFF;
let c = -99;

println(a + b); // 270
println(a / b); // 0
println(a - b + c); // -156
println(a + b * c); // -9801
println(a - (b - c)); // 198
println(a / b * b + a % b); // 99

整數可以進行加減乘除和取模運算。需要注意的是，整數相除的結果仍然是整數，遵循整數運算規則。可以使用括號來指定運算的優先級。

浮點數

浮點數類型對應Java中的double類型，表示雙精度 64 位浮點數。浮點數可以使用十進制或科學計數法表示。

let a = 1.34159265;
let b = 0.33333;
let c = 1e-2;

println(a + b); // 1.67492265
println(a - b); // 1.00826265
println(a * b); // 0.4471865500145
println(a / b); // 4.0257402772554
println(a + c); // 1.35159265

浮點數可以進行加減乘除運算，結果仍然為浮點數。

高精度計算(Decimal)

高精度計算使用 BigDecimal 類型，可以進行精確的數值計算，適用于貨幣運算或者物理公式運算的場景。可以通過在數字后面添加 "M" 后綴來表示 BigDecimal 類型。

let a = 1.34M;
let b = 0.333M;
let c = 2e-3M;

println(a + b); // 1.673M
println(a - b); // 1.007M
println(a * b); // 0.44622M
println(a / b); // 4.022022022M
println(a + c); // 1.342M

BigDecimal 類型可以進行加減乘除運算，結果仍然為 BigDecimal 類型。默認的運算精度是 MathContext.DECIMAL128，可以通過修改引擎配置項 Options.MATH_CONTEXT 來改變。

數字類型轉換

數字類型在運算時會自動進行類型轉換：

單一類型參與的運算，結果仍然為該類型。
多種類型參與的運算，按照 long -> bigint -> decimal -> double 的順序自動提升，結果為提升后的類型。

可以使用 long(x) 函數將數字強制轉換為 long 類型，使用 double(x) 函數將數字強制轉換為 double 類型。

let a = 1;
let b = 2;

println("a/b is " + a/b); // 0
println("a/double(b) is " + a/double(b)); // 0.5

a 和 b 都是 long 類型，它們相除的結果仍然是整數。使用 double(b) 將 b 轉換為 double 類型后，相除的結果為浮點數。

字符串

字符串類型由單引號或雙引號括起來的連續字符組成。可以使用 println 函數來打印字符串。

let a = "hello world";
println(a); // hello world

字符串的長度可以通過 string.length 函數獲取。

let a = "hello world";
println(string.length(a)); // 11

字符串可以通過 + 運算符進行拼接。

let a = "hello world";
let b = "AviatorScript";
println(a + ", " + b + "!" + 5); // hello world, AviatorScript!5

字符串還包括其他函數，如截取字符串 substring，都在 string 這個 namespace 下，具體見函數庫列表。

布爾類型和邏輯運算

布爾類型用于表示真和假，它只有兩個值 true 和 false 分別表示真值和假值。

比較運算如大于、小于可以產生布爾值：

println("3 > 1 is " + (3 > 1));  // 3 > 1 is true
println("3 >= 1 is " + (3 >= 1));  // 3 >= 1 is true
println("3 >= 3 is " + (3 >= 3));  // 3 >= 3 is true
println("3 < 1 is " + (3 < 1));  // 3 < 1 is false
println("3 <= 1 is " + (3 <= 1));  // 3 <= 1 is false
println("3 <= 3 is " + (3 <= 3));  // 3 <= 3 is true
println("3 == 1 is " + (3 == 1));  // 3 == 1 is false
println("3 != 1 is " + (3 != 1));  // 3 != 1 is true

上面演示了所有的邏輯運算符：

> 大于
>= 大于等于
< 小于
<= 小于等于
== 等于
!= 不等于

基本語法

AviatorScript也支持條件語句和循環語句。

條件語句

AviatorScript 中的條件語句和其他語言沒有太大區別：

if(true) {
   println("in if body");
}

if-else

if(false){
   println("in if body");
} else {
   println("in else body");
}

if-elsif-else

let a = rand(1100);

if(a > 1000) {
  println("a is greater than 1000.");
} elsif (a > 100) {
  println("a is greater than 100.");
} elsif (a > 10) {
   println("a is greater than 10.");
} else {
   println("a is less than 10 ");
}

循環語句

AviatorScript提供了兩種循環語句：for和while。

for循環：遍歷集合

for ... in 語句通常用于遍歷一個集合，例如下面是遍歷 0 到 9 的數字

for i in range(0, 10) {
  println(i);
}

在這里，range(start, end) 函數用于創建一個整數集合，包括起始值 start，但不包括結束值 end。在循環迭代過程中，變量 i 綁定到集合中的每個元素，并執行大括號 {...} 中的代碼塊。

range 函數還可以接受第三個參數，表示遞增的步長大小（默認步長為 1）。例如，我們可以打印出0到9之間的偶數：

for i in range(0, 10, 2) {
  println(i);
}

for .. in 可以用于任何集合結構，比如數組、 java.util.List 、 java.util.Map 等等。

while循環

while 循環本質上是將條件語句與循環結合在一起。當條件為真時，不斷執行一段代碼塊，直到條件變為假。

例如，下面的示例中，變量 sum 從 1 開始，不斷累加自身，直到超過 1000 才停止，然后進行打印輸出：

let sum = 1;

while sum < 1000 {
  sum = sum + sum;
}

println(sum);

循環可以用這三個關鍵字結束——continue/break/return：

continue用于跳過當前迭代，繼續下一次迭代。
break用于跳出整個循環。
return用于中斷整個腳本（或函數）的執行并返回。

函數

我們再來看看AviatorScript一個非常重要的特性——函數。

函數

函數定義和調用

AviatorScript中使用fn語法來定義函數：

fn add(x, y) {
  return x + y;
}

three = add(1, 2);
println(three);  // 輸出：3

s = add('hello', ' world');
println(s);  // 輸出：hello world

我們這里通過fn關鍵字來定義了一個函數，函數名為add，它接受兩個參數x和y，并返回它們的和。

需要注意的是，AviatorScript是動態類型系統，不需要定義參數和返回值的類型，它會根據實際傳入和返回的值進行自動類型轉換。因此，我們可以使用字符串來調用add函數。

函數的返回值可以通過return語句來指定，也可以省略不寫。在函數體內，如果沒有明確的return語句，最后一個表達式的值將被作為返回值。

自定義函數

再來給大家介紹一個AviatorScript里非常好的特性，支持自定義函數，這給AviatorScript帶來了非常強的擴展性。

可以通過 java 代碼實現并往引擎中注入自定義函數，在 AviatorScript 中就可以使用，事實上所有的內置函數也是通過同樣的方式實現的：

public class TestAviator {

    public static void main(String[] args) {
        //通通創建一個AviatorEvaluator的實例
        AviatorEvaluatorInstance instance = AviatorEvaluator.getInstance();
        //注冊函數
        instance.addFunction(new AddFunction());
        //執行ab腳本,腳本里調用自定義函數
        Double result= (Double) instance.execute("add(1, 2)");
        //輸出結果
        System.out.println(result);
    }
}

/**
 * 實現AbstractFunction接口，就可以自定義函數
 */
class AddFunction extends AbstractFunction {

    /**
     * 函數調用
     * @param env 當前執行的上下文
     * @param arg1 第一個參數
     * @param arg2 第二個參數
     * @return 函數返回值
     */
    @Override
    public AviatorObject call(Map<String, Object> env,
                              AviatorObject arg1, AviatorObject arg2) {
        Number left = FunctionUtils.getNumberValue(arg1, env);
        Number right = FunctionUtils.getNumberValue(arg2, env);
        //將兩個參數進行相加
        return new AviatorDouble(left.doubleValue() + right.doubleValue());
    }

    /**
     * 函數的名稱
     * @return 函數名
     */
    public String getName() {
        return "add";
    }
}

我們看到：

繼承AbstractFunction類，就可以自定義一個函數
重寫call方法，就可以定義函數的邏輯，可以通過FunctionUtils獲取腳本傳遞的參數
通過getName可以設置函數的名稱
通過addFunction添加一個自定義函數類的實例，就可以注冊函數
最后就可以在Aviator的腳本里編譯執行我們自定義的函數

好了，關于AviatorScript的語法我們就不過多介紹了，大家可以直接查看官方文檔[1]，可讀性相當不錯。

接下來我們就來看看AviatorScript的實際應用，看看它到底怎么提升項目的靈活性。

實戰案例

標題帶了規則引擎，在我們的項目里也主要是拿AviatorScript作為規則引擎使用——我們可以把AviatorScript的腳本維護在配置中心或者數據庫，進行動態地維護，這樣一來，一些規則的修改，就不用大動干戈地去修改代碼，這樣就更加方便和靈活了。

圖片

Aviator應用

客戶端版本控制

在日常的開發中，我們很多時候可能面臨這樣的情況，兼容客戶端的版本，尤其是Android和iPhone，有些功能是低版本不支持的，或者說有些功能到了高版本就廢棄掉，這時候如果硬編碼去兼容就很麻煩，那么就可以考慮使用規則腳本的方式。

自定義版本比較函數：AviatorScript沒有內置版本比較函數，但是可以利用它的自定義函數特性，自己定義一個版本比較函數

class VersionFunction extends AbstractFunction {

        @Override
        public String getName() {
            return "compareVersion";
        }

        @Override
        public AviatorObject call(Map<String, Object> env, AviatorObject arg1, AviatorObject arg2) {
            // 獲取版本
            String version1 = FunctionUtils.getStringValue(arg1, env);
            String version2 = FunctionUtils.getStringValue(arg2, env);
            int n = version1.length(), m = version2.length();
            int i = 0, j = 0;
            while (i < n || j < m) {
                int x = 0;
                for (; i < n && version1.charAt(i) != '.'; ++i) {
                    x = x * 10 + version1.charAt(i) - '0';
                }
                ++i; // 跳過點號
                int y = 0;
                for (; j < m && version2.charAt(j) != '.'; ++j) {
                    y = y * 10 + version2.charAt(j) - '0';
                }
                ++j; // 跳過點號
                if (x != y) {
                    return x > y ? new AviatorBigInt(1) : new AviatorBigInt(-1);
                }
            }
            return new AviatorBigInt(0);
        }
    }

注冊自定義函數：為了方便使用各種自定義函數，我們一般定義一個單例的AviatorEvaluatorInstance，把它注冊成Bean

@Bean
    public AviatorEvaluatorInstance aviatorEvaluatorInstance() {
        AviatorEvaluatorInstance instance = AviatorEvaluator.getInstance();
        // 默認開啟緩存
        instance.setCachedExpressionByDefault(true);
        // 使用LRU緩存，最大值為100個。
        instance.useLRUExpressionCache(100);
        // 注冊內置函數，版本比較函數。
        instance.addFunction(new VersionFunction());
    }

在代碼里傳遞上下文：接下來，就可以在業務代碼里將一些參數放進執行上下文，然然后進行編譯執行，注意編譯的時候最好要開啟緩存，這樣效率會高很多

/**
     * 
     * @param device 設備
     * @param version 版本
     * @param rule 規則腳本
     * @return
     */
    public boolean filter(String device,String version,String rule){
        // 執行參數
        Map<String, Object> env = new HashMap<>();
        env.put("device", device);
        //編譯腳本
        Expression expression = aviatorEvaluatorInstance.compile(DigestUtils.md5DigestAsHex(rule.getBytes()), rule, true);
        //執行腳本
        boolean isMatch = (boolean) expression.execute(env);
        return isMatch;
    }

編寫腳本：接下來就可以編寫和維護對應的規則腳本，這些規則腳本通常放在在配置中心或者數據庫，方便進行動態變更

if(device==bil){
    return false;
}

## 控制android的版本
if (device=="Android" && compareVersion(version,"1.38.1")<0){
    return false;
}

return true;

這樣一來，假如某天，客戶端Bug或者產品原因，需要修改客戶端和客戶端的版本控制，直接修改腳本就好了。

甚至我們可以在env里放進更多參數，比如uid，可以實現簡單的黑白名單。

我們的自定義函數除了這種簡單的比較版本，我們還可以放一些復雜的邏輯，比如判斷是否新用戶等等。

營銷活動規則

假如現在我們的運營希望進行一場營銷活動，對用戶進行一定的支付優惠，最開始的一版活動規則：

滿1000減200，滿500減100

這個好寫，一頓if-else就完事了。

但是沒過幾天，又改了活動規則：

首單用戶統一減20

好，啪啪改代碼。

又過去幾天，活動規則又改了：

隨機優惠不同金額

為了一些多變的營銷規則，大動干戈，不停修改代碼，耗時費力，那么不如用規則腳本實現：

定義腳本

if (amount>=100){
    return 200;
}elsif(amount>=500){
    return 100;
}else{
    return 0;
}

業務代碼調用

public BigDecimal getDiscount(BigDecimal amount,String rule){
        // 執行規則并計算最終價格
        Map<String, Object> env = new HashMap<>();
        env.put("amount", amount);
        Expression expression = aviatorEvaluatorInstance.compile(DigestUtils.md5DigestAsHex(rule.getBytes()), rule, true);
        return  (BigDecimal) expression.execute();
    }

接下來，再發生營銷規則變更，就可以少量開發（自定義函數，比如判斷首單用戶），并且可以組件化地維護營銷規則。

訂單風控規則

Aviator我在訂單風控里應用也很香，風控的規則調整是相當頻繁的，比如一個電商網站，常常要根據交易的爭議率、交易表現等等，來收緊和放松風控規則，這就要求我們能對一風控規則進行快速地配置變更。

例如，根據訂單金額、客戶評級、收貨地址等屬性，自動判斷是否有風險并觸發相應的風控操作。

規則腳本

if (amount>=1000 || rating <= 2){
    return "High";
}elsif(amount >= 500 || rating<=4){
    return "Mid";
}else{
    return "Low";
}

代碼調用：這里只是簡單返回了一個風控等級，其實可以通過Map的方式返回多個參數。

public String riskLevel(BigDecimal amount,String rating,String rule){
        // 執行規則并計算最終價格
        Map<String, Object> env = new HashMap<>();
        env.put("amount", amount);
        env.put("rating", rating);
        Expression expression = aviatorEvaluatorInstance.compile(DigestUtils.md5DigestAsHex(rule.getBytes()), rule, true);
        return  (String) expression.execute();
    }

上面隨手列出了幾個簡單的例子，AviatorScript 還可以用在一些審批流程、事件處理、數據質量管理等等場景……

總結

這一期給大家分享了一款輕量級的規則腳本語言AviatorScript，它的語法豐富，但是很輕量，并且支持非常靈活的擴展，在項目中使用可以有效提高業務的靈活性，降低開發的工作量。

本來這期想淺淺盤點一下AviatorScript的設計實現，結果發現越盤越深，所以就單獨拆出來，放在下一期了，敬請期待。

責任編輯：武曉燕來源：三分惡

場景 Redis 接口

成人免费xxxxx在线视频软件_久久精品久久久_亚洲国产精品久久久_天天色天天色_亚洲人成一区_欧美一级欧美三级在线观看

這款輕量級規則引擎，真香！

簡介

快速開始

基本語法

基本類型及運算

數字

整數和算術運算

浮點數

高精度計算(Decimal)

數字類型轉換

字符串

布爾類型和邏輯運算

基本語法

條件語句

循環語句

for循環：遍歷集合

while循環

函數

函數

函數定義和調用

自定義函數

實戰案例

客戶端版本控制

營銷活動規則

訂單風控規則

總結