10. Spring 表达语言(SpEL)

10.1 简介

Spring Expression Language(简称SpEL)是一种强大的表达式语言,支持在运行时查询和操作对象图。语言语法类似于Unified EL,但提供了其他功能,最值得注意的是方法调用和基本字符串模板功能。

虽然还有其他几种Java表达式语言,例如OGNL,MVEL和JBoss EL,但是创建Spring表达语言是为了向Spring社区提供一种支持良好的表达式语言,可以在所有产品中使用。 Spring 组合。其语言功能受Spring组合项目要求的驱动,包括基于eclipse的Spring Tool Suite中代码完成支持的工具要求。也就是说,SpEL基于技术无关的API,允许在需要时集成其他表达式语言实现。

虽然SpEL是Spring组合中表达式评估的基础,但它并不直接与Spring绑定,可以单独使用。为了自包含,本章中的许多示例都使用SpEL,就像它是一种独立的表达式语言一样。这需要创建一些引导基础结构类,例如解析器。大多数Spring用户不需要处理此基础结构,而只需编写表达式字符串以进行评估。这种典型用法的一个例子是将SpEL集成到创建XML或基于注释的bean定义中,如 Expression support for defining bean definitions. 部分所示。

本章介绍表达式语言的功能,API及其语言语法。在几个地方,Inventor和Inventor的Society类被用作表达式评估的目标对象。这些类声明和用于填充它们的数据列在本章末尾。

表达式语言支持以下功能:

  • 文字表达

  • 布尔和关系运算符

  • 正则表达式

  • 类表达式

  • 访问属性,数组,列表,映射

  • 方法调用

  • 关系运算符

  • 作业

  • 调用构造函数

  • Bean引用

  • 数组构造

  • 内联列表

  • 内联 Map

  • 三元运算符

  • 变量

  • 用户定义的函数

  • 收集投影

  • 收藏品选择

  • 模板化表达式

10.2 评价

本节介绍SpEL接口及其表达式语言的简单使用。完整的语言参考可以在 Language Reference 部分找到。

以下代码介绍了SpEL API,以评估文字字符串表达式'Hello世界'。

ExpressionParser parser = new SpelExpressionParser();
Expression exp = parser.parseExpression("'Hello World'");
String message = (String) exp.getValue();

消息变量的值只是“Hello World”。

您最有可能使用的SpEL类和接口位于包 org.springframework.expression 及其子包和 spel.support 中。

接口 ExpressionParser 负责解析表达式字符串。在此示例中,表达式字符串是由周围的单引号表示的字符串文字。接口 Expression 负责评估先前定义的表达式字符串。在分别调用 parser.parseExpressionexp.getValue 时,可以抛出两个异常, ParseExceptionEvaluationException

SpEL支持广泛的功能,例如调用方法,访问属性和调用构造函数。

作为方法调用的示例,我们在字符串文字上调用 concat 方法。

ExpressionParser parser = new SpelExpressionParser();
Expression exp = parser.parseExpression("'Hello World'.concat('!')");
String message = (String) exp.getValue();

消息的 Value 现在是'Hello World!'。

作为调用JavaBean属性的示例,可以调用String属性 Bytes ,如下所示。

ExpressionParser parser = new SpelExpressionParser();

// invokes 'getBytes()'
Expression exp = parser.parseExpression("'Hello World'.bytes");
byte[] bytes = (byte[]) exp.getValue();

SpEL还支持使用标准点表示法的嵌套属性,即prop1.prop2.prop3和属性值的设置

也可以访问公共字段。

ExpressionParser parser = new SpelExpressionParser();

// invokes 'getBytes().length'
Expression exp = parser.parseExpression("'Hello World'.bytes.length");
int length = (Integer) exp.getValue();

可以调用String的构造函数而不是使用字符串文字。

ExpressionParser parser = new SpelExpressionParser();
Expression exp = parser.parseExpression("new String('hello world').toUpperCase()");
String message = exp.getValue(String.class);

注意使用泛型方法 public <T> T getValue(Class<T> desiredResultType) 。使用此方法无需将表达式的值强制转换为所需的结果类型。如果无法将值强制转换为 T 类型或使用已注册的类型转换器转换,则将抛出 EvaluationException

SpEL的更常见用法是提供针对特定对象实例(称为根对象)计算的表达式字符串。该示例显示如何从 Inventor 类的实例检索 name 属性或创建布尔条件:

// Create and set a calendar
GregorianCalendar c = new GregorianCalendar();
c.set(1856, 7, 9);

// The constructor arguments are name, birthday, and nationality.
Inventor tesla = new Inventor("Nikola Tesla", c.getTime(), "Serbian");

ExpressionParser parser = new SpelExpressionParser();

Expression exp = parser.parseExpression("name");
String name = (String) exp.getValue(tesla);
// name == "Nikola Tesla"

exp = parser.parseExpression("name == 'Nikola Tesla'");
boolean result = exp.getValue(tesla, Boolean.class);
// result == true

10.2.1 EvaluationContext

在评估表达式以解析属性,方法,字段以及帮助执行类型转换时,将使用接口 EvaluationContext 。有两个开箱即用的实现。

  • SimpleEvaluationContext - 为不需要SpEL语言语法的完整范围的表达式类别公开了必要的SpEL语言功能和配置选项的子集,并且应该进行有意义的限制。示例包括但不限于数据绑定表达式,基于属性的过滤器等。

  • StandardEvaluationContext - 公开了一整套SpEL语言功能和配置选项。您可以使用它来指定默认根对象,并配置每个可用的与评估相关的策略。

SimpleEvaluationContext 旨在仅支持SpEL语言语法的子集。它排除了Java类型引用,构造函数和bean引用。它还需要明确选择表达式中属性和方法的支持级别。默认情况下, create() 静态工厂方法仅启用对属性的读访问权限。您还可以获取构建器以配置所需的确切支持级别,定位以下某个或以下组合:

  • 仅限自定义 PropertyAccessor (无反射)。

  • 只读访问的数据绑定属性。

  • 读取和写入的数据绑定属性。

类型转换

默认情况下,SpEL使用Spring核心中提供的转换服务( org.springframework.core.convert.ConversionService )。此转换服务附带了许多内置的转换器,可用于常见转换,但也可完全扩展,因此可以添加类型之间的自定义转换。此外,它具有通用感知的关键功能。这意味着当在表达式中使用泛型类型时,SpEL将尝试转换以维护它遇到的任何对象的类型正确性。

这在实践中意味着什么?假设正在使用 setValue() 进行赋值来设置 List 属性。该属性的类型实际上是 List<Boolean> 。 SpEL会识别列表中的元素在放入之前需要转换为 Boolean 。一个简单的例子:

class Simple {
    public List<Boolean> booleanList = new ArrayList<Boolean>();
}

Simple simple = new Simple();
simple.booleanList.add(true);

SimpleEvaluationContext context = SimpleEvaluationContext().create();

// false is passed in here as a string. SpEL and the conversion service will
// correctly recognize that it needs to be a Boolean and convert it

parser.parseExpression("booleanList[0]").setValue(context, simple, "false");

// b will be false
Boolean b = simple.booleanList.get(0);

10.2.2 解析器配置

可以使用解析器配置对象( org.springframework.expression.spel.SpelParserConfiguration )配置SpEL表达式解析器。配置对象控制某些表达式组件的行为。例如,如果索引到数组或集合中,并且指定索引处的元素是 null ,则可以自动创建该元素。当使用由一系列属性引用组成的表达式时,这很有用。如果索引到数组或列表并指定超出数组或列表当前大小末尾的索引,则可以自动增大数组或列表以适应该索引。

class Demo {
    public List<String> list;
}

// Turn on:
// - auto null reference initialization
// - auto collection growing
SpelParserConfiguration config = new SpelParserConfiguration(true,true);

ExpressionParser parser = new SpelExpressionParser(config);

Expression expression = parser.parseExpression("list[3]");

Demo demo = new Demo();

Object o = expression.getValue(demo);

// demo.list will now be a real collection of 4 entries
// Each entry is a new empty String

也可以配置SpEL表达式编译器的行为。

10.2.3 SpEL编译

Spring Framework 4.1包含一个基本的表达式编译器。表达式通常被解释为在评估期间提供了很多动态灵活性,但是没有提供最佳性能。对于偶尔使用表达式这很好,但是当其他组件(如Spring Integration)使用时,性能可能非常重要,并且不需要动态。

新的SpEL编译器旨在满足这一需求。编译器将在评估期间动态生成一个真正的Java类,它体现了表达式行为并使用它来实现更快的表达式评估。由于缺少表达式类型,编译器使用在执行编译时对表达式的解释评估期间收集的信息。例如,它不完全从表达式中知道属性引用的类型,但在第一次解释的求值期间,它将找出它是什么。当然,如果各种表达元素的类型随时间变化,那么基于此信息的编译可能会导致麻烦。因此,编译最适合于在重复评估时类型信息不会改变的表达式。

对于这样的基本表达式:

someArray[0].someProperty.someOtherProperty < 0.1

它涉及数组访问,一些属性derefencing和数字操作,性能增益可以非常明显。在50000次迭代的微基准测试示例中,仅使用解释器评估75ms,使用表达式的编译版本仅需3ms。

编译器配置

默认情况下,编译器未打开,但有两种方法可以打开它。当SpEL使用嵌入在另一个组件中时,可以使用前面讨论的解析器配置过程或通过系统属性打开它。本节讨论这两个选项。

重要的是要理解编译器可以运行的几种模式,在枚举中捕获( org.springframework.expression.spel.SpelCompilerMode )。模式如下:

  • OFF - 编译器已关闭;这是默认值。

  • IMMEDIATE - 在立即模式下,表达式会尽快编译。这通常是在第一次解释评估之后。如果编译的表达式失败(通常由于类型更改,如上所述),则表达式求值的调用者将收到异常。

  • MIXED - 在混合模式下,表达式会随着时间的推移在解释和编译模式之间静默切换。经过一些解释后的运行,它们将切换到编译形式,如果编译后的表单出现问题(如类型更改,如上所述),表达式将自动再次切换回解释形式。稍后它可能会生成另一个已编译的表单并切换到它。基本上,用户在 IMMEDIATE 模式下的异常是在内部处理的。

存在 IMMEDIATE 模式,因为 MIXED 模式可能会导致具有副作用的表达式出现问题。如果编译后的表达式在部分成功后爆炸,则可能已经完成了影响系统状态的事情。如果发生这种情况,调用者可能不希望它以解释模式静默重新运行,因为表达式的一部分可能正在运行两次。

选择模式后,使用 SpelParserConfiguration 配置解析器:

SpelParserConfiguration config = new SpelParserConfiguration(SpelCompilerMode.IMMEDIATE,
    this.getClass().getClassLoader());

SpelExpressionParser parser = new SpelExpressionParser(config);

Expression expr = parser.parseExpression("payload");

MyMessage message = new MyMessage();

Object payload = expr.getValue(message);

指定编译器模式时,也可以指定类加载器(允许传递null)。编译表达式将在任何提供的子类加载器中定义。重要的是要确保是否指定了类加载器,它可以看到表达式评估过程中涉及的所有类型。如果未指定,则将使用默认的类加载器(通常是表达式求值期间运行的线程的上下文类加载器)。

配置编译器的第二种方法是在SpEL嵌入到某个其他组件中时使用,并且可能无法通过配置对象进行配置。在这些情况下,可以使用系统属性。属性 spring.expression.compiler.mode 可以设置为 SpelCompilerMode 枚举值之一( offimmediatemixed )。

编译器限制

使用Spring Framework 4.1,基本的编译框架已经到位。但是,该框架尚不支持编译各种表达式。最初的重点是可能在性能关键环境中使用的常用表达式。目前无法编译这些表达式:

涉及作业的

  • 表达式

  • 表达式依赖于转换服务

  • 表达式使用自定义解析器或访问器
    使用选择或投影的

  • 表达式

将来可以编写越来越多的表达类型。

10.3 bean定义中的表达式

SpEL表达式可以与XML或基于注释的配置元数据一起使用,以定义 BeanDefinition 。在这两种情况下,定义表达式的语法都是 #{ <expression string> } 形式。

10.3.1 XML配置

可以使用表达式设置属性或构造函数-arg值,如下所示。

<bean id="numberGuess" class="org.spring.samples.NumberGuess">
    <property name="randomNumber" value="#{ T(java.lang.Math).random() * 100.0 }"/>

    <!-- other properties -->
</bean>

该变量 systemProperties 是预定义的,因此您可以在表达式中使用它,如下所示。请注意,您不必在此上下文中使用 # 符号为预定义变量添加前缀。

<bean id="taxCalculator" class="org.spring.samples.TaxCalculator">
    <property name="defaultLocale" value="#{ systemProperties['user.region'] }"/>

    <!-- other properties -->
</bean>

例如,您还可以通过名称引用其他bean属性。

<bean id="numberGuess" class="org.spring.samples.NumberGuess">
    <property name="randomNumber" value="#{ T(java.lang.Math).random() * 100.0 }"/>

    <!-- other properties -->
</bean>

<bean id="shapeGuess" class="org.spring.samples.ShapeGuess">
    <property name="initialShapeSeed" value="#{ numberGuess.randomNumber }"/>

    <!-- other properties -->
</bean>

10.3.2 注释配置

@Value 注释可以放在字段,方法和方法/构造函数参数上以指定默认值。

以下是设置字段变量的默认值的示例。

public static class FieldValueTestBean

    @Value("#{ systemProperties['user.region'] }")
    private String defaultLocale;

    public void setDefaultLocale(String defaultLocale) {
        this.defaultLocale = defaultLocale;
    }

    public String getDefaultLocale() {
        return this.defaultLocale;
    }

}

等价但在属性setter方法上如下所示。

public static class PropertyValueTestBean

    private String defaultLocale;

    @Value("#{ systemProperties['user.region'] }")
    public void setDefaultLocale(String defaultLocale) {
        this.defaultLocale = defaultLocale;
    }

    public String getDefaultLocale() {
        return this.defaultLocale;
    }

}

自动化方法和构造函数也可以使用 @Value 注释。

public class SimpleMovieLister {

    private MovieFinder movieFinder;
    private String defaultLocale;

    @Autowired
    public void configure(MovieFinder movieFinder,
            @Value("#{ systemProperties['user.region'] }") String defaultLocale) {
        this.movieFinder = movieFinder;
        this.defaultLocale = defaultLocale;
    }

    // ...
}
public class MovieRecommender {

    private String defaultLocale;

    private CustomerPreferenceDao customerPreferenceDao;

    @Autowired
    public MovieRecommender(CustomerPreferenceDao customerPreferenceDao,
            @Value("#{systemProperties['user.country']}") String defaultLocale) {
        this.customerPreferenceDao = customerPreferenceDao;
        this.defaultLocale = defaultLocale;
    }

    // ...
}

10.4 语言参考

10.4.1 文字表达

支持的文字表达式的类型是字符串,数值(int,real,hex),boolean和null。字符串由单引号分隔。要将单引号本身放在字符串中,请使用两个单引号字符。

以下清单显示了文字的简单用法。通常,它们不会像这样单独使用,而是作为更复杂表达式的一部分使用,例如在逻辑比较运算符的一侧使用文字。

ExpressionParser parser = new SpelExpressionParser();

// evals to "Hello World"
String helloWorld = (String) parser.parseExpression("'Hello World'").getValue();

double avogadrosNumber = (Double) parser.parseExpression("6.0221415E+23").getValue();

// evals to 2147483647
int maxValue = (Integer) parser.parseExpression("0x7FFFFFFF").getValue();

boolean trueValue = (Boolean) parser.parseExpression("true").getValue();

Object nullValue = parser.parseExpression("null").getValue();

数字支持使用负号,指数表示法和小数点。默认情况下,使用Double.parseDouble()解析实数。

10.4.2 属性,数组,列表, Map ,索引器

使用属性引用进行导航很简单:只需使用句点来指示嵌套属性值。 Inventor 类,pupin和tesla的实例填充了 Classes used in the examples 部分中列出的数据。要导航 "down" 并获得特斯拉的出生年份和普平的出生城市,使用以下表达方式。

// evals to 1856
int year = (Integer) parser.parseExpression("Birthdate.Year + 1900").getValue(context);

String city = (String) parser.parseExpression("placeOfBirth.City").getValue(context);

属性名称的第一个字母允许不区分大小写。使用方括号表示法获得数组和列表的内容。

ExpressionParser parser = new SpelExpressionParser();
SimpleEvaluationContext context = SimpleEvaluationContext.create();

// Inventions Array

// evaluates to "Induction motor"
String invention = parser.parseExpression("inventions[3]").getValue(
        context, tesla, String.class);

// Members List

// evaluates to "Nikola Tesla"
String name = parser.parseExpression("Members[0].Name").getValue(
        context, ieee, String.class);

// List and Array navigation
// evaluates to "Wireless communication"
String invention = parser.parseExpression("Members[0].Inventions[6]").getValue(
        context, ieee, String.class);

通过指定括号内的文字键值来获取映射的内容。在这种情况下,因为人员映射的键是字符串,我们可以指定字符串文字。

// Officer's Dictionary

Inventor pupin = parser.parseExpression("Officers['president']").getValue(
        societyContext, Inventor.class);

// evaluates to "Idvor"
String city = parser.parseExpression("Officers['president'].PlaceOfBirth.City").getValue(
        societyContext, String.class);

// setting values
parser.parseExpression("Officers['advisors'][0].PlaceOfBirth.Country").setValue(
        societyContext, "Croatia");

10.4.3 内联列表

列表可以使用 {} 表示法直接表达在表达式中。

// evaluates to a Java list containing the four numbers
List numbers = (List) parser.parseExpression("{1,2,3,4}").getValue(context);

List listOfLists = (List) parser.parseExpression("{{'a','b'},{'x','y'}}").getValue(context);

{} 本身就是一个空列表。出于性能原因,如果列表本身完全由固定文字组成,则创建常量列表以表示表达式,而不是在每个评估上构建新列表。

10.4.4 内嵌 Map

也可以使用 {key:value} 表示法直接在表达式中表示 Map 。

// evaluates to a Java map containing the two entries
Map inventorInfo = (Map) parser.parseExpression("{name:'Nikola',dob:'10-July-1856'}").getValue(context);

Map mapOfMaps = (Map) parser.parseExpression("{name:{first:'Nikola',last:'Tesla'},dob:{day:10,month:'July',year:1856}}").getValue(context);

{:} 本身就是一张空 Map 。出于性能原因,如果 Map 本身由固定文字或其他嵌套常量结构(列表或 Map )组成,则会创建一个常量 Map 来表示表达式,而不是在每次评估时构建新 Map 。引用 Map 键是可选的,上面的示例不使用引用键。

10.4.5 数组构造

可以使用熟悉的Java语法构建数组,可选地提供初始化程序以在构造时填充数组。

int[] numbers1 = (int[]) parser.parseExpression("new int[4]").getValue(context);

// Array with initializer
int[] numbers2 = (int[]) parser.parseExpression("new int[]{1,2,3}").getValue(context);

// Multi dimensional array
int[][] numbers3 = (int[][]) parser.parseExpression("new int[4][5]").getValue(context);

当前不允许在构造多维阵列时提供初始化器。

10.4.6 方法

使用典型的Java编程语法调用方法。您也可以在文字上调用方法。 Varargs也受支持。

// string literal, evaluates to "bc"
String bc = parser.parseExpression("'abc'.substring(1, 3)").getValue(String.class);

// evaluates to true
boolean isMember = parser.parseExpression("isMember('Mihajlo Pupin')").getValue(
        societyContext, Boolean.class);

10.4.7 运营商

关系运算符

关系运算符;使用标准运算符表示法支持等于,不等于,小于,小于或等于,大于等于或等于。

// evaluates to true
boolean trueValue = parser.parseExpression("2 == 2").getValue(Boolean.class);

// evaluates to false
boolean falseValue = parser.parseExpression("2 < -5.0").getValue(Boolean.class);

// evaluates to true
boolean trueValue = parser.parseExpression("'black' < 'block'").getValue(Boolean.class);

大于/小于与null的比较遵循一个简单的规则:null在此处被视为空(即不为零)。因此,任何其他值始终大于null(X> null始终为true),并且其他任何值都不会小于任何值(X <null始终为false)。如果您更喜欢数字比较,请避免基于数字的空比较,以支持与零进行比较(例如X> 0或X <0)。

除标准关系运算符外,SpEL还支持基于 matches 运算符的 instanceof 和正则表达式。

// evaluates to false
boolean falseValue = parser.parseExpression(
        "'xyz' instanceof T(Integer)").getValue(Boolean.class);

// evaluates to true
boolean trueValue = parser.parseExpression(
        "'5.00' matches '\^-?\\d+(\\.\\d{2})?$'").getValue(Boolean.class);

//evaluates to false
boolean falseValue = parser.parseExpression(
        "'5.0067' matches '\^-?\\d+(\\.\\d{2})?$'").getValue(Boolean.class);

小心原始类型,因为它们立即被装箱到包装类型,因此1个实例T(int)的计算结果为false,而1个实例的T(整数)计算结果为true,如预期的那样。

每个符号运算符也可以指定为纯字母等价运算符。这避免了所使用的符号对于嵌入表达式的文档类型具有特殊含义的问题(例如,XML文档)。文本等价物如下所示: lt< ), gt> ), le ), ge>= ), eq== ), ne!= ), div/ ), mod% ), not! )。这些不区分大小写。

逻辑运算符

逻辑运算符是支持是和,或,而不是。它们的用途如下所示。

// -- AND --

// evaluates to false
boolean falseValue = parser.parseExpression("true and false").getValue(Boolean.class);

// evaluates to true
String expression = "isMember('Nikola Tesla') and isMember('Mihajlo Pupin')";
boolean trueValue = parser.parseExpression(expression).getValue(societyContext, Boolean.class);

// -- OR --

// evaluates to true
boolean trueValue = parser.parseExpression("true or false").getValue(Boolean.class);

// evaluates to true
String expression = "isMember('Nikola Tesla') or isMember('Albert Einstein')";
boolean trueValue = parser.parseExpression(expression).getValue(societyContext, Boolean.class);

// -- NOT --

// evaluates to false
boolean falseValue = parser.parseExpression("!true").getValue(Boolean.class);

// -- AND and NOT --
String expression = "isMember('Nikola Tesla') and !isMember('Mihajlo Pupin')";
boolean falseValue = parser.parseExpression(expression).getValue(societyContext, Boolean.class);

数学运算符

加法运算符可用于数字和字符串。减法,乘法和除法只能用于数字。支持的其他数学运算符是模数(%)和指数幂(^)。强制执行标准运算符优先级。这些运算符如下所示。

// Addition
int two = parser.parseExpression("1 + 1").getValue(Integer.class); // 2

String testString = parser.parseExpression(
        "'test' + ' ' + 'string'").getValue(String.class); // 'test string'

// Subtraction
int four = parser.parseExpression("1 - -3").getValue(Integer.class); // 4

double d = parser.parseExpression("1000.00 - 1e4").getValue(Double.class); // -9000

// Multiplication
int six = parser.parseExpression("-2 * -3").getValue(Integer.class); // 6

double twentyFour = parser.parseExpression("2.0 * 3e0 * 4").getValue(Double.class); // 24.0

// Division
int minusTwo = parser.parseExpression("6 / -3").getValue(Integer.class); // -2

double one = parser.parseExpression("8.0 / 4e0 / 2").getValue(Double.class); // 1.0

// Modulus
int three = parser.parseExpression("7 % 4").getValue(Integer.class); // 3

int one = parser.parseExpression("8 / 5 % 2").getValue(Integer.class); // 1

// Operator precedence
int minusTwentyOne = parser.parseExpression("1+2-3*8").getValue(Integer.class); // -21

10.4.8 作业

通过使用赋值运算符来设置属性。这通常在对 setValue 的调用中完成,但也可以在调用 getValue 内完成。

Inventor inventor = new Inventor();
SimpleEvaluationContext context = SimpleEvaluationContext.create();

parser.parseExpression("Name").setValue(context, inventor, "Alexander Seovic2");

// alternatively

String aleks = parser.parseExpression(
        "Name = 'Alexandar Seovic'").getValue(context, inventor, String.class);

10.4.9 类型

特殊的 T 运算符可用于指定java.lang.Class(类型)的实例。也使用此运算符调用静态方法。 StandardEvaluationContext 使用 TypeLocator 查找类型, StandardTypeLocator (可以替换)是在了解java.lang包的基础上构建的。这意味着对java.lang中的类型的T()引用不需要完全限定,但所有其他类型引用必须是。

Class dateClass = parser.parseExpression("T(java.util.Date)").getValue(Class.class);

Class stringClass = parser.parseExpression("T(String)").getValue(Class.class);

boolean trueValue = parser.parseExpression(
        "T(java.math.RoundingMode).CEILING < T(java.math.RoundingMode).FLOOR")
        .getValue(Boolean.class);

10.4.10 构造函数

可以使用new运算符调用构造函数。除了基本类型和String(可以使用int,float等)之外,应该使用全限定类名。

Inventor einstein = p.parseExpression(
        "new org.spring.samples.spel.inventor.Inventor('Albert Einstein', 'German')")
        .getValue(Inventor.class);

//create new inventor instance within add method of List
p.parseExpression(
        "Members.add(new org.spring.samples.spel.inventor.Inventor(
            'Albert Einstein', 'German'))").getValue(societyContext);

10.4.11 变量

可以使用语法 #variableName 在表达式中引用变量。使用 EvaluationContext 实现上的setVariable方法设置变量。

Inventor tesla = new Inventor("Nikola Tesla", "Serbian");
SimpleEvaluationContext context = SimpleEvaluationContext.create();
context.setVariable("newName", "Mike Tesla");

parser.parseExpression("Name = #newName").getValue(context, tesla);

System.out.println(tesla.getName()) // "Mike Tesla"

#this和#root变量

始终定义变量#this并引用当前评估对象(解析非限定引用)。始终定义变量#root并引用根上下文对象。虽然#this可能会随着表达式的组件的评估而变化,但#root始终引用根。

// create an array of integers
List<Integer> primes = new ArrayList<Integer>();
primes.addAll(Arrays.asList(2,3,5,7,11,13,17));

// create parser and set variable 'primes' as the array of integers
ExpressionParser parser = new SpelExpressionParser();
SimpleEvaluationContext context = SimpleEvaluationContext.create();
context.setVariable("primes",primes);

// all prime numbers > 10 from the list (using selection ?{...})
// evaluates to [11, 13, 17]
List<Integer> primesGreaterThanTen = (List<Integer>) parser.parseExpression(
        "#primes.?[#this>10]").getValue(context);

10.4.12 功能

您可以通过注册可在表达式字符串中调用的用户定义函数来扩展SpEL。该功能通过 EvaluationContext 注册。

Method method = ...;

SimpleEvaluationContext context = SimpleEvaluationContext.create();
context.setVariable("myFunction", method);

例如,给定一个反转字符串的实用方法如下所示:

public abstract class StringUtils {

    public static String reverseString(String input) {
        StringBuilder backwards = new StringBuilder();
        for (int i = 0; i < input.length(); i++)
            backwards.append(input.charAt(input.length() - 1 - i));
        }
        return backwards.toString();
    }
}

然后可以如下注册和使用上述方法:

ExpressionParser parser = new SpelExpressionParser();
SimpleEvaluationContext context = SimpleEvaluationContext.create();

context.setVariable("reverseString",
    StringUtils.class.getDeclaredMethod("reverseString", String.class));

String helloWorldReversed = parser.parseExpression(
    "#reverseString('hello')").getValue(context, String.class);

10.4.13 Bean引用

如果已使用bean解析器配置了评估上下文,则可以使用(@)符号从表达式中查找bean。

ExpressionParser parser = new SpelExpressionParser();
StandardEvaluationContext context = StandardEvaluationContext.create();
context.setBeanResolver(new MyBeanResolver());

// This will end up calling resolve(context,"foo") on MyBeanResolver during evaluation
Object bean = parser.parseExpression("@foo").getValue(context);

要访问工厂bean本身,bean名称应该以(&)符号为前缀。

ExpressionParser parser = new SpelExpressionParser();
StandardEvaluationContext context = StandardEvaluationContext.create();
context.setBeanResolver(new MyBeanResolver());

// This will end up calling resolve(context,"&foo") on MyBeanResolver during evaluation
Object bean = parser.parseExpression("&foo").getValue(context);

10.4.14 三元运算符(If-Then-Else)

您可以使用三元运算符在表达式中执行if-then-else条件逻辑。一个最小的例子是:

String falseString = parser.parseExpression(
        "false ? 'trueExp' : 'falseExp'").getValue(String.class);

在这种情况下,布尔值false会返回字符串值'falseExp'。一个更现实的例子如下所示。

parser.parseExpression("Name").setValue(societyContext, "IEEE");
societyContext.setVariable("queryName", "Nikola Tesla");

expression = "isMember(#queryName)? #queryName + ' is a member of the ' " +
        "+ Name + ' Society' : #queryName + ' is not a member of the ' + Name + ' Society'";

String queryResultString = parser.parseExpression(expression)
        .getValue(societyContext, String.class);
// queryResultString = "Nikola Tesla is a member of the IEEE Society"

另请参阅Elvis运算符的下一节,了解三元运算符的更短语法。

10.4.15 猫王运营商

Elvis运算符是三元运算符语法的缩写,用于 Groovy 语言。使用三元运算符语法,您通常必须重复两次变量,例如:

String name = "Elvis Presley";
String displayName = name != null ? name : "Unknown";

相反,您可以使用Elvis运算符,该运算符的名称与Elvis的发型相似。

ExpressionParser parser = new SpelExpressionParser();

String name = parser.parseExpression("name?:'Unknown'").getValue(String.class);

System.out.println(name); // 'Unknown'

这是一个更复杂的例子。

ExpressionParser parser = new SpelExpressionParser();

Inventor tesla = new Inventor("Nikola Tesla", "Serbian");
SimpleEvaluationContext context = SimpleEvaluationContext.create();

String name = parser.parseExpression("Name?:'Elvis Presley'").getValue(context, tesla, String.class);

System.out.println(name); // Nikola Tesla

tesla.setName(null);

name = parser.parseExpression("Name?:'Elvis Presley'").getValue(context, tesla, String.class);

System.out.println(name); // Elvis Presley

10.4.16 安全导航操作员

安全导航操作符用于避免 NullPointerException 并来自 Groovy 语言。通常,在引用对象时,可能需要在访问对象的方法或属性之前验证它是否为null。为避免这种情况,安全导航操作符将只返回null而不是抛出异常。

ExpressionParser parser = new SpelExpressionParser();

Inventor tesla = new Inventor("Nikola Tesla", "Serbian");
tesla.setPlaceOfBirth(new PlaceOfBirth("Smiljan"));

SimpleEvaluationContext context = SimpleEvaluationContext.create();

String city = parser.parseExpression("PlaceOfBirth?.City").getValue(context, tesla, String.class);
System.out.println(city); // Smiljan

tesla.setPlaceOfBirth(null);

city = parser.parseExpression("PlaceOfBirth?.City").getValue(context, tesla, String.class);

System.out.println(city); // null - does not throw NullPointerException!!!

Elvis运算符可用于在表达式中应用默认值,例如在@Value表达式中:@Value(“#{systemProperties ['pop3.port']?:25}”)如果已定义,则将注入系统属性pop3.port,否则注入25。

10.4.17 收藏品选择

Selection是一种强大的表达式语言功能,允许您通过从其条目中进行选择将某些源集合转换为另一个源集合。

Selection使用语法 .?[selectionExpression] 。这将过滤集合并返回包含原始元素子集的新集合。例如,选择将使我们能够轻松获得塞尔维亚发明家名单:

List<Inventor> list = (List<Inventor>) parser.parseExpression(
        "Members.?[Nationality == 'Serbian']").getValue(societyContext);

可以在列表和 Map 上进行选择。在前一种情况下,针对每个单独的列表元素评估选择标准,而针对映射,针对每个映射条目(Java类型的对象 Map.Entry )评估选择标准。映射条目的键和值可作为属性在选择中使用。

此表达式将返回一个新映射,该映射由原始映射的那些元素组成,其中条目值小于27。

Map newMap = parser.parseExpression("map.?[value<27]").getValue();

除了返回所有选定的元素外,还可以只检索第一个或最后一个值。获得第一个与选择匹配的条目语法为 ^[…] ,同时为了获得最后一个匹配选择,语法为 $[…]

10.4.18 收集投影

投影允许集合驱动子表达式的评估,结果是新集合。投影的语法是 ![projectionExpression] 。最容易理解的例子是,假设我们有一个发明家名单,但想要他们出生的城市名单。实际上,我们想要为发明人列表中的每个条目评估“placeOfBirth.city”。使用投影:

// returns ['Smiljan', 'Idvor' ]
List placesOfBirth = (List)parser.parseExpression("Members.![placeOfBirth.city]");

Map 也可用于驱动投影,在这种情况下,投影表达式将根据 Map 中的每个条目进行评估(表示为Java Map.Entry )。跨 Map 投影的结果是一个列表,其中包含对每个 Map 条目的投影表达式的评估。

10.4.19 表达式模板

表达模板允许将文字文本与一个或多个评估块混合。每个评估块都用您可以定义的前缀和后缀字符分隔,常见的选择是使用 #{ } 作为分隔符。例如,

String randomPhrase = parser.parseExpression(
        "random number is #{T(java.lang.Math).random()}",
        new TemplateParserContext()).getValue(String.class);

// evaluates to "random number is 0.7038186818312008"

通过将文本文本“random number is”与评估#{}分隔符内表达式的结果进行连接来计算字符串,在本例中是调用random()方法的结果。方法 parseExpression() 的第二个参数是 ParserContext 类型。 ParserContext 接口用于影响表达式的解析方式,以支持表达式模板功能。 TemplateParserContext 的定义如下所示。

public class TemplateParserContext implements ParserContext {

    public String getExpressionPrefix() {
        return "#{";
    }

    public String getExpressionSuffix() {
        return "}";
    }

    public boolean isTemplate() {
        return true;
    }
}

10.5 示例中使用的类

Inventor.java

package org.spring.samples.spel.inventor;

import java.util.Date;
import java.util.GregorianCalendar;

public class Inventor {

    private String name;
    private String nationality;
    private String[] inventions;
    private Date birthdate;
    private PlaceOfBirth placeOfBirth;

    public Inventor(String name, String nationality) {
        GregorianCalendar c= new GregorianCalendar();
        this.name = name;
        this.nationality = nationality;
        this.birthdate = c.getTime();
    }

    public Inventor(String name, Date birthdate, String nationality) {
        this.name = name;
        this.nationality = nationality;
        this.birthdate = birthdate;
    }

    public Inventor() {
    }

    public String getName() {
        return name;
    }

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

    public String getNationality() {
        return nationality;
    }

    public void setNationality(String nationality) {
        this.nationality = nationality;
    }

    public Date getBirthdate() {
        return birthdate;
    }

    public void setBirthdate(Date birthdate) {
        this.birthdate = birthdate;
    }

    public PlaceOfBirth getPlaceOfBirth() {
        return placeOfBirth;
    }

    public void setPlaceOfBirth(PlaceOfBirth placeOfBirth) {
        this.placeOfBirth = placeOfBirth;
    }

    public void setInventions(String[] inventions) {
        this.inventions = inventions;
    }

    public String[] getInventions() {
        return inventions;
    }
}

PlaceOfBirth.java

package org.spring.samples.spel.inventor;

public class PlaceOfBirth {

    private String city;
    private String country;

    public PlaceOfBirth(String city) {
        this.city=city;
    }

    public PlaceOfBirth(String city, String country) {
        this(city);
        this.country = country;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String s) {
        this.city = s;
    }

    public String getCountry() {
        return country;
    }

    public void setCountry(String country) {
        this.country = country;
    }

}

Society.java

package org.spring.samples.spel.inventor;

import java.util.*;

public class Society {

    private String name;

    public static String Advisors = "advisors";
    public static String President = "president";

    private List<Inventor> members = new ArrayList<Inventor>();
    private Map officers = new HashMap();

    public List getMembers() {
        return members;
    }

    public Map getOfficers() {
        return officers;
    }

    public String getName() {
        return name;
    }

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

    public boolean isMember(String name) {
        for (Inventor inventor : members) {
            if (inventor.getName().equals(name)) {
                return true;
            }
        }
        return false;
    }

}
Updated at: 5 months ago
9.8.4. Spring MVC 3验证Table of content11. 使用Spring进行面向方面编程
Comment
You are not logged in.

There are no comments.