Aviator_Java_表達式引擎

本文轉載自查看原文 2021-11-23 09:51 1234 JAVA/ Aviator

簡介

前言

最近項目業務中有關於價格計算的模塊，項目用到這個東西，感覺很方便和靈活，特地看了一下官方文檔。

官方文檔地址如下：

點擊跳轉官方最新文檔地址

參照博客地址：

博客地址

軟件簡介

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

備注：版本5之前都叫Aviator, 5版本重大升級改名 AviatorScript,詳情請看官方文檔介紹。

Aviator是一個高性能、輕量級的java語言實現的表達式求值引擎，主要用於各種表達式的動態求值。現在已經有很多開源可用的java表達式求值引擎，為什么還需要Avaitor呢？

Aviator的設計目標是輕量級和高性能 ，相比於Groovy、JRuby的笨重，Aviator非常小，加上依賴包也才450K,不算依賴包的話只有70K；當然，Aviator的語法是受限的，它不是一門完整的語言，而只是語言的一小部分集合。

其次，Aviator的實現思路與其他輕量級的求值器很不相同，其他求值器一般都是通過解釋的方式運行，而Aviator則是直接將表達式編譯成Java字節碼，交給JVM去執行。簡單來說，Aviator的定位是介於Groovy這樣的重量級腳本語言和IKExpression這樣的輕量級表達式引擎之間。

特性介紹

Aviator的特性

支持大部分運算操作符，包括算術操作符、關系運算符、邏輯操作符、正則匹配操作符(=~)、三元表達式?: ，並且支持操作符的優先級和括號強制優先級，具體請看后面的操作符列表。
支持函數調用和自定義函數
支持正則表達式匹配，類似Ruby、Perl的匹配語法，並且支持類Ruby的$digit指向匹配分組。
自動類型轉換，當執行操作的時候，會自動判斷操作數類型並做相應轉換，無法轉換即拋異常。
支持傳入變量，支持類似a.b.c的嵌套變量訪問。
性能優秀

Aviator的限制：

沒有if else、do while等語句，沒有賦值語句，僅支持邏輯表達式、算術表達式、三元表達式和正則匹配。
沒有位運算符

使用場景包括：

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

整體結構

Aviator的結構非常簡單，一個典型的求值器的結構

Demo

創建項目

創建一個空的Maven項目
導入以下依賴

        <!--表達式求值引擎-->
        <dependency>
            <groupId>com.googlecode.aviator</groupId>
            <artifactId>aviator</artifactId>
            <version>5.1.4</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>compile</scope>
        </dependency>

執行表達式

Aviator的使用都是集中通過com.googlecode.aviator.AviatorEvaluator這個入口類來處理，最簡單的例子，執行一個計算1+2+3的表達式：

    /**
     * 計算1+2+3
     */
    @Test
    public void test01() {
        Long result = (Long) AviatorEvaluator.execute("1+2+3");
        System.out.println("result = " + result);//6
    }

細心的朋友肯定注意到結果是Long，而不是Integer。這是因為Aviator的數值類型僅支持Long和Double，任何整數都將轉換成Long，任何浮點數都將轉換為Double，包括用戶傳入的變量數值。這個例子的打印結果將是正確答案6。

使用變量

想讓Aviator對你say hello嗎？很簡單，傳入你的名字，讓Aviator負責字符串的相加：

    /**
     * 測試使用變量
     */
    @Test
    public void test02() {
        String yourName = "will";
        Map<String, Object> env = new HashMap<String, Object>();
        env.put("yourName", yourName);
        String result = (String) AviatorEvaluator.execute(" 'hello ' + yourName ", env);
        System.out.println(result);//hello will
    }

上面的例子演示了怎么向表達式傳入變量值，表達式中的yourname是一個變量，默認為null，通過傳入Map<String,Object>的變量綁定環境，將yourname設置為你輸入的名稱。env的key是變量名，value是變量的值。

上面例子中的'hello '是一個Aviator的String，Aviator的String是任何用單引號或者雙引號括起來的字符序列，String可以比較大小（基於unicode順序），可以參與正則匹配，可以與任何對象相加，任何對象與String相加結果為String。String中也可以有轉義字符，如/n、//、/'等。

AviatorEvaluator.execute(" 'a\\"b' ");   //字符串 a'b 
AviatorEvaluator.execute(" \\"a\\"b ");  //字符串 a"b 
AviatorEvaluator.execute(" 'hello' + 3 ");  //字符串 hello 3 
AviatorEvaluator.execute(" 'hello '+ unknow ");  //字符串 hello null

調用函數

Aviator支持函數調用，函數調用的風格類似lua，下面的例子獲取字符串的長度：

AviatorEvaluator.execute("string.length('hello')");

string.length('hello')是一個函數調用，string.length是一個函數,'hello'是調用的參數。

再用string.substring來截取字符串：

AviatorEvaluator.execute("string.contains(/"test/",string.substring('hello',1,2))");

通過string.substring('hello',1,2)獲取字符串'e'，然后通過函數string.contains判斷e是否在'test'中。可以看到，函數可以嵌套調用。

完整代碼：

    /**
     * 調用函數
     */
    @Test
    public void test03() {
        Long strLen = (Long) AviatorEvaluator.execute("string.length('hello will')");
        System.out.println("strLen = " + strLen); // 10
        Boolean strContainsFlag = (Boolean) AviatorEvaluator.execute("string.contains('test',string.substring('hello',1,2))");
        System.out.println("strContainsFlag = " + strContainsFlag);
    }

Aviator的內置函數列表請看后面。

自定義函數

Aviator除了內置的函數之外，還允許用戶自定義函數，只要實現com.googlecode.aviator.runtime.type.AviatorFunction接口，並注冊到AviatorEvaluator即可使用。

接口信息如下：

可以看一個例子，我們實現一個add函數來做數值的相加：

先創建一個類實現AbstractFunction

package com.bossyang.demo.aviator;

import com.googlecode.aviator.runtime.function.AbstractFunction;
import com.googlecode.aviator.runtime.function.FunctionUtils;
import com.googlecode.aviator.runtime.type.AviatorDouble;
import com.googlecode.aviator.runtime.type.AviatorObject;

import java.util.Map;

/**
 * @ClassName MyAddFunction
 * @Description 自定義實現增加方法
 * @Author will
 * @Date 2020/11/1 8:05 PM
 */
public class MyAddFunction extends AbstractFunction {

    @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());
    }
    public String getName() {
        return "add";
    }
}

注冊到AviatorEvaluator並調用如下：

    /**
     * 使用自定義函數
     */
    @Test
    public void test04() {
        //注冊函數
        AviatorEvaluator.addFunction(new MyAddFunction());
        System.out.println(AviatorEvaluator.execute("add(1,2)")); //3.0
        System.out.println(AviatorEvaluator.execute("add(add(1,2),100)")); //103.0
    }

注冊函數通過AviatorEvaluator.addFunction方法，移除可以通過removeFunction。

編譯表達式

上面提到的例子都是直接執行表達式，事實上Aviator背后都幫你做了編譯並執行的工作。你可以自己先編譯表達式，返回一個編譯的結果，然后傳入不同的env來復用編譯結果，提高性能，這是更推薦的使用方式：

    //使用編譯表達式
    @Test
    public void test05() {
        String expression = "a-(b-c)>100";
        // 編譯表達式
        Expression compiledExp = AviatorEvaluator.compile(expression);

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

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

通過compile方法可以將表達式編譯成Expression的中間對象，當要執行表達式的時候傳入env並調用Expression的execute方法即可。表達式中使用了括號來強制優先級，這個例子還使用了>用於比較數值大小，比較運算符!=、==、>、>=、<、<=不僅可以用於數值，也可以用於String、Pattern、Boolean等等，甚至是任何用戶傳入的兩個都實現了java.lang。Comparable接口的對象之間。

編譯后的結果你可以自己緩存，也可以交給Aviator幫你緩存，AviatorEvaluator內部有一個全局的緩存池，如果你決定緩存編譯結果，可以通過：

   public static Expression compile(String expression, boolean cached)

將cached設置為true即可，那么下次編譯同一個表達式的時候將直接返回上一次編譯的結果。使緩存失效通過：

public static void invalidateCache(String expression)

這個方法。

訪問數組和集合

可以通過中括號去訪問數組和java.util.List對象，可以通過map.key訪問java.util.Map中key對應的value，一個例子：

    //操作數組
    @Test
    public void test06() {
        final List<String> list = new ArrayList<String>();
        list.add("hello");
        list.add(" world");

        final int[] array = new int[3];
        array[0] = 0;
        array[1] = 1;
        array[2] = 3;

        final Map<String, Date> map = new HashMap<String, Date>();
        map.put("date", new Date());

        Map<String, Object> env = new HashMap<String, Object>();
        env.put("list", list);
        env.put("array", array);
        env.put("map", map);

        /**
         * hello world/array[0]+array[1]+array[2]=4
         *  today is Sun Nov 01 20:31:32 CST 2020
         */
        System.out.println(AviatorEvaluator.execute(
                "list[0]+list[1]+'/array[0]+array[1]+array[2]='+(array[0]+array[1]+array[2]) +' \n today is '+map.date ", env));
    }

三元操作符

Aviator不提供if else語句，但是提供了三元操作符?:用於條件判斷，使用上與java沒有什么不同：

    //三元運算符
    @Test
    public void test07() {
        int num = 6;
        Map<String, Object> env = new HashMap<String, Object>();
        env.put("a", num);
        String result = (String) AviatorEvaluator.execute("a > 0? 'yes':'no'", env);
        System.out.println(result);//yes
    }

這個例子用來判斷用戶傳入的數字是否是正整數，是的話打印yes。

Aviator的三元表達式對於兩個分支的結果類型並不要求一致，可以是任何類型，這一點與java不同。

正則表達式匹配

Aviator支持類Ruby和Perl風格的表達式匹配運算，通過=~操作符，如下面這個例子匹配email並提取用戶名返回：

    //正則表達式
    @Test
    public void test08(){
        String email = "will2020@qq.com";
        Map<String, Object> env = new HashMap<String, Object>();
        env.put("email", email);
        String username = (String) AviatorEvaluator.execute("email=~/([\\w0-8]+@\\w+[\\.\\w+]+)/ ? $1:'unknow'", env);
        System.out.println(username);//will2020@qq.com
    }

email與正則表達式//(//w0-8+@//w+//.//w++)/通過=~操作符來匹配，結果為一個Boolean類型，因此可以用於三元表達式判斷，匹配成功的時候返回$1，指代正則表達式的分組1，也就是用戶名，否則返回unknown。這個例子將打印killme2008這個用戶名。

Aviator在表達式級別支持正則表達式，通過//括起來的字符序列構成一個正則表達式，正則表達式可以用於匹配（作為=~的右操作數)、比較大小，匹配僅能與字符串進行匹配。匹配成功后，Aviator會自動將匹配成功的分組放入$num的變量中，其中$0指代整個匹配的字符串，而$1表示第一個分組，以此類推。

Aviator的正則表達式規則跟Java完全一樣，因為內部其實就是使用java.util.regex.Pattern做編譯的。

變量的語法糖衣

Aviator有個方便用戶使用變量的語法糖衣，當你要訪問變量a中的某個屬性b，那么你可以通過a.b訪問到，更進一步，a.b.c將訪問變量a的b屬性中的c屬性值，推廣開來也就是說Aviator可以將變量聲明為嵌套訪問的形式，一個例子，Foo類有屬性i、f、date：

package com.bossyang.demo.aviator;

import java.util.Date;

public class Foo {
        int i; 
        float f; 
        Date date = new Date();
 
        public Foo(int i, float f, Date date) { 
            super(); 
            this.i = i; 
            this.f = f; 
            this.date = date; 
        } 
 
        public int getI() { 
            return i; 
        } 
 
        public void setI(int i) { 
            this.i = i; 
        } 
 
        public float getF() { 
            return f; 
        } 
 
        public void setF(float f) { 
            this.f = f; 
        } 
 
        public Date getDate() { 
            return date; 
        } 
 
        public void setDate(Date date) { 
            this.date = date; 
        } 
    }

Foo類符合JavaBean規范，並且是public的，我們執行一個表達式來描述Foo:

    //變量的語法糖
    @Test
    public void test09(){
        Foo foo = new Foo(100, 3.14f, new Date());
        Map<String, Object> env = new HashMap<String, Object>();
        env.put("foo", foo);

        String result =
                (String) AviatorEvaluator.execute(
                        " '[foo i='+ foo.i + ' f='+foo.f+' year='+(foo.date.year+1900)+ ' month='+foo.date.month +']'  ",
                        env);
        //因為獲取的是year調用的是Date對象的getYear方法，而getYear方法默認獲取的是公元元年
        System.out.println(result);//[foo i=100 f=3.14 year=2020 month=10]
    }

細看下表達式：

'[foo i='+ foo.i + ' f='+foo.f+' year='+(foo.date.year+1900)+ ' month='+foo.date.month +']'

可以看到我們通過foo.i和foo.f的方式來訪問foo變量中的i和f屬性，並且通過foo.date.year的方式來訪問foo中date對象的year屬性（其實是getYear方法）。

nil對象

nil是Aviator內置的常量，類似java中的null，表示空的值。nil跟null不同的在於，在java中null只能使用在==、!=的比較運算符，而nil還可以使用>、>=、<、<=等比較運算符。Aviator規定，任何對象都比nil大除了nil本身。用戶傳入的變量如果為null，將自動以nil替代。

    //nil對象
    @Test
    public void test10(){
        System.out.println(AviatorEvaluator.execute("nil == nil")); // true
        System.out.println(AviatorEvaluator.execute("3 > nil")); // true
        System.out.println(AviatorEvaluator.execute(" true!= nil")); // true
        System.out.println(AviatorEvaluator.execute(" '' >nil ")); // true
        System.out.println(AviatorEvaluator.execute(" a == nil ")); // true
    }

nil與String相加的時候，跟java一樣顯示為null

日期比較

Aviator並不支持日期類型，如果要比較日期，你需要將日期寫字符串的形式，並且要求是形如"yyyy-MM-dd HH:mm:ss:SS"的字符串，否則都將報錯。字符串跟java.util.Date比較的時候將自動轉換為Date對象進行比較：

    //日期格式比較
    @Test
    public void test11(){
        Map<String, Object> env = new HashMap<String, Object>();
        final Date date = new Date();
        String dateStr = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SS").format(date);
        env.put("date", date);
        env.put("dateStr", dateStr);

        Boolean result = (Boolean) AviatorEvaluator.execute("date == dateStr", env);
        System.out.println(result); //true

        result = (Boolean) AviatorEvaluator.execute("date > '2009-12-20 00:00:00:00' ", env);
        System.out.println(result);//true

        result = (Boolean) AviatorEvaluator.execute("date < '2200-12-20 00:00:00:00' ", env);
        System.out.println(result);//true

        result = (Boolean) AviatorEvaluator.execute("date == date ", env);
        System.out.println(result);//true
    }

也就是說String除了能跟String比較之外，還能跟nil和date字符串比較。

兩種模式

默認AviatorEvaluator以編譯速度優先：

AviatorEvaluator.setOptimize(AviatorEvaluator.COMPILE);

你可以修改為運行速度優先，這會做更多的編譯優化：

AviatorEvaluator.setOptimize(AviatorEvaluator.EVAL);

語法手冊

下面是Aviator詳細的語法規則定義。

數據類型

Number類型：數字類型，支持兩種類型，分別對應Java的Long和Double，也就是說任何整數都將被轉換為Long，而任何浮點數都將被轉換為Double，包括用戶傳入的數值也是如此轉換。不支持科學計數法，僅支持十進制。如-1、100、2.3等。
String類型：字符串類型，單引號或者雙引號括起來的文本串，如'hello world'，變量如果傳入的是String或者Character也將轉為String類型。
Bool類型：常量true和false，表示真值和假值，與java的Boolean.TRUE和Boolean.False對應。
Pattern類型：類似Ruby、perl的正則表達式，以//括起來的字符串，如//d+/，內部實現為java.util.Pattern。
變量類型：與Java的變量命名規則相同，變量的值由用戶傳入，如"a"、"b"等
nil類型: 常量nil,類似java中的null，但是nil比較特殊，nil不僅可以參與==、!=的比較，也可以參與>、>=、<、<=的比較，Aviator規定任何類型都n大於nil除了nil本身，nil==nil返回true。用戶傳入的變量值如果為null，那么也將作為nil處理，nil打印為null。

操作符

算術運算符

Aviator支持常見的算術運算符，包括+ - * / % 五個二元運算符，和一元運算符"-"。其中 - * / %和一元的"-"僅能作用於Number類型。

"+"不僅能用於Number類型，還可以用於String的相加，或者字符串與其他對象的相加。Aviator規定，任何類型與String相加，結果為String。

邏輯運算符

Avaitor的支持的邏輯運算符包括，一元否定運算符"!"，以及邏輯與的"&&"，邏輯或的"||"。邏輯運算符的操作數只能為Boolean。

關系運算符

Aviator支持的關系運算符包括"<" "<=" ">" ">=" 以及"=="和"!=" 。

&&和||都執行短路規則。

關系運算符可以作用於Number之間、String之間、Pattern之間、Boolean之間、變量之間以及其他類型與nil之間的關系比較，不同類型除了nil之外不能相互比較。

Aviator規定任何對象都比nil大除了nil之外。

匹配運算符

匹配運算符"=~"用於String和Pattern的匹配，它的左操作數必須為String，右操作數必須為Pattern。匹配成功后，Pattern的分組將存於變量$num，num為分組索引。

三元運算符

Aviator沒有提供if else語句，但是提供了三元運算符 "?:"，形式為 bool ? exp1: exp2。其中bool必須為結果為Boolean類型的表達式，而exp1和exp2可以為任何合法的Aviator表達式，並且不要求exp1和exp2返回的結果類型一致。

操作符列表

Aviator支持操作符的優先級，並且允許通過括號來強制優先級，下面是完整的操作符列表，按照優先級從高到低的順序排列：

序號	操作符	結合性	操作數限制
0	() `[` `]`	從左到右	()用於函數調用，`[` `]`用於數組和java.util.List的元素訪問，要求`[`indx`]`中的index必須為整型
1	! -	從右到左	! 能用於Boolean,- 僅能用於Number
2	`*` / %	從左到右	Number之間
3	+ -	從左到右	+ - 都能用於Number之間, + 還能用於String之間，或者String和其他對象
4	< <= > >=	從左到右	Number之間、String之間、Pattern之間、變量之間、其他類型與nil之間
5	== != =~	從左到右	==和!=作用於Number之間、String之間、Pattern之間、變量之間、其他類型與nil之間以及String和java.util.Date之間，=~僅能作用於String和Pattern之間
6	&&	從左到右	Boolean之間，短路
7	`	``\|`	從左到右
8	? :	從右到左	第一個操作數的結果必須為Boolean，第二和第三操作數結果無限制

類型轉換規則

Java的byte short int long都轉化為Long類型，Java的float,double都將轉化為Double類型。Java的char String都將轉化為String。Java的null都將轉為nil。
當兩個操作符都是Double或者都是Long的時候，各自按照Double或者Long的類型執行
當兩個操作符中某一個是Double的時候，另一個操作數也將轉換成Double，按照Double類型執行。
任何類型與String相加，結果為String
任何類型都比nil大，除了nil本身。
nil在打印或者與字符串相加的時候，顯示為null
形如"yyyy-MM-dd HH:mm:ss:SS"的字符串，在與java.util.Date做比較的時候將嘗試轉換成java.util.Date對象比較。
沒有規定的類型轉換操作，除了未知的變量類型之間，都將拋出異常。

常量和變量

true	真值
false	假值
nil	空值
$digit	正則表達式匹配成功后的分組，$0表示匹配的字符串，$1表示第一個分組 etc.

內置函數

函數名稱	說明
sysdate()	返回當前日期對象java.util.Date
rand()	返回一個介於0-1的隨機數，double類型
print(`[`out`]`,obj)	打印對象，如果指定out，向out打印，否則輸出到控制台
println(`[`out`]`,obj)	與print類似，但是在輸出后換行
now()	返回System.currentTimeMillis
string.contains(s1,s2)	判斷s1是否包含s2，返回Boolean
string.length(s)	求字符串長度,返回Long
string.startsWith(s1,s2)	s1是否以s2開始，返回Boolean
string.endsWith(s1,s2)	s1是否以s2結尾,返回Boolean
string.substring(s,begin`[`,end`]`)	截取字符串s，從begin到end，end如果忽略的話，將從begin到結尾，與java.util.String.substring一樣。
math.abs(d)	求d的絕對值
math.sqrt(d)	求d的平方根
math.pow(d1,d2)	求d1的d2次方
math.log(d)	求d的自然對數
math.log10(d)	求d以10為底的對數
math.sin(d)	正弦函數
math.cos(d)	余弦函數
math.tan(d)	正切函數
map(seq,fun)	將函數fun作用到集合seq每個元素上，返回新元素組成的集合
filter(seq,predicate)	將謂詞predicate作用在集合的每個元素上，返回謂詞為true的元素組成的集合
count(seq)	返回集合大小
include(seq,element)	判斷element是否在集合seq中，返回boolean值
sort(seq)	排序集合，僅對數組和List有效，返回排序后的新集合
reduce(seq,fun,init)	fun接收兩個參數，第一個是集合元素，第二個是累積的init，本函數用於將fun作用在集合每個元素和初始值上面，返回最終的init值
seq.eq(value)	返回一個謂詞，用來判斷傳入的參數是否跟value相等,用於filter函數，如filter(seq,seq.eq(3)) 過濾返回等於3的元素組成的集合
seq.neq(value)	與seq.eq類似，返回判斷不等於的謂詞
seq.gt(value)	返回判斷大於value的謂詞
seq.ge(value)	返回判斷大於等於value的謂詞
seq.lt(value)	返回判斷小於value的謂詞
seq.le(value)	返回判斷小於等於value的謂詞
seq.nil()	返回判斷是否為nil的謂詞
seq.exists()	返回判斷不為nil的謂詞

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 Aviator——輕量級Java表達式求值引擎 Aviator和MVEL實現Map過濾（通過動態表達式求值)—Java表達式引擎的使用 Google輕量級的表達式引擎aviator Aviator 表達式求值引擎開源框架幾款不錯的java表達式引擎 AviatorEvaluator表達式引擎 java的表達式基於ε-NFA的正則表達式引擎 qlexpress 另外一個表達式引擎表達式解析引擎的設計