QLExpress学习使用总结

官网学习地址：https://github.com/alibaba/QLExpress

一、基本介绍

（一）快速了解

QLExpress（Quick Language Express）是阿里巴巴开源的一门动态脚本引擎解析工具，起源于阿里巴巴的电商业务，旨在解决业务规则、表达式、数学计算等动态脚本的解析问题。其具有以下基本特点：

1. 线程安全：QLExpress被设计为线程安全的动态脚本引擎，它使用threadlocal类型的临时变量，确保在引擎运算过程中的并发场景下的线程安全性。

2. 高效执行：为了提高执行效率，QLExpress在编译过程中可以将比较耗时的脚本编译结果缓存到本地机器。此外，运行时的临时变量创建采用了缓冲池技术，以确保高效的运行时性能，使其与一些性能优秀的脚本引擎（如Groovy）相当。

3. 弱类型脚本语言：QLExpress采用弱类型脚本语言，语法类似于Groovy和JavaScript。这使得业务规则的表达更加灵活，虽然相对于强类型脚本语言可能略慢，但在业务的灵活性方面提供了很大的优势。

4. 安全控制：QLExpress提供了一些运行时参数的设置，以进行安全控制。通过这些参数，可以预防一些潜在的安全问题，如死循环或对高危系统API的调用。

5. 代码精简、依赖最小：QLExpress的设计追求代码的精简和最小依赖，其jar包大小为250k，适用于所有Java的运行环境。这使得它在各种环境中都能轻松部署和运行，包括在Android系统的低端POS机上广泛应用。

总体而言，这些特性使QLExpress成为一个在阿里电商业务场景中得到广泛应用的强大工具，具有高效、灵活和安全的特点。

（二）与常用规则引擎对比

Drools适用于复杂的业务规则，而Aviator和QLExpress适用于相对简单的表达式计算和规则。EasyRule更适合简单规则场景，特别是面向非专业开发人员的情况。最终选择取决于具体需求，包括业务规则的复杂性、性能要求、开发人员技能水平以及项目的特定场景。

（三）引用说明与基本展示

在 Maven 项目中引入 QLExpress，需要在项目的 pom.xml 文件中添加相关的依赖：

    
        com.ql
        qlExpress
        3.2.2 
    

以下展示简单演示如何使用 QLExpress 计算折扣后的金额。在实际项目中，可能需要更复杂的脚本和上下文，以适应业务需求。

package org.zyf.javabasic.qlexpress;
 
import com.ql.util.express.DefaultContext;
import com.ql.util.express.ExpressRunner;
 
/**
 * @program: zyfboot-javabasic
 * @description: 演示如何使用 QLExpress 计算折扣后的金额
 * @author: zhangyanfeng
 * @create: 2023-11-12 21:40
 **/
public class QLExpressExample {
    public static void main(String[] args) {
        try {
            // 创建 QLExpress 引擎
            ExpressRunner runner = new ExpressRunner();
 
            // 创建上下文并设置变量
            DefaultContext context = new DefaultContext<>();
            context.put("amount", 1000);
            context.put("discount", 0.1);
 
            // 执行脚本
            String expression = "amount * (1 - discount)";
            Object result = runner.execute(expression, context, null, true, false);
 
            // 输出结果
            System.out.println("Result: " + result);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

二、基本语法学习

（一）操作符

QLExpress 支持一系列操作符，包括算术运算符、比较运算符、逻辑运算符等。

定义一个 Calculator 类，其中包含一些数字和一个用户对象，然后使用 QLExpress 进行一些简单的运算和条件判断。

package org.zyf.javabasic.qlexpress;
 
import com.ql.util.express.DefaultContext;
import com.ql.util.express.ExpressRunner;
 
/**
 * @program: zyfboot-javabasic
 * @description: 一些简单的运算和条件判断
 * @author: zhangyanfeng
 * @create: 2023-11-12 21:48
 **/
public class Calculator {
    public static void main(String[] args) {
        try {
            ExpressRunner runner = new ExpressRunner();
            DefaultContext context = new DefaultContext<>();
 
            // 设置变量
            context.put("a", 10);
            context.put("b", 5);
 
            // 算术运算示例
            executeAndPrint(runner, context, "a + b", "Addition");
 
            // 比较运算示例
            executeAndPrint(runner, context, "a > b", "Greater than");
 
            // 逻辑运算示例
            executeAndPrint(runner, context, "a > 0 && b > 0", "Logical AND");
 
            // 三元运算示例
            executeAndPrint(runner, context, "a > b ? 'a is greater' : 'b is greater'", "Ternary Operator");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
    private static void executeAndPrint(ExpressRunner runner, DefaultContext context, String expression, String operation) throws Exception {
        // 执行脚本
        Object result = runner.execute(expression, context, null, true, false);
 
        // 输出结果
        System.out.println(operation + ": " + result);
    }
}

（二）Java对象操作

基本的 Java 语法和对象操作在 QLExpress 中同样适用,演示在 QLExpress 中使用 Java 语法和进行对象操作：

package org.zyf.javabasic.qlexpress;
 
import com.ql.util.express.DefaultContext;
import com.ql.util.express.ExpressRunner;
 
/**
 * @program: zyfboot-javabasic
 * @description: 基本的 Java 语法和对象操作
 * @author: zhangyanfeng
 * @create: 2023-11-12 21:54
 **/
public class QLExpressJavaSyntaxExample {
    public static void main(String[] args) {
        try {
            ExpressRunner runner = new ExpressRunner();
            DefaultContext context = new DefaultContext<>();
 
            // 创建一个用户对象
            User user = new User("John", 25);
            context.put("user", user);
 
            // 使用 Java 语法访问对象属性和调用方法
            executeAndPrint(runner, context, "user.getName()", "Accessing Object Property");
            executeAndPrint(runner, context, "user.getAge() + 5", "Performing Arithmetic with Object Property");
 
            // 使用 Java 语法进行对象操作
            executeAndPrint(runner, context, "user.age = 30", "Modifying Object Property");
 
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
    private static void executeAndPrint(ExpressRunner runner, DefaultContext context, String expression, String operation) throws Exception {
        // 执行脚本
        Object result = runner.execute(expression, context, null, true, false);
 
        // 输出结果
        System.out.println(operation + ": " + result);
    }
 
    // 用户对象类
    static class User {
        private String name;
        private int age;
 
        public User(String name, int age) {
            this.name = name;
            this.age = age;
        }
 
        public String getName() {
            return name;
        }
 
        public int getAge() {
            return age;
        }
    }
}

（三） 脚本中定义function

在QLExpress中，可以通过 function 关键字来定义函数。以下是一个简单的示例：

package org.zyf.javabasic.qlexpress;
 
import com.ql.util.express.DefaultContext;
import com.ql.util.express.ExpressRunner;
 
/**
 * @program: zyfboot-javabasic
 * @description: 通过 function 关键字来定义函数
 * @author: zhangyanfeng
 * @create: 2023-11-12 22:11
 **/
public class QLExpressFunctionExample {
    public static void main(String[] args) {
        try {
            final String express = "function add(int a, int b){\n" +
                    "  return a + b;\n" +
                    "};\n" +
                    "\n" +
                    "function sub(int a, int b){\n" +
                    "  return a - b;\n" +
                    "};\n" +
                    "\n" +
                    "a = 10;\n" +
                    "result = add(a, 4) + sub(a, 9);\n" +
                    "return result;";
            ExpressRunner runner = new ExpressRunner();
            DefaultContext context = new DefaultContext<>();
 
            // 执行脚本
            Object result = runner.execute(express, context, null, true, false);
 
            // 输出脚本执行结果
            System.out.println("Result: " + result);
 
            // 输出函数调用过程中的参数和返回值
            System.out.println("add function call: a + 4 = " + context.get("a") + " + 4 = " + context.get("result"));
 
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

（四）扩展操作符

在 QLExpress 中，可以通过自定义操作符（Operator）来扩展语言的功能。

package org.zyf.javabasic.qlexpress;
 
import com.ql.util.express.DefaultContext;
import com.ql.util.express.ExpressRunner;
 
import java.util.ArrayList;
import java.util.List;
 
/**
 * @program: zyfboot-javabasic
 * @description: 自定义操作符（Operator）来扩展语言的功能
 * @author: zhangyanfeng
 * @create: 2023-11-12 23:13
 **/
public class QLExpressOperatorExample {
    public static void main(String[] args) {
        try {
            // 示例 1：替换 if then else 关键字
            ExpressRunner runner1 = new ExpressRunner();
            DefaultContext context1 = new DefaultContext<>();
            context1.put("语文",120);
            context1.put("数学",23);
            context1.put("英语",23);
 
            runner1.addOperatorWithAlias("如果", "if", null);
            runner1.addOperatorWithAlias("则", "then", null);
            runner1.addOperatorWithAlias("否则", "else", null);
 
            String express1 = "如果 (语文 + 数学 + 英语 > 270) 则 {return 1;} 否则 {return 0;}";
            Object result1 = runner1.execute(express1, context1, null, false, false, 100L);
            System.out.println("Result 1: " + result1); // 输出结果 1
 
            // 示例 2：自定义 Operator
            ExpressRunner runner2 = new ExpressRunner();
            DefaultContext context2 = new DefaultContext<>();
 
            // 自定义 Operator
            runner2.addOperator("join", new JoinOperator());
 
            // 示例 2.1：addOperator
            Object result2_1 = runner2.execute("1 join 2 join 3", context2, null, false, false);
            System.out.println("Result 2.1: " + result2_1); // 输出结果 [1, 2, 3]
 
            // 示例 2.2：replaceOperator
            ExpressRunner runner2_2 = new ExpressRunner();
            runner2_2.replaceOperator("+", new JoinOperator());
            Object result2_2 = runner2_2.execute("1 + 2 + 3", context2, null, false, false);
            System.out.println("Result 2.2: " + result2_2); // 输出结果 [1, 2, 3]
 
            // 示例 2.3：addFunction
            ExpressRunner runner2_3 = new ExpressRunner();
            runner2_3.addFunction("join", new JoinOperator());
            Object result2_3 = runner2_3.execute("join(1, 2, 3)", context2, null, false, false);
            System.out.println("Result 2.3: " + result2_3); // 输出结果 [1, 2, 3]
 
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
    // JoinOperator 类的定义
    public static class JoinOperator extends com.ql.util.express.Operator {
        public Object executeInner(Object[] list) throws Exception {
            Object opdata1 = list[0];
            Object opdata2 = list[1];
            if (opdata1 instanceof List) {
                ((List) opdata1).add(opdata2);
                return opdata1;
            } else {
                List result = new ArrayList();
                for (Object opdata : list) {
                    result.add(opdata);
                }
                return result;
            }
        }
    }
}

（五）扩展操作符