Apache Jexl rule engine use demo

Table of contents

1. What is the JEXL rule engine

2. Other rule engines

3. Use case display

---

1. What is the JEXL rule engine

Jexl is a Java-based expression language for computing and manipulating values ​​in Java applications. It can be used as part of a rules engine, but was not specifically designed for it. Compared with other engines designed for rule engines, Jexl has the following advantages and disadvantages.

advantage

• Easy to learn and use : Jexl's syntax is simple and intuitive, making it easy to understand and use. Its API is also very easy to use, very friendly for novices.

• High flexibility : Jexl has high flexibility, allowing users to customize functions, variables and operators to meet various needs.

• Well-integrated with Java : Jexl is Java-based, so it can be easily integrated with Java applications. It can easily interact with Java objects and use Java's reflection mechanism to access classes and methods.

shortcoming

• Not designed for rule engines : While it is possible to use Jexl as part of a rules engine, it was not designed for it. Therefore, there may be some limitations and deficiencies when dealing with complex business rules.

• Lack of rule management functions : Jexl itself only provides expression parsing and calculation functions. If you need more complex rule management functions, such as rule editing, version control, and approval processes, you need to implement them yourself or use other rule engines.

• Poor performance : Since Jexl is an interpreted language, it has relatively low performance. If you need to process large amounts of data or high concurrency scenarios, you may need to consider using other rule engines.

2. Other rule engines

In addition to Jexl, there are many other rule engines to choose from, the following are some of the common ones:

1. Drools: Drools is an open source rules engine that allows developers to separate business logic from application code. It uses a rule-based language (DRL) to express and execute rules, and provides the ability to automatically infer output results from multiple data sources.

2. Jess: Jess is another rule-based programming language designed to integrate with Java. It can be used to build expert systems, business decision support systems, etc. Jess also includes advanced features such as pattern matching and object manipulation.

3. Easy Rules: Easy Rules is a lightweight rule engine framework that allows developers to define and enforce simple rules in applications. It supports annotations and Lambda expressions, and provides integration with Spring and CDI.

4. Apache Spark MLlib: Apache Spark MLlib is a large-scale machine learning library that includes many algorithms and tools for tasks such as classification, regression, clustering, and collaborative filtering. It also provides a set of rule engines for processing streaming and batch data.

5. NRules: NRules is a .NET rules engine that allows developers to define and enforce rules. It is written in C# and provides integration with LINQ, allowing developers to filter data using SQL-like queries.

These are some common rules engines, each of which has its own advantages and disadvantages and applicable scenarios. Developers should choose the most suitable

3. Use case display

3.1 Introducing dependencies

Add the following dependencies in the pom.xml file:

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-jexl3</artifactId>
    <version>3.2.0</version>
</dependency>

3.2 Update maven dependencies

Save the file and update the Maven project. You can run the following commands on the command line:mvn clean install

3.3 Write a case 

import org.apache.commons.jexl3.*;

public class JexlTest{

    public static void main(String[] args) {
        // 创建 JEXL 引擎对象
        JexlEngine jexl = new JexlBuilder().create();

        // 定义表达式
        String expression = "a + b * c";

        // 创建 JEXL 表达式对象
        JexlExpression jexlExpression = jexl.createExpression(expression);

        // 准备数据
        JexlContext context = new MapContext();
        context.set("a", 2);
        context.set("b", 3);
        context.set("c", 4);

        // 计算结果
        Integer result = (Integer) jexlExpression.evaluate(context);

        // 输出结果
        System.out.println(result); // 输出 14
    }
}

In the above example, we calculated a + b * cthe value of using JEXL and output it to the console. We first create a JexlEngineobject, then define the expression to evaluate and the data to provide for the expression.

Next, we create a MapContextobject that contains the data we want to feed into the expression. We set the values ​​of the variables a, band to be , and .c234

We then use JexlEnginethe object to create a JexlExpressionobject that represents the expression to be evaluated. We evaluateevaluate the expression using the method, passing in MapContextthe object as an argument.

Finally, we convert the result of the calculation to an integer and output it to the console.