Aviator

簡介¶

Aviator是一個高性能、輕量級的java語言實現的表達式求值引擎，主要用於各類表達式的動態求值。如今已經有不少開源可用的java表達式求值引擎，爲何還須要Avaitor呢？java

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

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

特性¶

Aviator的特性express

支持大部分運算操做符，包括算術操做符、關係運算符、邏輯操做符、正則匹配操做符(=~)、三元表達式?: ，而且支持操做符的優先級和括號強制優先級，具體請看後面的操做符列表。apache

支持函數調用和自定義函數數組

支持正則表達式匹配，相似Ruby、Perl的匹配語法，而且支持類Ruby的$digit指向匹配分組。緩存
自動類型轉換，當執行操做的時候，會自動判斷操做數類型並作相應轉換，沒法轉換即拋異常。ide
支持傳入變量，支持相似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 = "killme2008@gmail.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); 
    } 
}

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，包括用戶傳入的數值也是如此轉換。不支持科學計數法，僅支持十進制。如-一、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的謂詞