表达式语言_ spring

Spring Espresdsion Language

Spring表达式语言(简称SpEL)是一个支持查询并在运行时操纵一个对象图的功能强大的表达式语言。SpEL语言的语法类似于统一EL,但提供了更多的功能,最主要的是显式方法调用和基本字符串模板函数。

同很多可用的Java 表达式语言相比,例如OGNL,MVEL和JBoss EL,SpEL的诞生是为了给Spring社区提供一个可以给Spring目录中所有产品提供单一良好支持的表达式语言。其语言特性由Spring目录中的项目需求驱动,包括基于eclipse的SpringSource套件中的代码补全工具需求。也就是说,SpEL是一个基于技术中立的API允许需要时与其他表达式语言集成。

SpEL作为Spring目录中表达式求值的基础,它并不是直接依赖于Spring而是可以被独立使用。为了能够自包含,本章中的许多示例把SpEL作为一个独立的表达式语言来使用。这就需要创建一些如解析器的引导基础组件类。大多数Spring用户只需要为求值编写表达式字符串而不需要关心这些基础组件

SpEL 的功能特性:

  • 字符表达式
  • 布尔和关系操作符
  • 正则表达式
  • 类表达式
  • 访问properties,arrays,lists,maps
  • 方法调用
  • 关系操作符
  • 赋值
  • 调用构造器
  • 三元操作符
  • 变量
  • 用户自定义函数
  • 集合投影
  • 集合选择
  • 模板表达式

    使用 spring 表达式语言

  1. 新建一个Maven Web项目,添加依赖,pom.xml如下所示:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
<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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>

<groupId>com.ceshi.test</groupId>
<artifactId>Spring053</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>

<name>Spring053</name>
<url>http://maven.apache.org</url>

<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<spring.version>4.3.0.RELEASE</spring.version>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<scope>test</scope>
<version>4.10</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.9</version>
</dependency>
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>3.2.4</version>
</dependency>
</dependencies>
</project>
  1. 为了IOC,定义了用户类User.java与Order.java,如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
package com.ceshi.test.Spring053;

/**
* 订单类
*
*/
public class Order {
/**
* 订单名称
*/
private String orderName;
/*
* 用户姓名
*/
private String userName;
/**
* 用户对象
*/
private User customer;

public String getOrderName() {
return orderName;
}

public void setOrderName(String orderName) {
this.orderName = orderName;
}

public User getCustomer() {
return customer;
}

public void setCustomer(User customer) {
this.customer = customer;
}

public String getUserName() {
return userName;
}

public void setUserName(String userName) {
this.userName = userName;
}

@Override
public String toString() {
return "订单名:"+this.getOrderName()+",姓名:"+this.getUserName()+",编号:"+this.getCustomer().getId();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
package com.ceshi.test.Spring053.spel01;

/**
* 订单类
*
*/
public class Order {
/**
* 订单名称
*/
private String orderName;
/*
* 用户姓名
*/
private String userName;
/**
* 用户对象
*/
private User customer;

public String getOrderName() {
return orderName;
}

public void setOrderName(String orderName) {
this.orderName = orderName;
}

public User getCustomer() {
return customer;
}

public void setCustomer(User customer) {
this.customer = customer;
}

public String getUserName() {
return userName;
}

public void setUserName(String userName) {
this.userName = userName;
}
}
  1. 编写容器初始化的配置文件spel01.xml,内容如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">

<bean id="gyl" class="com.ceshi.test.Spring053.spel01.User" p:id="9527">
<property name="name" value="张三">
</property>
</bean>

<bean id="order001" class="com.ceshi.test.Spring053.spel01.Order">
<property name="customer" ref="gyl"></property>
<property name="name" value="#{gyl.name}"></property>
<property name="orderName" value='#{"Apples".toUpperCase()}'></property>
</bean>

</beans>

复制代码
在配置文件中,出现了#{}形式的表达式,我们就称为Spel表达式。#{gyl.name}作用是找到名称为gyl的bean取出中间的name值;#{“Apples”.toUpperCase()}把字符串Apples转换成大写并输出。

  1. 取出bean测试
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    package com.ceshi.test.Spring053.spel01;

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

    public class Test {

    public static void main(String[] args) {
    ApplicationContext ctx=new ClassPathXmlApplicationContext("spel01.xml");
    Order order=ctx.getBean("order001",Order.class);
    System.out.println(order);
    }
    }

    //运行结果:订单名:APPLES,姓名:张三,编号:9527

SpEL表达式Hello World!

Spring表达式语言(SpEL)从3.X开始支持,它是一种能够支持运行时查询和操作对象图的强大的表达式,其表达式语法类似于统一表达式语言。

SpEL支持如下表达式:

  • 基本表达式:字面量表达式、关系,逻辑与算数运算表达式、字符串连接及截取表达式、三目运算、正则表达式、括号优先级表达式;
  • 类相关表达式:类类型表达式、类实例化、instanceof表达式、变量定义及引用、赋值表达式、自定义函数、对象属性存取及安全导航表达式、对象方法调用、Bean引用;
  • 集合相关表达式:内联List、内联数组、集合,字典访问、列表,字典,数组修改、集合投影、集合选择;不支持多维内联数组初始化;不支持内联字典定义;
  • 其他表达式:模板表达式.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package com.ceshi.test.Spring053.spel02;

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

public class Test {

public static void main(String[] args) {
//创建SpEL表达式的解析器
ExpressionParser parser=new SpelExpressionParser();
//解析表达式'Hello '+' World!'
Expression exp=parser.parseExpression("'Hello '+' World!'");
//取出解析结果
String result=exp.getValue().toString();
//输出结果
System.out.println(result);
}
}

SpEL 表达式的运用

支持的文字表达的类型是字符串,日期,数值(整型,实型,和十六进制),布尔和空。字符串是由单引号分隔。使用反斜杠字符转移把一个单引号字符本身放在字符串中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
//创建SpEL表达式的解析器
ExpressionParser ep= new SpelExpressionParser();
System.out.println(ep.parseExpression("'HelloWorld'").getValue());
System.out.println(ep.parseExpression("0xffffff").getValue());
System.out.println(ep.parseExpression("1.234345e+3").getValue());
System.out.println(ep.parseExpression("new java.util.Date()").getValue());

ExpressionParser parser=new SpelExpressionParser();
User user=new User(9527,"周星驰");
//解析表达式需要的上下文,解析时有一个默认的上下文
EvaluationContext ctx = new StandardEvaluationContext();
//在上下文中设置变量,变量名为user,内容为user对象
ctx.setVariable("user", user);
//从用户对象中获得id,获得解析后的值在ctx上下文中
//User类在前面已定义,这里增加了一个有参构造方法。上面的示例是调用方法,其实可以这样:引用对象属性,只需使用一个句点来表示一个嵌套的属性值
int id = (Integer) parser.parseExpression("#user.getId()").getValue(ctx);

System.out.println(id);

//运行结果HelloWorld
16777215
1234.345
Fri Jul 01 14:50:59 CST 2017

9527

数组:

1
2
3
4
5
String[] students=new String[]{"tom","jack","rose","mark","lucy"};
ctx.setVariable("students", students);
String student = parser.parseExpression("#students[3]").getValue(ctx,
String.class);
System.out.println(student);

大致使用都是类似的 parser.parseExpression(“ 表达式 “).getValue( 上下文, class);

parser.parseExpression(“ 表达式 “).getValue(class);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
/**关系运算符*/
//true
boolean trueValue1 = parser.parseExpression("2 == 2").getValue(Boolean.class);
//false
boolean falseValue1 = parser.parseExpression("2 < -5.0").getValue(Boolean.class);
//true
boolean trueValue2 = parser.parseExpression("'black' < 'block'").getValue(Boolean.class);
//false,字符xyz是否为int类型
boolean falseValue2 = parser.parseExpression("'xyz' instanceof T(int)").getValue(Boolean.class);
//true,正则是否匹配
boolean trueValue3 =parser.parseExpression("'5.00' matches '^-?\\d+(\\.\\d{2})?$'").getValue(Boolean.class);
//false
boolean falseValue3=parser.parseExpression("'5.0067' matches '^-?\\d+(\\.\\d{2})?$'").getValue(Boolean.class);
/**逻辑运算*/
//false
boolean falseValue4 = parser.parseExpression("true and false").getValue(Boolean.class);
//true,isMember方法用于测试是否为某个对象的成员
String expression = "isMember('Nikola Tesla') and isMember('Mihajlo Pupin')";
boolean trueValue4 = parser.parseExpression(expression).getValue(Boolean.class);
// -- OR 或运算--
//true
boolean trueValue5 = parser.parseExpression("true or false").getValue(Boolean.class);
//true
String expression1 = "isMember('Nikola Tesla') or isMember('Albert Einstein')";
boolean trueValue6 = parser.parseExpression(expression).getValue( Boolean.class);
//false
boolean falseValue5 = parser.parseExpression("!true").getValue(Boolean.class);
//false
String expression2 = "isMember('Nikola Tesla') and !isMember('Mihajlo Pupin')";
boolean falseValue6 = parser.parseExpression(expression).getValue(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

基于 XML 配置定义 Bean

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
<bean id="gyl" class="com.ceshi.test.Spring053.spel01.User" p:id="9527">
<property name="name" value="张三">
</property>
</bean>

<bean id="order001" class="com.ceshi.test.Spring053.spel01.Order">
<property name="customer" ref="gyl"></property>
<property name="userName" value="#{gyl.name}"></property>
<property name="orderName" value='#{"Apples".toUpperCase()}'></property>
</bean>

<bean id="numberGuess" class="org.spring.samples.NumberGuess">
<!--调用静态方法random() -->
<property name="randomNumber" value="#{ T(java.lang.Math).random() * 100.0 }" />
</bean>

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

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

基于注解配置:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
package com.ceshi.test.Spring053.spel03;

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

/**
* 用户类
*/
@Component("user1")
public class User {
/**
* 编号
*/
@Value("#{9527+100}")
private int id;
/**
* 姓名
*/
@Value("#{'Hello'.toUpperCase()}")
private String name;

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;
}
}

参见于:http://www.cnblogs.com/best/p/5748105.html