Aviator使用

最新推荐文章于 2022-03-01 11:06:21 发布
最新推荐文章于 2022-03-01 11:06:21 发布
阅读量3.4k 收藏
点赞数 1
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CarrotZsy/article/details/112715727
版权

“初步了解和使用Aviator”

1.Aviator简介

Aviator 是一个高性能，轻量级的java语言实现的表达式求值引擎，主要用于各种表达式的动态求值。

官方文档

github地址

支持数字、字符串、正则表达式、布尔值、正则表达式等基本类型，完整支持所有 Java 运算符及优先级等。
函数是一等公民，支持闭包和函数式编程。
内置 bigint/decmal 类型用于大整数和高精度运算，支持运算符重载得以让这些类型使用普通的算术运算符 ±*/ 参与运算。
完整的脚本语法支持，包括多行数据、条件语句、循环语句、词法作用域和异常处理等。
函数式编程结合 Sequence 抽象，便捷处理任何集合。
轻量化的模块系统。
多种方式，方便地调用 Java 方法，完整支持 Java 脚本 API（方便从 Java 调用脚本）。
丰富的定制选项，可作为安全的语言沙箱和全功能语言使用。
轻量化，高性能，通过直接将脚本翻译成 JVM 字节码，AviatorScript 的基础性能较好。

使用场景包括：

  1. 规则判断及规则引擎
  2. 公式计算
  3. 动态脚本控制
  4. 集合数据 ELT 等 ……

2.Aviator入门常用

这里使用版本为4.2.5

2.1数据类型
  • Number类型: 数字类型,支持四种类型,分别是long,double,java.math.BigInteger(简称 big int)和java.math.BigDecimal(简 称 decimal),规则如下:
    • 任何以大写字母 N 结尾的整数都被认为是 big int
    • 任何以大写字母 M 结尾的数字都被认为是 decimal
    • 其他的任何整数都将被转换为 Long
    • 其他任何浮点数都将被转换为 Double
    • 超过 long 范围的整数字面量都将自动转换为 big int 类型
  • String类型: 字符串类型,单引号或者双引号括起来的文本串,如’hello world’, 变量如果传入的是String或者Character也将转为String类型
  • Bool类型: 常量true和false,表示真值和假值,与 java 的Boolean.TRUE和Boolean.False对应
  • Pattern类型: 正则表达式, 以//括起来的字符串,如/\d+/,内部 实现为java.util.Pattern
  • 变量类型: 与 Java 的变量命名规则相同,变量的值由用户传入
  • nil类型: 常量nil,类似 java 中的null,但是nil比较特殊,nil不仅可以参与==、!=的比较, 也可以参与>、>=、<、<=的比较,Aviator 规定任何类型都大于nil除了nil本身,nil==nil返回true。 用户传入的变量值如果为null,那么也将作为nil处理,nil打印为null
2.2操作符
算术运算符

Aviator 支持常见的算术运算符,包括+ - * / %五个二元运算符,和一元运算符-(负)。其中- * / %和一元的-仅能作用于Number类型。
+不仅能用于Number类型,还可以用于String的相加,或者字符串与其他对象的相加。
Aviator 规定,任何类型与String相加,结果为String。

逻辑运算符

Avaitor 的支持的逻辑运算符包括,一元否定运算符!,以及逻辑与的&&,逻辑或的||。逻辑运算符的操作数只能为Boolean。
&&和||都执行短路规则。

关系运算符

Aviator 支持的关系运算符包括<, <=, >, >=以及==和!= 。
关系运算符可以作用于Number之间、String之间、Pattern之间、Boolean之间、变量之间以及其他类型与nil之间的关系比较, 不同类型除了nil之外不能相互比较。

3.一些简单特性

package aviator;

import com.googlecode.aviator.AviatorEvaluator;
import com.googlecode.aviator.Expression;
import com.googlecode.aviator.runtime.function.AbstractFunction;
import com.googlecode.aviator.runtime.function.AbstractVariadicFunction;
import com.googlecode.aviator.runtime.function.FunctionUtils;
import com.googlecode.aviator.runtime.type.AviatorDouble;
import com.googlecode.aviator.runtime.type.AviatorObject;
import com.googlecode.aviator.runtime.type.AviatorString;

import java.util.HashMap;
import java.util.Map;

/**
 * @author zousy
 * @version v1.0
 * @Description
 * @date 2021-01-16 15:39
 */
public class App {
    public static void main(String[] args) {
        //执行表达式 Aviator的数值类型仅支持Long和Double, 任何整数都将转换成Long,
        // 任何浮点数都将转换为Double, 包括用户传入的变量数值
        Object execute = AviatorEvaluator.execute("1+1+2");
        System.out.println(execute.toString() + execute.getClass().getSimpleName());
        Object execute1 = AviatorEvaluator.execute("2.3+3.0");
        System.out.println(execute1.toString() + execute1.getClass().getSimpleName());

        //内置函数和 多行表达式 使用; 隔开
        Expression compile = AviatorEvaluator.getInstance().compile("println('Hello, AviatorScript!'); 1+2");
        Object res = compile.execute();
        System.out.println(res.toString());

        //使用变量
        Map<String, Object> env = new HashMap<String, Object>();
        env.put("name","zsad");
        String execute2 = (String) AviatorEvaluator.execute(" 'hello' + name", env);
        System.out.println(execute2);

        //支持函数调用
        Object execute3 = AviatorEvaluator.execute("string.length('hello')");
        System.out.println(execute3.toString());


        //支持通过 lambda 关键字定义一个匿名函数，并且支持闭包捕获
        //lambda (参数1,参数2...) -> 参数体表达式 end
        env.put("x",1);
        env.put("y",10);
        Object execute4 = AviatorEvaluator.execute("(lambda (x,y) -> x + y end)(x,y)", env);
        System.out.println(execute4.toString());

        //支持自定义函数
        AviatorEvaluator.addFunction(new AddFunction());
        AviatorEvaluator.addFunction(new GetFirstNonNullFunction());
        env.put("a",12);
        env.put("v",13);

        //参数确定 自定义函数
        System.out.println(AviatorEvaluator.execute("add(1,33)").toString());
        //参数不确定自定义函数
        System.out.println(AviatorEvaluator.execute("getFirstNonNull(a,v,bas,asf)",env));
        //lambda表达式 自定义函数
        AviatorEvaluator.defineFunction("sub","lambda (a,b) -> a - b end");
        System.out.println(AviatorEvaluator.execute("sub(12,13)").toString());
        //lambda表达式支持闭包 自定义函数  ? 按照官方写 会报错  存疑
        AviatorEvaluator.defineFunction("sub2","lambda (a) -> lambda (b) -> a - b end end");
        System.out.println(AviatorEvaluator.execute("sub2(12)(14)").toString());

    }

    //参数确定 继承 AbstractFunction
    static class AddFunction 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());
        }

        //函数名 add
        @Override
        public String getName() {
            return "add";
        }
    }

    //参数不确定 继承 AbstractVariadicFunction
    static class GetFirstNonNullFunction extends AbstractVariadicFunction {

        @Override
        public AviatorObject variadicCall(Map<String, Object> env, AviatorObject... args) {
            if (args != null) {
                for (AviatorObject arg : args) {
                    if (arg.getValue(env) != null) {
                        return arg;
                    }
                }
            }
            return new AviatorString(null);
        }


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

    }
}

运行结果
在这里插入图片描述

4.官方函数例子(官方代码)

package aviator.example;

import com.googlecode.aviator.AviatorEvaluator;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

/**
 * @author zousy
 * @version v1.0
 * @Description
 * @date 2021-01-18 15:59
 */
public class FunctionExample {
    public static void main(String[] args) {
        System.out.println(AviatorEvaluator.execute("sysdate()"));
        System.out.println(AviatorEvaluator.execute("rand()"));
        System.out.println(AviatorEvaluator.execute("now()"));
        System.out.println(AviatorEvaluator.execute("date_to_string(sysdate(),'yyyy-MM-dd')"));
        System.out.println(AviatorEvaluator
                .execute("string_to_date(date_to_string(sysdate(),'yyyy-MM-dd'),'yyyy-MM-dd')"));

        // string function
        System.out.println("test string function...");
        System.out.println(AviatorEvaluator.execute("string.length('hello')"));
        System.out.println(AviatorEvaluator.execute("string.contains('hello','h')"));
        System.out.println(AviatorEvaluator.execute("string.startsWith('hello','h')"));
        System.out.println(AviatorEvaluator.execute("string.endsWith('hello','llo')"));
        System.out.println(
                AviatorEvaluator.execute("string.contains(\"test\",string.substring('hello',1,2))"));
        System.out.println(Arrays
                .toString((String[]) AviatorEvaluator.execute("string.split('hello world,aviator',' ')")));

        // math function
        System.out.println("test math function...");
        System.out.println(AviatorEvaluator.execute("math.abs(-3)"));
        System.out.println(AviatorEvaluator.execute("math.pow(-3,2)"));
        System.out.println(AviatorEvaluator.execute("math.sqrt(14.0)"));
        System.out.println(AviatorEvaluator.execute("math.log(100)"));
        System.out.println(AviatorEvaluator.execute("math.log10(1000)"));
        System.out.println(AviatorEvaluator.execute("math.sin(20)"));
        System.out.println(AviatorEvaluator.execute("math.cos(99.23)"));
        System.out.println(AviatorEvaluator.execute("math.tan(19.9)"));

        // seq lib
        Map<String, Object> env = new HashMap<String, Object>();
        ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(3);
        list.add(100);
        list.add(-100);
        env.put("list", list);
        System.out.println(AviatorEvaluator.execute("reduce(list,+,0)", env));
        System.out.println(AviatorEvaluator.execute("filter(list,seq.exists())", env));
        System.out.println(AviatorEvaluator.execute("count(list)", env));
        System.out.println(AviatorEvaluator.execute("include(list,100)", env));
        System.out.println(AviatorEvaluator.execute("sort(list)", env));
        System.out.println(AviatorEvaluator.execute("map(list,println)", env));
        System.out.println(list);
    }
}

运行结果

运行结果

5.支持大数据操作

package aviator.example;

import com.googlecode.aviator.AviatorEvaluator;
import com.googlecode.aviator.Options;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.MathContext;
import java.util.HashMap;
import java.util.Map;

/**
 * @author zousy
 * @version v1.0
 * @Description
 * @date 2021-01-18 16:10
 */
public class BigNumberExample {
    //以大写字母N为后缀的整数都被认为是big int,如1N,2N,9999999999999999999999N等, 都是big int类型。
    //超过long范围的整数字面量都将自动转换为big int类型。
    //以大写字母M为后缀的数字都被认为是decimal, 如1M,2.222M, 100000.9999M等, 都是decimal类型。
    //big int和decimal的运算,跟其他数字类型long,double没有什么区别,操作符仍然是一样的。
    // aviator重载了基本算术操作符来支持这两种新类型:
    public static void main(String[] args) {
        Object rt = AviatorEvaluator.execute("9223372036854775807100.356M * 2");
        System.out.println(rt + "  " + rt.getClass());

        rt = AviatorEvaluator.execute("92233720368547758074+1000");
        System.out.println(rt + "  " + rt.getClass());

        BigInteger a = new BigInteger(String.valueOf(Long.MAX_VALUE) + String.valueOf(Long.MAX_VALUE));
        BigDecimal b = new BigDecimal("3.2");
        BigDecimal c = new BigDecimal("9999.99999");

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

        rt = AviatorEvaluator.execute("a+10000000000000000000", env);
        System.out.println(rt + "  " + rt.getClass());

        rt = AviatorEvaluator.execute("b+c*2", env);
        System.out.println(rt + "  " + rt.getClass());

        rt = AviatorEvaluator.execute("a*b/c", env);
        System.out.println(rt + "  " + rt.getClass());

        // set math context
        AviatorEvaluator.setOption(Options.MATH_CONTEXT, MathContext.DECIMAL64);
        rt = AviatorEvaluator.execute("a*b/c", env);
        System.out.println(rt + "  " + rt.getClass());
    }
}

运行结果
运行结果

6.正则表达式匹配

package aviator.example;

import com.googlecode.aviator.AviatorEvaluator;

import java.util.HashMap;
import java.util.Map;

/**
 * @author zousy
 * @version v1.0
 * @Description
 * @date 2021-01-18 16:40
 */
public class RegularExpressionExample {
    //email与正则表达式/([\\w0-8]+@\\w+[\\.\\w+]+)/通过=~操作符来匹配,结果为一个 Boolean 类 型,
    // 因此可以用于三元表达式判断,匹配成功的时候返回$1,指代正则表达式的分组 1,也就是用户名,否则返回unknown。
    //Aviator 在表达式级别支持正则表达式,通过//括起来的字符序列构成一个正则表达式,
    // 正则表达式可以用于匹配(作为=~的右操作数)、比较大小。但是匹配仅能与字符串进行匹配。
    // 匹配成功后, Aviator 会自动将匹配成功的捕获分组(capturing groups) 放入 env ${num}的变量中,
    // 其中$0 指代整个匹配的字符串,而$1表示第一个分组，$2表示第二个分组以此类推。
    //请注意，分组捕获放入 env 是默认开启的，因此如果传入的 env 不是线程安全并且被并发使用，可能存在线程安全的隐患。
    // 关闭分组匹配，可以通过 AviatorEvaluator.setOption(Options.PUT_CAPTURING_GROUPS_INTO_ENV, false);来关闭，对性能有稍许好处。
    //Aviator 的正则表达式规则跟 Java 完全一样,因为内部其实就是使用java.util.regex.Pattern做编译的。
    public static void main(final String[] args) {
        String email = "killme2008@gmail.com";
        Map<String, Object> env = new HashMap<>();
        env.put("email", email);
        String username =
                (String) AviatorEvaluator.execute("email=~/([\\w0-8]+)@\\w+[\\.\\w+]+/ ? $1:'unknow'", env);
        System.out.println(username);
    }
}

运行结果
运行结果

小舟~
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
CSharp_入门教程
08-30
vc2003使用入门级教程，希望对你有用
Csharp基础教程
09-06
Csharp基础教程 适合初学者 C#是微软公司发布的一种面向对象的、运行于.NET Framework之上的高级程序设计语言。并定于在微软职业开发者论坛(PDC)上登台亮相。C#是微软公司研究员Anders Hejlsberg的最新成果。C#看起来与Java有着惊人的相似；它包括了诸如单一继承、接口、与Java几乎同样的语法和编译成中间代码再运行的过程。但是C#与Java有着明显的不同，它借鉴了Delphi的一个特点，与COM（组件对象模型）是直接集成的，而且它是微软公司 .NET windows网络框架的主角。
表达式引擎Aviator基本介绍及使用以及基于Aviator的规则引擎（附代码详细介绍）
弹弹霹雳的博客
07-18 2万+
1. Avaitor 1.1 什么是Avaitor? Aviator是一门高性能、轻量级的Java语言实现的表达式求值引擎，主要用于表达式的动态求值。 1.2 为什么需要Avaitor? Aviator的设计目标是 轻量级 和 高性能 ，相对于Groovy、JRuby的笨重，Aviator非常小，加上依赖包就450K，不算依赖包就70K，不过Aviator的语法受限，它并不是一门完整的语言，只是语言的一小部分集合。 1.3 Avaitor的特点 Aviator的实现思路与其它轻量级的求值器不同，其它求值器是
C#(Csharp)基础教程(上)(菜鸟教程笔记)
热门推荐
sally的jerry
11-02 22万+
目录1. C# 及其开发环境简介1.1 C# 概述1.2 C# 的编程功能1.3 C# 与.Net的关系1.3.1 .Net1.3.2 C#1.4 C# 的集成开发环境（Integrated Development Environment - IDE）1.4.1 Windows上编写 C# 程序1.4.2 Linux / Mac OS 上编写 C# 程序2. C# 程序结构 1. C# 及其开发环境简介 1.1 C# 概述 C# 是一个现代的、通用的、面向对象的编程语言，它是由微软（Microsoft）开发
C#(Csharp)基础教程(中)(菜鸟教程笔记)
sally的jerry
11-05 2万+
前置博客为：C#(Csharp)基础教程(上)(菜鸟教程笔记) 内容包括：C#概述及开发环境简介、C# 程序结构、C# 基本语法、C# 数据类型、类型转换、变量、常量、运算符。 目录1. C# 判断2. C# 循环3. C# 封装4. C# 方法5. C# 可空类型（Nullable）6. C# 数组（Array）7. C# 字符串（String）8. C# 结构体（Struct）9. C# 枚举（Enum） 1. C# 判断 2. C# 循环 3. C# 封装 4. C# 方法 5. C# 可空类型（.
C#教程
weixin_33729196的博客
12-13 256
C#教程 C# 简介 C# 环境 C# 程序结构 C# 基本语法 C# 数据类型 C# 类型转换 C# 变量 C# 常量 C# 运算符 C# 判断 C# 循环 C# 封装 C# 方法 C# 可空类型 C# 数组（Array） C# 字符串（String） C# 结构（Struct） C# 枚举（Enum） C# 类（Cl...
aviator 表达式解析
04-03
aviator 表达式解析 aviator 表达式解析 aviator 表达式解析
aviator-4.1.2.jar
09-11
Aviator——轻量级Java表达式求值引擎，这个是下载下来的jar包，版本是4.1.2
Aviator 2.3.0
09-15
开源轻量级、高性能的表达式求值器 Aviator 2.3.0 包含Aviator-2.3.0用户指南，aviator-2.3.2-bin-with-dependencies等
aviator-master.zip
09-21
主要是Google放开的java源码，针对java的自定义的表达式实现，比如说实现￥￥￥&&&||||与逻辑或的实现源码，1、进行表达式解析，获取里面的单引号参数，然后解析成表达式入参，2、逻辑运算的加减乘除的实现逻辑，...
csharp 入门教程
05-20
很容易入门，是绝好的东西。这个完全是个人的心得体会，比书要好用的多。
C-sharp-入门教程
06-18
C-sharp-教程
c sharp初级教程.rar
10-10
本来是一分都不要的，但是现在只少都得设置为一分，我们上传资料本来是本着共享的原则的，他们的这种行径非常恶劣
C#教程.pdf
02-27
C#教程.pdf
c#教程文件，c#教程文件，c#教程文件，
12-30
需要课程
demo:使用 Aviator gem 的演示应用程序
07-07
这个项目演示了如何使用 Aviator。 安装 虚拟机 Ruby 版本管理器是一个很好的工具，可以轻松管理您机器中的多个 Ruby 版本。 使用以下命令安装它： curl -L https://get.rvm.io | bash -s stable --ruby=1.9.3 ...
C# 教程
W_H_M_2018的博客
12-02 601
C#教程 C# 是一个简单的、现代的、通用的、面向对象的编程语言，它是由微软（Microsoft）开发的。 本教程将告诉您基础的 C# 编程，同时将向您讲解 C# 编程语言相关的各种先进理念。 现在开始学习 C#！ C# 在线工具 谁适合阅读本教程？ 本教程有助于初学者理解基础的 C# 编程。在学习完本教程后，您将到达一个中级的 C# 编程水平。 阅读本教程前，您需要了解的知识： C# 编程是基于 C 和 C++ 编程语言的，因此如果您对 C 和 C++ 编程有基本的了解，将有助于您..
C sharp学习（一）
nwly______的博客
03-01 1452
1.以.cs结尾的称为类文件 2.解决方案&项目&类之间的关系 解决方案：公司 项目：部门 类：员工 （1）如果想在同一个解决方案里新建项目，直接右键解决方案 （2）如果想在一个项目里添加类，直接右键项目 3.初步认识代码 ...
java 使用 aviator自定义sum函数
最新发布
06-13
Aviator是一个表达式求值引擎，它支持自定义函数的定义和使用。下面是一个使用Aviator自定义sum函数的Java示例代码： ```java import com.googlecode.aviator.AviatorEvaluator; import com.googlecode.aviator.runtime.type.AviatorDecimal; public class AviatorSumFunctionDemo { public static void main(String[] args) { // 注册函数 AviatorEvaluator.addFunction(new SumFunction()); // 执行表达式 String expression = "sum(1, 2, 3, 4)"; Object result = AviatorEvaluator.execute(expression); System.out.println(result); // 输出10 } // 自定义sum函数 static class SumFunction extends com.googlecode.aviator.runtime.type.AviatorFunction { @Override public String getName() { return "sum"; } @Override public AviatorDecimal call(Map<String, Object> env, AviatorObject... args) { double sum = 0; for (AviatorObject arg : args) { sum += (double) arg.getValue(env); } return AviatorDecimal.valueOf(sum); } } } ``` 在上面的示例代码中，我们首先通过AviatorEvaluator的addFunction方法注册了自定义的sum函数，然后执行了一个表达式"sum(1, 2, 3, 4)"，得到了结果10。 自定义函数需要继承com.googlecode.aviator.runtime.type.AviatorFunction类，并实现getName和call方法。getName方法返回函数的名称，call方法实现函数的具体逻辑。在call方法中，我们通过AviatorObject的getValue方法获取函数参数的值，并将它们相加，最后返回一个AviatorDecimal类型的结果。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值