表達式運算

Aviator 表達式求值引擎開源框架

簡介¶

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等語句，沒有賦值語句，僅支持邏輯表達式、算術表達式、三元表達式和正則匹配。

• 沒有位運算符

整體結構¶

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

依賴包¶

commons-beanutils和commons-logging

使用手冊¶

執行表達式¶

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

import com.googlecode.aviator.AviatorEvaluator; 
public class SimpleExample { 
    public static void main(String[] args) { 
        Long result = (Long) AviatorEvaluator.execute("1+2+3"); 
        System.out.println(result); 
    } 
}

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

使用變量¶

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

import com.googlecode.aviator.AviatorEvaluator; 
 
 
public class SayHello { 
    public static void main(String[] args) { 
        if (args.length < 1) { 
            System.err.print("Usesage: Java SayHello yourname"); 
        } 
        String yourname = args[0]; 
        Map<String, Object> env = new HashMap<String, Object>(); 
        env.put("yourname", yourname); 
        String result = (String) AviatorEvaluator.execute(" 'hello ' + yourname ", env); 
        System.out.println(result); 
    } 
}

上面的例子演示了怎麼向表達式傳入變量值，表達式中的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'中。可以看到，函數可以嵌套調用。

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

自定義函數¶

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

public interface AviatorFunction { 
    /** 
     * Get the function name 
     *  
     * @return 
     */ 
    public String getName(); 
 
 
    /** 
     * call function 
     *  
     * @param env 
     *            Variable environment 
     * @param args 
     *            Function arguments 
     * @return 
     */ 
    public AviatorObject call(Map<String, Object> env, AviatorObject... args); 
}

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

  import com.googlecode.aviator.runtime.function.FunctionUtils; 
  import com.googlecode.aviator.runtime.type.AviatorDouble; 
  import com.googlecode.aviator.runtime.type.AviatorFunction; 
  import com.googlecode.aviator.runtime.type.AviatorObject; 
  public class AddFunction implements AviatorFunction { 
 
        public AviatorObject call(Map<String, Object> env, AviatorObject... args) { 
            if (args.length != 2) { 
                throw new IllegalArgumentException("Add only supports two arguments"); 
            } 
            Number left = FunctionUtils.getNumberValue(0, args, env); 
            Number right = FunctionUtils.getNumberValue(1, args, env); 
            return new AviatorDouble(left.doubleValue() + right.doubleValue()); 
        } 
 
 
        public String getName() { 
            return "add"; 
        } 
 
    }

註冊到AviatorEvaluator並調用如下：

        //註冊函數 
        AviatorEvaluator.addFunction(new AddFunction()); 
        System.out.println(AviatorEvaluator.execute("add(1,2)")); 
        System.out.println(AviatorEvaluator.execute("add(add(1,2),100)"));

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

編譯表達式¶

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

import java.util.HashMap; 
import java.util.Map; 
 
import com.googlecode.aviator.AviatorEvaluator; 
import com.googlecode.aviator.Expression; 
 
public class CompileExample { 
    public static void main(String[] args) { 
        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); 
    } 
}

通過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，一個例子：

import java.util.ArrayList; 
import java.util.Date; 
import java.util.HashMap; 
import java.util.List; 
import java.util.Map; 
 
import com.googlecode.aviator.AviatorEvaluator; 
 
 
public class CollectionExample { 
    public static void main(String[] args) { 
        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("mmap", map); 
 
        System.out.println(AviatorEvaluator.execute( 
            "list[0]+list[1]+'/narray[0]+array[1]+array[2]='+(array[0]+array[1]+array[2]) +' /ntoday is '+mmap.date ", env)); 
    } 
}

三元操作符¶

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

import java.util.HashMap; 
import java.util.Map; 
 
import com.googlecode.aviator.AviatorEvaluator; 
 
 
public class TernaryOperatorExample { 
    public static void main(String[] args) { 
        if (args.length < 1) { 
            System.err.println("Usage: java TernaryOperatorExample [number]"); 
            System.exit(1); 
        } 
        int num = Integer.parseInt(args[0]); 
        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。

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

正則表達式匹配¶

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

import java.util.HashMap; 
import java.util.Map; 
 
import com.googlecode.aviator.AviatorEvaluator; 
 
public class RegularExpressionExample { 
    public static void main(String[] args) { 
        String email = "[email protected]"; 
        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); 
    } 
}

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：

 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:

import java.util.Date; 
import java.util.HashMap; 
import java.util.Map; 
 
import com.googlecode.aviator.AviatorEvaluator; 
 
public class VariableExample { 
    public static void main(String[] args) { 
        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); 
        System.out.println(result); 
 
    } 
}

細看下錶達式：

'[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替代。

        AviatorEvaluator.execute("nil == nil");  //true 
        AviatorEvaluator.execute(" 3> nil");    //true 
        AviatorEvaluator.execute(" true!= nil");    //true 
        AviatorEvaluator.execute(" ' '>nil ");  //true 
        AviatorEvaluator.execute(" a==nil ");   //true,a is null

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

日期比較¶

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

import java.text.SimpleDateFormat; 
import java.util.Date; 
import java.util.HashMap; 
import java.util.Map; 
 
import com.googlecode.aviator.AviatorEvaluator; 
 
 
public class DateExample { 
    public static void main(String[] args) throws Exception { 
        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); 
 
        result = (Boolean) AviatorEvaluator.execute("date > '2009-12-20 00:00:00:00' ", env); 
        System.out.println(result); 
 
        result = (Boolean) AviatorEvaluator.execute("date < '2200-12-20 00:00:00:00' ", env); 
        System.out.println(result); 
 
        result = (Boolean) AviatorEvaluator.execute("date ==date ", env); 
        System.out.println(result); 
    } 
 
}

也就是說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	||	從左到右	Boolean之間，短路
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的謂詞