Java 中执行动态表达式语句前中后缀Ognl、SpEL、Groovy、Jexl3

1. Ognl

Ognl（Object-Graph Navigation Language）是一种表达式语言，特别适用于访问Java对象属性和方法，执行动态表达式。

Ognl表达式的基本语法如下：

运算符	描述
.	执行属性访问
[]	执行表达式
#	引用变量
@	调用静态方法
$	用于定义变量

在Java中，可以使用Ognl表达式来访问对象属性和方法，例如：

import ognl.*;

public class Test {
    public static void main(String[] args) throws Exception {
        // 访问对象属性
        String expression = "user.name";
        User user = new User();
        user.setName("Tom");
        Object result = Ognl.getValue(Ognl.parseExpression(expression), user);
        System.out.println(result); // 输出：Tom

        // 执行方法调用
        expression = "user.sayHello('John')";
        result = Ognl.getValue(Ognl.parseExpression(expression), user);
        System.out.println(result); // 输出：Hello John
    }
}

class User {
    private String name;

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public String sayHello(String name) {
        return "Hello " + name;
    }
}

这段代码使用Ognl表达式访问User对象的name属性和sayHello方法。

1. SpEL

SpEL（Spring Expression Language）也是一种表达式语言，与Ognl类似，可以访问Java对象属性和方法，执行动态表达式。

SpEL表达式的基本语法如下：

运算符	描述
.	执行属性访问
[]	执行表达式
? :	条件运算符
#	引用变量
@	调用Bean方法或静态方法
$	用于定义字符串字面量

在Java中，可以使用SpEL表达式来访问对象属性和方法，例如：

import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;

public class Test {
    public static void main(String[] args) {
        ExpressionParser parser = new SpelExpressionParser();
        StandardEvaluationContext context = new StandardEvaluationContext();
        context.setVariable("name", "Tom");
        String expression = "#name.substring(0, 1).toUpperCase() + #name.substring(1)";
        String result = parser.parseExpression(expression).getValue(context, String.class);
        System.out.println(result); // 输出：Tom
    }
}

这段代码使用SpEL表达式访问字符串变量name的子字符串并转换为首字母大写形式。

1. Groovy

Groovy是一种基于JVM的动态语言，可以被用作Java的替代语言。Groovy中可以使用表达式语言访问Java对象的属性和方法，执行动态表达式。

Groovy表达式的基本语法如下：

运算符	描述
.	执行属性访问
[]	执行表达式
?:	条件运算符
@	获取类或对象
$	用于定义字符串字面量

在Java中，可以使用Groovy表达式来访问对象属性和方法，例如：

import groovy.lang.Binding;
import groovy.lang.GroovyShell;

public class Test {
    public static void main(String[] args) {
        Binding binding = new Binding();
        binding.setVariable("user", new User());
        GroovyShell shell = new GroovyShell(binding);
        String expression = "user.name";
        Object result = shell.evaluate(expression);
        System.out.println(result); // 输出：null
    }
}

class User {
    private String name;

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

这段代码使用Groovy表达式访问User对象的name属性。在Groovy中，访问一个未初始化的属性会返回null。

1. Jexl3

Jexl3是一个开源的表达式语言，它可以解析和执行完整的表达式。Jexl3是专为解析和执行复杂Java表达式而设计的。

Jexl3表达式的基本语法如下：

运算符	描述
.	执行属性访问
[]	执行表达式
?:	条件运算符
#	引用变量
@	调用Java方法
$	用于定义字符串字面量

在Java中，可以使用Jexl3表达式来访问对象属性和方法，例如：

import org.apache.commons.jexl3.JexlBuilder;
import org.apache.commons.jexl3.JexlEngine;
import org.apache.commons.jexl3.MapContext;

public class Test {
    public static void main(String[] args) {
        JexlEngine engine = new JexlBuilder().create();
        MapContext context = new MapContext();
        context.set("user", new User());
        String expression = "user.name";
        Object result = engine.createExpression(expression).evaluate(context);
        System.out.println(result); // 输出：null
    }
}

class User {
    private String name;

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

这段代码使用Jexl3表达式访问User对象的name属性。在Jexl3中，访问一个未初始化的属性会返回null。