Spring SpEL - 快速指南

---

Spring SpEL - 概述

Spring 表达式语言 SpEL 是一种非常强大的表达式语言，它支持在运行时查询和操作对象图。它提供了许多高级功能，例如方法调用和基本字符串模板功能。

Spring 表达式语言最初是为 Spring 社区创建的，目的是拥有一种受良好支持的表达式语言，可以在 Spring 产品组合中的所有产品中使用。虽然 SpEL 是 Spring 产品组合中表达式求值的基础，但它并不直接与 Spring 绑定，可以独立使用。

以下是 Spring 表达式语言 SpEL 支持的功能列表：

• 文字表达

• 布尔和关系运算符

• 常用表达

• 类表达式

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

• 方法调用

• 关系运算符

• 任务

• 调用构造函数

• 豆参考

• 数组构建

• 内联列表

• 三元运算符

• 变量

• 用户定义函数

• 收藏投影

• 收藏精选

• 模板化表达式

我们将在接下来的章节中介绍每个主题。

Spring SpEL - 环境设置

本章将指导您如何准备开发环境以开始使用 Spring 框架。它还将教您如何在设置 Spring 框架之前在您的计算机上设置 JDK、Maven 和 Eclipse -

设置 Java 开发工具包 (JDK)

您可以从 Oracle 的 Java 站点 - Java SE 下载下载最新版本的 SDK 。您将在下载的文件中找到安装 JDK 的说明，按照给定的说明进行安装和配置设置。最后设置 PATH 和 JAVA_HOME 环境变量以引用包含 java 和 javac 的目录，通常分别为 java_install_dir/bin 和 java_install_dir。

如果您运行的是 Windows 并已将 JDK 安装在 C:\jdk-11.0.11 中，则必须将以下行放入 C:\autoexec.bat 文件中。

set PATH=C:\jdk-11.0.11;%PATH% 
set JAVA_HOME=C:\jdk-11.0.11 

或者，在 Windows NT/2000/XP 上，您必须右键单击“我的电脑”，选择“属性”→“高级”→“环境变量”。然后，您必须更新 PATH 值并单击“确定”按钮。

在 Unix（Solaris、Linux 等）上，如果 SDK 安装在 /usr/local/jdk-11.0.11 中并且您使用 C shell，则必须将以下内容放入 .cshrc 文件中。

setenv PATH /usr/local/jdk-11.0.11/bin:$PATH 
setenv JAVA_HOME /usr/local/jdk-11.0.11

或者，如果您使用集成开发环境 (IDE)，如 Borland JBuilder、Eclipse、IntelliJ IDEA 或 Sun ONE Studio，则必须编译并运行一个简单的程序来确认 IDE 知道您安装了 Java 的位置。否则，您将必须按照 IDE 文档中的规定进行正确的设置。

设置 Eclipse IDE

本教程中的所有示例都是使用 Eclipse IDE 编写的。因此，我们建议您应该在计算机上安装最新版本的 Eclipse。

要安装 Eclipse IDE，请从www.eclipse.org/downloads下载最新的 Eclipse 二进制文件。下载安装后，将二进制发行版解压到一个方便的位置。例如，在 Windows 上的 C:\eclipse 中，或在 Linux/Unix 上的 /usr/local/eclipse 中，最后适当地设置 PATH 变量。

Eclipse 可以通过在 Windows 机器上执行以下命令来启动，或者只需双击 eclipse.exe

%C:\eclipse\eclipse.exe 

可以通过在 Unix（Solaris、Linux 等）机器上执行以下命令来启动 Eclipse -

$/usr/local/eclipse/eclipse

成功启动后，如果一切正常，那么它应该显示以下结果 -

设置Maven

在本教程中，我们使用 Maven 来运行和构建基于 Spring 的示例。按照Maven - 环境设置安装 maven。

我们将在接下来的章节中介绍每个主题。

Spring SpEL - 创建项目

使用 eclipse，选择File → New → Maven Project。勾选“创建一个简单项目（跳过原型选择）”，然后单击“下一步”。

输入详细信息，如下所示 -

• groupId - com.tutorialspoint

• artifactId - springspel

• 版本- 0.0.1-SNAPSHOT

• 名称- springspel

• 描述- Spring SpEL 项目

单击完成按钮，将创建一个新项目。

pom.xml

使用 Spring Core 依赖项更新 pom.xml。以下是pom.xml的完整内容

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.tutorialspoint</groupId>
   <artifactId>springspel</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <name>springspel</name>
   <description>Spring SpEL Project</description>
   <properties>
      <org.springframework.version>5.3.9</org.springframework.version>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <java.version>1.8</java.version>    
   </properties> 
   <dependencies>
      <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-context</artifactId>
         <version>${org.springframework.version}</version>
         <scope>compile</scope>
      </dependency>
   </dependencies>	    
   <build>
      <plugins>
         <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.1</version>
            <configuration>
               <source>${java.version}</source>
               <target>${java.version}</target>
            </configuration>
         </plugin>
      </plugins>
   </build>
</project>

应用程序上下文.xml

在src → main → resources中创建 applicationcontext.xml ，内容如下。

应用程序上下文.xml

<?xml version="1.0" encoding="UTF-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans"  
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   
   xsi:schemaLocation="http://www.springframework.org/schema/beans   
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">  
</beans> 

Spring SpEL - 表达式接口

ExpressionParser是Spring SpEL的主要接口，它帮助将表达式字符串解析为编译后的表达式。这些编译的表达式可以被评估并支持解析模板以及标准表达式字符串。

句法

以下是创建 ExpressionParser 并使用其对象获取值的示例。

ExpressionParser parser = new SpelExpressionParser();
Expression exp = parser.parseExpression("'Welcome to Tutorialspoint'");
String message = (String) exp.getValue();

它应该打印结果如下 -

Welcome to Tutorialspoint

• ExpressionParser - 负责解析表达式字符串的接口。

• 表达式- 负责评估表达式字符串的接口。

• 异常- 在 parseExpression 和 getValue 方法调用期间可能抛出 ParseException 和 EvaluationException。

SpEL 支持调用方法、调用构造函数和访问属性。以下示例显示了各种用例。

例子

以下示例显示了MainApp类。

让我们更新在Spring SpEL - 创建项目章节中创建的项目。我们正在添加以下文件 -

• MainApp.java - 要运行和测试的主应用程序。

这是MainApp.java文件的内容-

package com.tutorialspoint;

import org.springframework.expression.Expression;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;

public class MainApp {
   public static void main(String[] args) {
      ExpressionParser parser = new SpelExpressionParser();

      // parse a plain text
      Expression exp = parser.parseExpression("'Welcome to tutorialspoint'");
      String message = (String) exp.getValue();
      System.out.println(message);

      // invoke a method
      exp = parser.parseExpression("'Welcome to tutorialspoint'.concat('!')");
      message = (String) exp.getValue();
      System.out.println(message);

      // get a property
      exp = parser.parseExpression("'Welcome to tutorialspoint'.bytes");
      byte[] bytes = (byte[]) exp.getValue();
      System.out.println(bytes.length);

      // get nested properties
      exp = parser.parseExpression("'Welcome to tutorialspoint'.bytes.length");
      int length = (Integer) exp.getValue();
      System.out.println(length);

      //Calling constructor
      exp = parser.parseExpression("new String('Welcome to tutorialspoint').toUpperCase()");
      message = (String) exp.getValue();
      System.out.println(message);	   
   }
}

输出

Welcome to tutorialspoint
Welcome to tutorialspoint!
25
25
WELCOME TO TUTORIALSPOINT

Spring SpEL - 评估上下文

valuationContext是 Spring SpEL 的一个接口，它有助于在上下文中执行表达式字符串。当在表达式求值期间遇到引用时，在此上下文中解析引用。

句法

以下是创建EvaluationContext并使用其对象获取值的示例。

ExpressionParser parser = new SpelExpressionParser();
Expression exp = parser.parseExpression("'name'");
EvaluationContext context = new StandardEvaluationContext(employee);
String name = (String) exp.getValue();

它应该打印如下结果：

Mahesh

这里的结果是员工对象Mahesh的 name 字段的值。StandardEvaluationContext 类指定计算表达式所依据的对象。一旦创建了上下文对象，StandardEvaluationContext 就无法更改。它缓存状态并允许快速执行表达式评估。以下示例显示了各种用例。

例子

以下示例显示了MainApp类。

让我们更新在Spring SpEL - 创建项目章节中创建的项目。我们正在添加以下文件 -

• Employee.java - 员工类。

• MainApp.java - 要运行和测试的主应用程序。

这是Employee.java文件的内容-

package com.tutorialspoint;

public class Employee {
   private String id;
   private String name;
   public String getId() {
      return id;
   }
   public void setId(String id) {
      this.id = id;
   }
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
}

这是MainApp.java文件的内容-

package com.tutorialspoint;

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

public class MainApp {
   public static void main(String[] args) {
      Employee employee = new Employee();
      employee.setId(1);
      employee.setName("Mahesh");

      ExpressionParser parser = new SpelExpressionParser();
      EvaluationContext context = new StandardEvaluationContext(employee);
      Expression exp = parser.parseExpression("name");
      
      // evaluate object using context
      String name = (String) exp.getValue(context);
      System.out.println(name);

      Employee employee1 = new Employee();
      employee1.setId(2);
      employee1.setName("Rita");

      // evaluate object directly
      name = (String) exp.getValue(employee1);
      System.out.println(name);
      exp = parser.parseExpression("id > 1");
      
      // evaluate object using context
      boolean result = exp.getValue(context, Boolean.class);
      System.out.println(result);  // evaluates to false

      result = exp.getValue(employee1, Boolean.class);
      System.out.println(result);  // evaluates to true
   }
}

输出

Mahesh
Rita
false
true

Spring SpEL - 基于 XML 的配置

SpEL 表达式可用于基于 XML 的 bean 配置

句法

以下是在 xml 配置中使用表达式的示例。

<bean id="randomNumberGenerator" class="com.tutorialspoint.RandomNumberGenerator">
   <property name="randomNumber" value="#{ T(java.lang.Math).random() * 100.0 }"/>
</bean> 

这里我们指定了一个要使用 Math.random() 方法填充的属性。对于类，其名称应该是完全限定的。我们也可以使用系统变量以及使用systemProperties。它是一个内置变量。

<property name="country" value="#{ systemProperties['user.country'] }"/>

我们还可以使用另一个带有 SpEL 表达式的 bean，如下所示：

<property name="id" value="#{ randomNumberGenerator.randomNumber }"/>

以下示例显示了各种用例。

例子

让我们更新在Spring SpEL - 创建项目章节中创建的项目。我们正在添加/更新以下文件 -

• RandomNumberGenerator.java - 随机数生成器类。

• Employee.java - 员工类。

• MainApp.java - 要运行和测试的主应用程序。

• applicationcontext.xml - beans 配置文件。

这是RandomNumberGenerator.java文件的内容-

package com.tutorialspoint;
public class RandomNumberGenerator {
   private int randomNumber;
   public int getRandomNumber() {
      return randomNumber;
   } 
   public void setRandomNumber(int randomNumber) {
      this.randomNumber = randomNumber;
   }
}

这是Employee.java文件的内容-

package com.tutorialspoint;

public class Employee {
   private int id;
   private String name;	
   private String country;
   
   public int getId() {
      return id;
   }
   public void setId(int id) {
      this.id = id;
   }
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
   public String getCountry() {
      return country;
   }
   public void setCountry(String country) {
      this.country = country;
   }
   @Override
   public String toString() {
      return "[" + id + ", " + name + ", " + country + "]";
   }
}

这是MainApp.java文件的内容-

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationcontext.xml");
      Employee employee = (Employee) applicationContext.getBean("employee");
      System.out.println(employee);
   }
}

这是applicationcontext.xml文件的内容-

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans"  
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
   xsi:schemaLocation="http://www.springframework.org/schema/beans   
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"> 

   <bean id="randomNumberGenerator" class="com.tutorialspoint.RandomNumberGenerator">
      <property name="randomNumber" value="#{ T(java.lang.Math).random() * 100.0 }"/>
   </bean> 
   <bean id="employee" class="com.tutorialspoint.Employee">
      <property name="id" value="#{ randomNumberGenerator.randomNumber }"/>
      <property name="country" value="#{ systemProperties['user.country'] }"/>
      <property name="name" value="Mahesh"/>
   </bean> 
</beans> 

输出

[84, Mahesh, IN]

Spring SpEL - 基于注释的配置

SpEL 表达式可用于基于注释的 bean 配置

句法

以下是在基于注释的配置中使用表达式的示例。

@Value("#{ T(java.lang.Math).random() * 100.0 }")
private int id;

在这里，我们使用 @Value 注释，并且在属性上指定了 SpEL 表达式。类似地，我们也可以在 setter 方法、构造函数和自动装配期间指定 SpEL 表达式。

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

以下示例显示了各种用例。

例子

让我们更新在Spring SpEL - 创建项目章节中创建的项目。我们正在添加/更新以下文件 -

• Employee.java - 员工类。

• AppConfig.java - 配置类。

• MainApp.java - 要运行和测试的主应用程序。

这是Employee.java文件的内容-

package com.tutorialspoint;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class Employee {
   @Value("#{ T(java.lang.Math).random() * 100.0 }")
   private int id;
   private String name;	
   private String country;

   public int getId() {
      return id;
   }
   public void setId(int id) {
      this.id = id;
   }
   public String getName() {
      return name;
   }
   @Value("Mahesh")
   public void setName(String name) {
      this.name = name;
   }
   public String getCountry() {
      return country;
   }
   @Value("#{ systemProperties['user.country'] }")
   public void setCountry(String country) {
      this.country = country;
   }
   @Override
   public String toString() {
      return "[" + id + ", " + name + ", " + country + "]";
   }
}

这是AppConfig.java文件的内容-

package com.tutorialspoint;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan(basePackages = "com.tutorialspoint")
public class AppConfig {
}

这是MainApp.java文件的内容-

package com.tutorialspoint;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
      context.register(AppConfig.class);
      context.refresh();

      Employee emp = context.getBean(Employee.class);
      System.out.println(emp);	   
   }
}

输出

[84, Mahesh, IN]

Spring SpEL - 文字表达式

SpEL 表达式支持以下类型的文字 -

• 字符串- 单引号分隔的字符串。要使用单引号，请在其周围加上另一个单引号。

• 数字- 支持 int、real 和 hex 表达式。

• 布尔值

• 无效的

以下示例显示了各种用例。

例子

让我们更新在Spring SpEL - 创建项目章节中创建的项目。我们正在添加/更新以下文件 -

• MainApp.java - 要运行和测试的主应用程序。

这是MainApp.java文件的内容-

package com.tutorialspoint;

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

public class MainApp {
   public static void main(String[] args) {
      ExpressionParser parser = new SpelExpressionParser();
      
      // parse a simple text
      String message = (String) parser.parseExpression("'Tutorialspoint'").getValue();
      System.out.println(message);

      // parse a double from exponential expression
      double avogadros  = (Double) parser.parseExpression("6.0221415E+23").getValue();
      System.out.println(avogadros);	

      // parse an int value from Hexadecimal expression
      int intValue = (Integer) parser.parseExpression("0x7FFFFFFF").getValue();
      System.out.println(intValue);

      // parse a boolean 
      boolean booleanValue = (Boolean) parser.parseExpression("true").getValue();
      System.out.println(booleanValue);

      // parse a null object
      Object nullValue = parser.parseExpression("null").getValue();
      System.out.println(nullValue);
   }
}

输出

Tutorialspoint
6.0221415E23
2147483647
true
null

Spring SpEL - 属性

SpEL 表达式支持访问对象的属性。

• 我们也可以在 SpEL 表达式中访问嵌套属性。

• SpEL 表达式中属性的首字母不区分大小写。

以下示例显示了各种用例。

例子

让我们更新在Spring SpEL - 创建项目章节中创建的项目。我们正在添加/更新以下文件 -

• Employee.java - 员工类。

• MainApp.java - 要运行和测试的主应用程序。

这是Employee.java文件的内容-

package com.tutorialspoint;

import java.util.Date;

public class Employee {
   private int id;
   private String name;	
   private Date dateOfBirth;

   public int getId() {
      return id;
   }
   public void setId(int id) {
      this.id = id;
   }
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
   public Date getDateOfBirth() {
      return dateOfBirth;
   }
   public void setDateOfBirth(Date dateOfBirth) {
      this.dateOfBirth = dateOfBirth;
   }
   @Override
   public String toString() {
      return "[" + id + ", " + name + ", " + dateOfBirth + "]";
   }
}

这是MainApp.java文件的内容-

package com.tutorialspoint;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;

public class MainApp {
   public static void main(String[] args) throws ParseException {
      ExpressionParser parser = new SpelExpressionParser();
      Employee employee = new Employee();
      
      employee.setId(1);
      employee.setName("Mahesh");
      employee.setDateOfBirth(new SimpleDateFormat("YYYY-MM-DD").parse("1985-12-01"));

      EvaluationContext context = new StandardEvaluationContext(employee);
      
      int birthYear = (Integer) parser.parseExpression("dateOfBirth.Year + 1900").getValue(context);	
      System.out.println(birthYear);

      String name = (String) parser.parseExpression("name").getValue(context);	
      System.out.println(name);
   }
}

输出

1984
Mahesh

Spring SpEL - 数组

SpEL 表达式支持访问数组并使用对象数组的索引。

• 我们也可以在 SpEL 表达式中访问嵌套数组。

以下示例显示了各种用例。

例子

让我们更新在Spring SpEL - 创建项目章节中创建的项目。我们正在添加/更新以下文件 -

• Employee.java - 员工类。

• Dept.java - 部门类。

• MainApp.java - 要运行和测试的主应用程序。

这是Employee.java文件的内容-

package com.tutorialspoint;

public class Employee {
   private String[] awards;
   public String[] getAwards() {
      return awards;
   }
   public void setAwards(String[] awards) {
      this.awards = awards;
   }
}

这是Dept.java文件的内容-

package com.tutorialspoint;

public class Dept {
   private Employee[] employees;
   public Employee[] getEmployees() {
      return employees;
   }
   public void setEmployees(Employee[] employees) {
      this.employees = employees;
   }
}

这是MainApp.java文件的内容-

package com.tutorialspoint;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;

public class MainApp {
   public static void main(String[] args) throws ParseException {
      ExpressionParser parser = new SpelExpressionParser();
      Employee employee = new Employee();
      String[] awards = {"Star of the Month", "Champion", "Accelerator"};
      employee.setAwards(awards);

      Employee[] employees = { employee };
      Dept dept = new Dept();
      dept.setEmployees(employees);
      EvaluationContext employeeContext = new StandardEvaluationContext(employee);

      // evaluates to "Accelerator"
      String award = parser.parseExpression("awards[2]").getValue(employeeContext, String.class);
      System.out.println(award);
      EvaluationContext deptContext = new StandardEvaluationContext(dept);

      // evaluates to "Champion"
      award = parser.parseExpression("employees[0].awards[1]").getValue(deptContext, String.class);
      System.out.println(award);
   }
}

输出

Accelerator
Champion

Spring SpEL - 列表

SpEL 表达式支持访问列表并使用对象列表的索引。

• 我们也可以在 SpEL 表达式中访问嵌套列表。

以下示例显示了各种用例。

例子

让我们更新在Spring SpEL - 创建项目章节中创建的项目。我们正在添加/更新以下文件 -

• Employee.java - 员工类。

• Dept.java - 部门类。

• MainApp.java - 要运行和测试的主应用程序。

这是Employee.java文件的内容-

package com.tutorialspoint;

public class Employee {
   private List<String> awards;
   public List<String> getAwards() {
      return awards;
   }
   public void setAwards(List<String> awards) {
      this.awards = awards;
   }
}

这是Dept.java文件的内容-

package com.tutorialspoint;

public class Dept {
   private List<Employee> employees;
   public List<Employee> getEmployees() {
      return employees;
   }
   public void setEmployees(List<Employee> employees) {
      this.employees = employees;
   }
}

这是MainApp.java文件的内容-

package com.tutorialspoint;

import java.text.ParseException;
import java.util.Arrays;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;

public class MainApp {
   public static void main(String[] args) throws ParseException {
      ExpressionParser parser = new SpelExpressionParser();
      Employee employee = new Employee();
      employee.setAwards(Arrays.asList("Star of the Month", "Champion", "Accelerator"));

      Dept dept = new Dept();
      dept.setEmployees(Arrays.asList(employee));
      EvaluationContext employeeContext = new StandardEvaluationContext(employee);

      // evaluates to "Accelerator"
      String award = parser.parseExpression("awards.get(2)").getValue(employeeContext, String.class);
      System.out.println(award);

      EvaluationContext deptContext = new StandardEvaluationContext(dept);

      // evaluates to "Champion"
      award = parser.parseExpression("employees.get(0).awards.get(1)").getValue(deptContext, String.class);
      System.out.println(award);
   }
}

输出

Accelerator
Champion

Spring SpEL - 地图

SpEL表达式支持访问map。

以下示例显示了各种用例。

例子

让我们更新在Spring SpEL - 创建项目章节中创建的项目。我们正在添加/更新以下文件 -

• Employee.java - 员工类。

• MainApp.java - 要运行和测试的主应用程序。

这是Employee.java文件的内容-

package com.tutorialspoint;

import java.util.Map;

public class Employee {
   private Map<String, String> offices;
   public Map<String, String> getOffices() {
      return offices;
   }
   public void setOffices(Map<String, String> offices) {
      this.offices = offices;
   }
}

这是MainApp.java文件的内容-

package com.tutorialspoint;

import java.text.ParseException;
import java.util.HashMap;
import java.util.Map;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;

public class MainApp {
   public static void main(String[] args) throws ParseException {
      ExpressionParser parser = new SpelExpressionParser();
      Employee employee = new Employee();
      Map<String, String> officeMap = new HashMap();
      officeMap.put("IN", "Hyderabad");
      officeMap.put("UK", "London");

      employee.setOffices(officeMap);
      EvaluationContext employeeContext = new StandardEvaluationContext(employee);

      // evaluates to "Hyderabad"
      String city = parser.parseExpression("offices['IN']").getValue(employeeContext, String.class);
      System.out.println(city);
   }
}

输出

Hyderabad

Spring SpEL - 方法

SpEL 表达式支持访问对象的方法。

以下示例显示了各种用例。

例子

让我们更新在Spring SpEL - 创建项目章节中创建的项目。我们正在添加/更新以下文件 -

• Employee.java - 员工类。

• MainApp.java - 要运行和测试的主应用程序。

这是Employee.java文件的内容-

package com.tutorialspoint;

public class Employee {
   private List<String> awards;
   public List<String> getAwards() {
      return awards;
   }
   public void setAwards(List<String> awards) {
      this.awards = awards;
   }
   public boolean isAwardee() {
      return awards != null && awards.size() > 0;
   }
}

这是MainApp.java文件的内容-

package com.tutorialspoint;

import java.text.ParseException;
import java.util.Arrays;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;

public class MainApp {
   public static void main(String[] args) throws ParseException {
      ExpressionParser parser = new SpelExpressionParser();
      Employee employee = new Employee();
      employee.setAwards(Arrays.asList("Star of the Month", "Champion", "Accelerator"));
      EvaluationContext employeeContext = new StandardEvaluationContext(employee);

      // string literal, evaluates to "t"
      String t = parser.parseExpression("'Tutorials'.substring(2, 3)").getValue(String.class);
      System.out.println(t);

      // evaluates to true
      boolean isAwardee = parser.parseExpression("isAwardee()").getValue(employeeContext, Boolean.class);
      System.out.println(isAwardee);
   }
}

输出

t
true

Spring SpEL - 关系运算符

SpEL 表达式支持关系运算符，如<、>、等于等。它还支持实例和匹配运算符。

以下示例显示了各种用例。

例子

让我们更新在Spring SpEL - 创建项目章节中创建的项目。我们正在添加/更新以下文件 -

• MainApp.java - 要运行和测试的主应用程序。

这是MainApp.java文件的内容-

package com.tutorialspoint;

import java.text.ParseException;
import java.util.HashMap;
import java.util.Map;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;

public class MainApp {
   public static void main(String[] args) throws ParseException {
      ExpressionParser parser = new SpelExpressionParser();

      // evaluates to true
      boolean result = parser.parseExpression("2 == 2").getValue(Boolean.class);
      System.out.println(result);

      // evaluates to false
      result = parser.parseExpression("2 < -5.0").getValue(Boolean.class);
      System.out.println(result);

      // evaluates to true
      result = parser.parseExpression("'black' < 'block'").getValue(Boolean.class);
      System.out.println(result);

      // evaluates to false
      result = parser.parseExpression("'xyz' instanceof T(int)").getValue(Boolean.class);
      System.out.println(result);

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

输出

true
false
true
false
false

Spring SpEL - 逻辑运算符

SpEL 表达式支持 AND、OR 和 NOT 等逻辑运算符。

以下示例显示了各种用例。

例子

让我们更新在Spring SpEL - 创建项目章节中创建的项目。我们正在添加/更新以下文件 -

• MainApp.java - 要运行和测试的主应用程序。

这是MainApp.java文件的内容-

package com.tutorialspoint;

import java.text.ParseException;
import java.util.HashMap;
import java.util.Map;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;

public class MainApp {
   public static void main(String[] args) throws ParseException {
      ExpressionParser parser = new SpelExpressionParser();

      // evaluates to true
      boolean result = parser.parseExpression("true and true").getValue(Boolean.class);
      System.out.println(result);

      // evaluates to true
      result = parser.parseExpression("true or false").getValue(Boolean.class);
      System.out.println(result);

      // evaluates to false
      result = parser.parseExpression("!true").getValue(Boolean.class);
      System.out.println(result);
   }
}

输出

true
true
false

Spring SpEL - 数学运算符

SpEL 表达式支持 +、-、* 等数学运算符。

以下示例显示了各种用例。

例子

让我们更新在Spring SpEL - 创建项目章节中创建的项目。我们正在添加/更新以下文件 -

• MainApp.java - 要运行和测试的主应用程序。

这是MainApp.java文件的内容-

package com.tutorialspoint;

import java.text.ParseException;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;

public class MainApp {
   public static void main(String[] args) throws ParseException {
      ExpressionParser parser = new SpelExpressionParser();

      // evaluates to 5
      int result = parser.parseExpression("3 + 2").getValue(Integer.class);
      System.out.println(result);

      // evaluates to 1
      result = parser.parseExpression("3 - 2").getValue(Integer.class);
      System.out.println(result);

      // evaluates to 6
      result = parser.parseExpression("3 * 2").getValue(Integer.class);
      System.out.println(result);

      // evaluates to 1
      result = parser.parseExpression("3 / 2").getValue(Integer.class);
      System.out.println(result);

      // evaluates to 1
      result = parser.parseExpression("3 % 2").getValue(Integer.class);
      System.out.println(result);

      // follow operator precedence, evaluate to -9
      result = parser.parseExpression("1+2-3*4").getValue(Integer.class); 
      System.out.println(result);
   }
}

输出

 5
 1
 6
 1
 1
-9

Spring SpEL - 赋值运算符

SpEL 表达式支持使用 setValue() 方法以及使用赋值运算符对属性进行赋值。

以下示例显示了各种用例。

例子

让我们更新在Spring SpEL - 创建项目章节中创建的项目。我们正在添加/更新以下文件 -

• Employee.java - 员工对象。

• MainApp.java - 要运行和测试的主应用程序。

这是Employee.java文件的内容-

package com.tutorialspoint;

public class Employee {
   private String name;
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
}

这是MainApp.java文件的内容-

package com.tutorialspoint;

import java.text.ParseException;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;

public class MainApp {
   public static void main(String[] args) throws ParseException {
      ExpressionParser parser = new SpelExpressionParser();
      Employee employee = new Employee();   
      EvaluationContext employeeContext = new StandardEvaluationContext(employee);

      // Using setValue
      parser.parseExpression("name").setValue(employeeContext, "Mahesh");
      String result = parser.parseExpression("name").getValue(employeeContext, String.class);
      System.out.println(result);

      // Using assignment operator
      result = parser.parseExpression("Name = 'Robert'").getValue(employeeContext, String.class);
      System.out.println(result);
   }
}

输出

Mahesh
Robert

Spring SpEL - 三元运算符

SpEL 表达式支持三元运算符来执行 if-then-else 逻辑。

以下示例显示了各种用例。

例子

让我们更新在Spring SpEL - 创建项目章节中创建的项目。我们正在添加/更新以下文件 -

• MainApp.java - 要运行和测试的主应用程序。

这是MainApp.java文件的内容-

package com.tutorialspoint;

import java.text.ParseException;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;

public class MainApp {
   public static void main(String[] args) throws ParseException {
      ExpressionParser parser = new SpelExpressionParser();

      String result = parser.parseExpression("true ? 'Yes' : 'No'").getValue(String.class);
      System.out.println(result);

      result = parser.parseExpression("false ? 'Yes' : 'No'").getValue(String.class);
      System.out.println(result);
   }
}

输出

Yes
No

Spring SpEL - Elvis Operator

SpEL 表达式支持 Elvis 运算符，它是三元运算符的缩写形式。

// Using ternary operator
String result = name != null ? name: "unknown";

// Using Elvis Operator
result = name?:"unknown";

以下示例显示了各种用例。

例子

让我们更新在Spring SpEL - 创建项目章节中创建的项目。我们正在添加/更新以下文件 -

• Employee.java - 员工类。

• MainApp.java - 要运行和测试的主应用程序。

这是Employee.java文件的内容-

package com.tutorialspoint;

public class Employee {
   private String name;

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

这是MainApp.java文件的内容-

package com.tutorialspoint;

import java.text.ParseException;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;

public class MainApp {
   public static void main(String[] args) throws ParseException {
      ExpressionParser parser = new SpelExpressionParser();
      Employee employee = new Employee();   
      EvaluationContext employeeContext = new StandardEvaluationContext(employee);

      // Evaluates to "unknown"
      String result = parser.parseExpression("name?:'unknown'").getValue(employeeContext, String.class);
      System.out.println(result);

      employee.setName("Mahesh");

      // Evaluates to "Mahesh"
      result = parser.parseExpression("name?:'unknown'").getValue(employeeContext, String.class);
      System.out.println(result);
   }
}

输出

unknown
Mahesh

Spring SpEL - 安全导航操作员

SpEL 表达式支持安全导航运算符，用于避免 NullPointerException。

int length = parser.parseExpression("name?.length").getValue(context, Integer.class);

这里如果name为null，则表达式不会抛出空指针异常。

以下示例显示了各种用例。

例子

让我们更新在Spring SpEL - 创建项目章节中创建的项目。我们正在添加/更新以下文件 -

• Employee.java - 员工类。

• MainApp.java - 要运行和测试的主应用程序。

这是Employee.java文件的内容-

package com.tutorialspoint;

public class Employee {
   private String name;
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
}

这是MainApp.java文件的内容-

package com.tutorialspoint;

import java.text.ParseException;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;

public class MainApp {
   public static void main(String[] args) throws ParseException {
      ExpressionParser parser = new SpelExpressionParser();
      Employee employee = new Employee();   
      EvaluationContext employeeContext = new StandardEvaluationContext(employee);

      // Evaluates to null but will not throw null pointer exception during parseExpression
      String result = parser.parseExpression("name?.strip()").getValue(employeeContext, String.class);
      System.out.println(result);
      employee.setName("   Mahesh   ");

      // Evaluates to "Mahesh"
      result = parser.parseExpression("name?.strip()").getValue(employeeContext, String.class);
      System.out.println(result);	   
   }
}

输出

null
Mahesh

Spring SpEL - 集合选择

SpEL 表达式支持集合选择，这是一个非常强大的表达式，允许通过从源集合中选择条目来将源集合转换为另一个集合。

句法

?[selectionExpresion]

以下示例显示了用法。

List<Employee> list = (List<Employee>)
   parser.parseExpression("employees.?[country == 'USA']").getValue(deptContext);

此处 SpEL 将仅返回来自美国的员工列表中的员工。

以下示例显示了各种用例。

例子

让我们更新在Spring SpEL - 创建项目章节中创建的项目。我们正在添加/更新以下文件 -

• Employee.java - 员工类。

• Dept.java - 部门类。

• MainApp.java - 要运行和测试的主应用程序。

这是Employee.java文件的内容-

package com.tutorialspoint;

public class Employee {
   private String name;
   private String country;

   public Employee(String name, String country) {
      this.name = name;
      this.country = country;
   }
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
   public String getCountry() {
      return country;
   }
   public void setCountry(String country) {
      this.country = country;
   }
   public String toString() {
      return "[" +name+ ", "+country + "]";
   }
}

这是Dept.java文件的内容-

package com.tutorialspoint;

import java.util.List;

public class Dept {
   private List<Employee> employees;
   public List<Employee> getEmployees() {
      return employees;
   }
   public void setEmployees(List<Employee> employees) {
      this.employees = employees;
   }
}

这是MainApp.java文件的内容-

package com.tutorialspoint;

import java.text.ParseException;
import java.util.ArrayList;
import java.util.List;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;

public class MainApp {
   public static void main(String[] args) throws ParseException {
      ExpressionParser parser = new SpelExpressionParser();
      Employee employee1 = new Employee("Robert", "USA");
      Employee employee2 = new Employee("Julie", "USA");
      Employee employee3 = new Employee("Ramesh", "India");

      List<Employee> employees = new ArrayList<Employee>();
      employees.add(employee1);
      employees.add(employee2);
      employees.add(employee3);

      Dept dept = new Dept();
      dept.setEmployees(employees);
      EvaluationContext deptContext = new StandardEvaluationContext(dept);

      // Select list of employees who are living in USA
      List<Employee> list = (List<Employee>)
         parser.parseExpression("employees.?[country == 'USA']").getValue(deptContext);
      System.out.println(list);
   }
}

输出

[[Robert, USA], [Julie, USA]]

Spring SpEL - 集合投影

SpEL 表达式支持集合投影，这是一个非常强大的表达式，允许计算子表达式并在结果中返回一个新集合。

句法

![projectionExpresion]

以下示例显示了用法。

List<String> list = (List<String>)
   parser.parseExpression("employees.![country]").getValue(deptContext);

此处 SpEL 将仅返回来自美国的员工列表中的员工。

以下示例显示了各种用例。

例子

让我们更新在Spring SpEL - 创建项目章节中创建的项目。我们正在添加/更新以下文件 -

• Employee.java - 员工类。

• Dept.java - 部门类。

• MainApp.java - 要运行和测试的主应用程序。

这是Employee.java文件的内容-

package com.tutorialspoint;

public class Employee {
   private String name;
   private String country;
   public Employee(String name, String country) {
      this.name = name;
      this.country = country;
   }
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
   public String getCountry() {
      return country;
   }
   public void setCountry(String country) {
      this.country = country;
   }
   public String toString() {
      return "[" +name+ ", "+country + "]";
   }
}

这是Dept.java文件的内容-

package com.tutorialspoint;

import java.util.List;

public class Dept {
   private List<Employee> employees;
   public List<Employee> getEmployees() {
      return employees;
   }
   public void setEmployees(List<Employee> employees) {
      this.employees = employees;
   }
}

这是MainApp.java文件的内容-

package com.tutorialspoint;

import java.text.ParseException;
import java.util.ArrayList;
import java.util.List;

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

public class MainApp {
   public static void main(String[] args) throws ParseException {

      ExpressionParser parser = new SpelExpressionParser();

      Employee employee1 = new Employee("Robert", "USA");
      Employee employee2 = new Employee("Julie", "USA");
      Employee employee3 = new Employee("Ramesh", "India");

      List<Employee> employees = new ArrayList<Employee>();
      employees.add(employee1);
      employees.add(employee2);
      employees.add(employee3);

      Dept dept = new Dept();
      dept.setEmployees(employees);

      EvaluationContext deptContext = new StandardEvaluationContext(dept);

      // Select list of countries
      List<String> list = (List<String>)
         parser.parseExpression("employees.![country]").getValue(deptContext);
      System.out.println(list);
   }
}

输出

[USA, USA, India]

Spring SpEL - 构造函数

SpEL 表达式支持使用 new 运算符在表达式内创建对象。我们需要传递类的完全限定名称。

句法

Employee robert = parser.parseExpression("new com.tutorialspoint.Employee('Robert','USA')").getValue(Employee.class);

以下示例显示了各种用例。

例子

让我们更新在Spring SpEL - 创建项目章节中创建的项目。我们正在添加/更新以下文件 -

• Employee.java - 员工类。

• Dept.java - 部门类。

• MainApp.java - 要运行和测试的主应用程序。

这是Employee.java文件的内容-

package com.tutorialspoint;

public class Employee {
   private String name;
   private String country;

   public Employee(String name, String country) {
      this.name = name;
      this.country = country;
   }
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
   public String getCountry() {
      return country;
   }
   public void setCountry(String country) {
      this.country = country;
   }
   public String toString() {
      return "[" +name+ ", "+country + "]";
   }
}

这是Dept.java文件的内容-

package com.tutorialspoint;

import java.util.List;

public class Dept {
   private List<Employee> employees;

   public List<Employee> getEmployees() {
      return employees;
   }
   public void setEmployees(List<Employee> employees) {
      this.employees = employees;
   }
   public String toString() {
      return "[" + employees.toString() + "]";
   }
}

这是MainApp.java文件的内容-

package com.tutorialspoint;

import java.text.ParseException;
import java.util.ArrayList;
import java.util.List;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;

public class MainApp {
   public static void main(String[] args) throws ParseException {
      ExpressionParser parser = new SpelExpressionParser();

      List<Employee> employees = new ArrayList<Employee>();	   
      Employee robert = parser.parseExpression("new com.tutorialspoint.Employee('Robert','USA')")
         .getValue(Employee.class);
      employees.add(robert);

      Dept dept = new Dept();
      dept.setEmployees(employees);
      System.out.println(dept);

      EvaluationContext deptContext = new StandardEvaluationContext(dept);
      parser.parseExpression("employees.add(new com.tutorialspoint.Employee('Julie','USA'))")
         .getValue(deptContext);
      System.out.println(dept);
   }
}

输出

[[[Robert, USA]]]
[[[Robert, USA], [Julie, USA]]]

Spring SpEL - 变量

SpEL 表达式允许使用 #variable-name 语法创建和使用特定于表达式的变量。使用EvaluationContext 上的setVariable 设置变量。内置变量也有两种类型：#this 和#root。#this 变量始终引用当前评估对象，而 #root 变量则引用评估上下文的根对象。

句法

context.setVariable("newName", "Mahesh Kumar");

以下示例显示了各种用例。

例子

让我们更新在Spring SpEL - 创建项目章节中创建的项目。我们正在添加/更新以下文件 -

• Employee.java - 员工类。

• MainApp.java - 要运行和测试的主应用程序。

这是Employee.java文件的内容-

package com.tutorialspoint;

public class Employee {
   private String name;
   private String country;

   public Employee(String name, String country) {
      this.name = name;
      this.country = country;
   }
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
   public String getCountry() {
      return country;
   }
   public void setCountry(String country) {
      this.country = country;
   }
   public String toString() {
      return "[" +name+ ", "+country + "]";
   }
}

这是MainApp.java文件的内容-

package com.tutorialspoint;

import java.text.ParseException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.s