Beginning Spring学习笔记——第9章 SpEL

最新推荐文章于 2022-08-13 10:07:41 发布
最新推荐文章于 2022-08-13 10:07:41 发布
阅读量774 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： Beginning Spring学习笔记 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/LonelyQuantum/article/details/77811947
本文介绍了Spring Expression Language (SpEL) 的使用，包括在XML配置中通过SpEL注入属性，创建分析器，调用方法，使用变量和函数，以及SpEL的运算符和实用工具。示例展示了如何在Spring应用中利用SpEL的强大功能进行表达式解析和方法调用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

使用SpEL配置应用程序

本章使用的依赖基本被下文件包括：

<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>org.springframework.samples.service.service</groupId>
  <artifactId>SpringAOPTest</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>war</packaging>

    <properties>

        <!-- Generic properties -->
        <java.version>1.6</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>

        <!-- Web -->
        <jsp.version>2.3.1</jsp.version>
        <jstl.version>1.2</jstl.version>
        <servlet.version>3.1.0</servlet.version>


        <!-- Spring -->
        <spring-framework.version>4.3.10.RELEASE</spring-framework.version>

        <!-- Hibernate / JPA -->
        <hibernate.version>5.2.10.Final</hibernate.version>

        <!-- Logging -->
        <logback.version>1.2.3</logback.version>
        <slf4j.version>1.7.25</slf4j.version>

        <!-- Test -->
        <junit.version>4.12</junit.version>

        <!-- AspectJ -->
        <aspectj.version>1.8.10</aspectj.version>

    </properties>

    <dependencies>

        <!-- Spring MVC -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring-framework.version}</version>
        </dependency>

        <!-- Other Web dependencies -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>${jstl.version}</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>${servlet.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>javax.servlet.jsp-api</artifactId>
            <version>${jsp.version}</version>
            <scope>provided</scope>
        </dependency>

        <!-- Spring and Transactions -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${spring-framework.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring-framework.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring-framework.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring-framework.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring-framework.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>${spring-framework.version}</version>
        </dependency>

        <!-- Logging with SLF4J & LogBack -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j.version}</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>${logback.version}</version>
            <scope>runtime</scope>
        </dependency>

        <!-- Hibernate -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>${hibernate.version}</version>
        </dependency>


        <!-- Test Artifacts -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring-framework.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>

        <!-- AspectJ -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>${aspectj.version}</version>
        </dependency>

    </dependencies> 
</project>

首先在src/main/resource文件夹下创建上下文配置文件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-4.0.xsd">

    <bean id="show1" class="com.wiley.beginningspring.ch9.MyBean">
        <property name="message" value="#{systemProperties['user.language']}" />
    </bean>
</beans>

此处将类MyBean定义成了名为show1的类，并向其中的message属性通过SpEL注入了系统属性中的用户语言。
接下来创建MyBean类。

public class MyBean {
    private String message;

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

然后就可以在Main类中测试配置了。

public class Main {

    public static void main(String... args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        MyBean myBean = context.getBean(MyBean.class);
        System.out.println(myBean.getMessage());
    }
}

输出结果为zh，用户语言为中文。项目目录结构很简单：
目录结构
事实上，也可以用注解完成配置，此时的配置类为：

@Configuration
@ComponentScan(basePackages = {"com.wiley.beginningspring.ch9"})
public class ApplicationConfig {
}

而MyBean类需要在类定义时被定义为一个Spring Bean：

@Component
public class MyBean {

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

    public String getMessage() {
        return message;
    }
}

其中message属性上通过@Value注解使用相同的SpEL语句注入了用户语言的值。

创建一个分析器

SpEL上下文中定义的表达式都应该首先被ExpressionParser解析然后被评估，该分析器对象是线程安全的。默认情况下，表达式模板以‘#’开头，‘}’结尾。分析器对象创建如下：
ExpressionParser parser = new SpELExpressionParser();
创建完分析器实例后就可以用它的parseExpression方法解析一个表达式创建一个表达式实例：
Expression expression = parser.parseExpression("'Hello World'");
然后就可以通过它的getValue方法获得表达式评估的值：
String value = expression.getValue(String.class)
下用 SpEL 解析一个 Hello World：

public class HelloWorldTest {

    ExpressionParser parser;

    @Before
    public void setup() {
        parser = new SpelExpressionParser();
    }

    @Test
    public void helloWorldParsedOK() {
        Expression expression = parser.parseExpression("'Hello World!'");
        String value = expression.getValue(String.class);
        assertThat(value, is("Hello World!"));
    }
}

测试通过。

通过SpEL调用方法

xml配置中调用方法

项目目录结构为：
目录结构

首先在src/main/resource文件夹中创建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-4.0.xsd">

    <bean id="show1" class="com.wiley.beginningspring.ch9.Show">
        <property name="instrument" value="Piano" />
        <property name="song" value="Turning Tables" />
    </bean>

    <bean id="show2" class="com.wiley.beginningspring.ch9.Show">
        <property name="instrument" value="Guitar" />
        <property name="song" value="#{show2.guitarSong()}" />
    </bean>
</beans>

该上下文文件中定义了两个类为Show的Bean。分别用字符串常量和SpEL表达式调用方法注入了值。
然后创建Show类：

public class Show {

    private String instrument;
    private String song;

    public void setInstrument(String instrument) {
        this.instrument = instrument;
    }

    public void setSong(String song) {
        this.song = song;
    }

    public String guitarSong() {
        return "More Than Words";
    }

    public void present() {
        System.out.println("Playing " + song + " with instrument " + instrument);
    }
}

然后创建Main方法执行程序：

public class Main {

    public static void main(String... args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Show show1 = (Show) context.getBean("show1");
        show1.present();
        Show show2 = (Show) context.getBean("show2");
        show2.present();
    }
}

运行输出结果：
输出结果

在字符串上调用方法及链接调用
public class NestedMethodInvocationStringConcatTest {

    ExpressionParser parser;

    @Before
    public void setup() {
        parser = new SpelExpressionParser();
    }

    @Test
    public void helloParsedAndConcatenatedWithWorldAndThenLengthMethodInvoked() {
        Expression exp = parser.parseExpression("'Hello'.concat(' World!').length()");
        Integer value = exp.getValue(Integer.class);
        assertThat(value, is(12));
    }
}
调用构造函数
public class ConstructorInvocationTest {

    ExpressionParser parser;

    @Before
    public void setup() {
        parser = new SpelExpressionParser();
    }

    @Test
    public void constructorInvocationWorksOK() {
        Expression exp = parser.parseExpression("new Double(3.141592653589793)");
        Double value = exp.getValue(Double.class);
        assertThat(value, is(3.141592653589793));
    }
}
调用静态方法
public class StaticConstantFieldAccessTest {

    ExpressionParser parser;

    @Before
    public void setup() {
        parser = new SpelExpressionParser();
    }

    @Test
    public void staticConstantFieldAccessWorksOK() {
        Expression exp = parser.parseExpression("T(java.lang.Math).PI");
        Double value = exp.getValue(Double.class);
        assertThat(value, is(3.141592653589793));
    }
}

使用变量和函数

可以通过context.setVariable("name",...)注册一个变量到评估上下文StandardEvaluationContext对象中，之后就可以在变量名前加#引用已经注册的变量了。

#root

可以在评估上下文中设置一个根对象，当表达式中遇到未知方法和属性时使用该对象进行查找。

public class RootVariablesTests {

    ExpressionParser parser;

    @Before
    public void setup() {
        parser = new SpelExpressionParser();
    }

    @Test
    public void rootVariableRegisteredOK() {
        StandardEvaluationContext context = new StandardEvaluationContext();
        context.setRootObject(new MyBean());
        assertTrue(parser.parseExpression("#root").getValue(context) instanceof MyBean);
    }
}

其中MyBean为任意类。

public class MyBean {

}
#this

提供对当前评估过程的引用。

访问一同属性和环境变量

使用前缀@来访问：

String value = parser.parseExpression("@systemEnvironment[JAVA_HOME]").getValue(context, String.class);

String value = parser.parseExpression("@systemProperties['java.version']").getValue(context, String.class);
内联列表
public class InlineListTests {

    ExpressionParser parser;

    @Before
    public void setup() {
        parser = new SpelExpressionParser();
    }

    @Test
    public void inlineListCreatedOK() {
        List<Integer> value = parser.parseExpression("{1,2,3}").getValue(List.class);
        assertThat(value, hasItems(1, 2, 3));
    }

    @Test
    public void inlineListOfListsCreatedOK() {
        List<List<Integer>> value = parser.parseExpression("{{1,2},{3,4},{5,6}}").getValue(List.class);
        assertThat(value, hasItems(Arrays.asList(1,2), Arrays.asList(3,4), Arrays.asList(5,6)));
    }
}
注册函数

除了注册变量外还可以注册函数，并在之后调用。注册方法为context.registerFunction("name",method)

public class FunctionRegistrationTests {

    ExpressionParser parser;

    @Before
    public void setup() {
        parser = new SpelExpressionParser();
    }

    @Test
    public void functionRegisteredOK() throws NoSuchMethodException {
        StandardEvaluationContext context = new StandardEvaluationContext();
        context.registerFunction("capitalize",
                StringUtils.class.getDeclaredMethod("capitalize", new Class[] { String.class }));

        String value = parser.parseExpression("#capitalize('hello')").getValue(context, String.class);
        assertThat(value, is("Hello"));
    }
}

SpEL运算符

  • 关系：<, >, <=, >=, ==, !=, lt, gt, le, ge, eq, ne
  • 算数：+, -, *, /, %, ^
  • 逻辑： &&, ||, !, and, or, not, between, instanceof
  • 条件：? : (ternary), ? : (elvis)
  • 其他类型：?.(safe navigation), ?[...](selection), ![...](projection), ^[...](first element), $[...](last element)
    其中 instantceof 可以用来判定表达式是否为某个类的实例，如"'Hello' instanceof T(String)"返回一个true值的Boolean变量。
    安全导航运算符用于在嵌套属性上进行导航，使未初始化的属性返回null值而不是抛出SpelEvaluationException。如
public class SafeNavigationOperatorsTest {

    ExpressionParser p;

    @Before
    public void setup() {
        p = new SpelExpressionParser();
    }

    @Test
    public void safeNavigationOperatorsWorkOK() {
        Employee employee = new Employee("Mert");
        StandardEvaluationContext context = new StandardEvaluationContext(employee);

        assertThat(p.parseExpression("Address?.Name").getValue(context, String.class), is(nullValue()));
    }
}

利用之前提到的#this还可以进行集合选择与投影将其转换为另一个集合。

    @Test
    public void collectionSelectedOK() {
        StandardEvaluationContext context = new StandardEvaluationContext();
        context.setRootObject(Arrays.asList(1,2,3,4,5,6,7,8,9));
        List<Integer> evenNumbers = parser.parseExpression("#root.?[#this%2 == 0 ?: false]").getValue(context, List.class);
        assertThat(evenNumbers, hasItems(2, 4, 6, 8));
    }

其中#this用来遍历集合中元素。
还可以通过![…]将一个集合投影到另一个集合，如下：

public class Worker {

    private String name;
    private Country birthPlace;

    public Worker(String name, Country birthPlace) {
        this.name = name;
        this.birthPlace = birthPlace;
    }

    public String getName() {
        return name;
    }

    public Country getBirthPlace() {
        return birthPlace;
    }
}

public enum Country {
    TR,
    USA,
    DE
}

投影Worker到Country：

    @Test
    public void collectionProjectedOK() {
        StandardEvaluationContext context = new StandardEvaluationContext();
        context.setRootObject(Arrays.asList(
                new Worker("Mert", Country.DE),
                new Worker("Funda", Country.TR),
                new Worker("Tugce", Country.USA)));
        List<Country> birthPlaces = parser.parseExpression("#root.![#this.birthPlace]").getValue(context, List.class);
        assertThat(birthPlaces, hasItems(Country.TR, Country.USA, Country.DE));
    }

使用SpEL中的实用工具

访问Spring Bean

在Bean名称前添加@来访问

public class SpringBeanAccessTests {

    ExpressionParser parser;

    @Before
    public void setup() {
        parser = new SpelExpressionParser();
    }

    @Test
    public void springBeanAccessWorksOK() {
        StandardEvaluationContext context = new StandardEvaluationContext();
        context.setBeanResolver(new BeanFactoryResolver(new AnnotationConfigApplicationContext(ApplicationConfig.class)));
        Expression exp = parser.parseExpression("@myBean.sayHello()");
        String value = exp.getValue(context, String.class);
        assertThat(value, is("Hello!"));
    }
}

@Component
public class MyBean {

    public String sayHello() {
        return "Hello!";
    }
}

@Configuration
@ComponentScan(basePackages = {"com.wiley.beginningspring.ch9"})
public class ApplicationConfig {
}
<spring:eval>

使用spring.tld中的该标签可以将评估值显示到JSP页面或为变量分配值。

<body>
    <spring:eval expression = "@MyBean.sayHi()"/>
</body>
Spring Expression Language（SpEL）
有意思
08-19 8927
Spring Expression Language（SpEL） spring的一种表达式。用来动态的获取，值、对象等。 样式： #{ …} 使用既定的规则放置在花括号中。式中的规则得以运行，可以反馈结果。理论上可以返回任何类型。 说说两种方式去设置SpEL Annotation 注解。@Value（）方便快捷。 你可以在里面方式任何符合SpEL规范的语句，并把它的返回值注...
Java知识点概览
qq_48403611的博客
08-03 3897
java后端开发常见面试题总结
Spring实战2.3.3 在SpEL中筛选集合
Quantum_Dog的博客
01-18 640
目录 spring 配置问题：  The prefix "util" for element "util:list" is not bound"  The prefix "aop" for element "aop:config" is not bound. spring 配置问题： Spring配置文件标签报错：The prefix "XXX" for element "XXX
spring表达式语言 SpEl
TonyWu的博客
08-23 398
spring表达式语言，简称SpEl 是一个支持运行时查询和操作对象的强大表达式语言 语法类似于SpEl 使用#{。。。} 作为定界符 通过SpEl 可以实现以下功能 SpEl为bean动态赋值提供了遍历 ：通过bean的id对bean进行引用 ：调用方法以及引用对象中的属性 ：计算表达式值 ：正则表达式匹配         推荐大家学习一下java...
第五章、SpEL
yubo_830的博客
05-31 558
第五章、SpEL SpEL:Spring Expression Language, Spring 表达式语言 （一）SpEL特点 SpEL是强大的表达式语言， 支持运行时查询、操纵一个对象图功能。 SpEL语言的语法类似于EL，但提供了更多的功能，最主要的是显式方法调用和基本字符串模板函数 SpEL是一个基于技术中立的API，允许需要时与其他表达式语言集成。 SpEL与Spring不是直接绑定关系，它可以独立存在，并应用到其它平台 （二）SpEL支持如的功能： 基本表达式：字面量表达式、关系，逻辑与
Spring系列14：SpEL详解
Joe192的博客
07-12 2563
Spring 表达式语言（简称“SpEL”）是一种强大的表达式语言，支持在运行时查询和操作对象图。语言语法类似于 Unified EL，但提供了额外的功能，最值得注意的是方法调用和基本的字符串模板功能。虽然 SpEL 是 Spring 产品组合中表达式评估的基础，但它不直接与 Spring 绑定，可以独立使用。表达式语言支持以下功能：通过几个案例快速体验SpEL表达式的使用。纯字面意义的字符串输出，体验使用的基本步骤。 案例2 字符串方法的字面调用 在表达式中调用字符串的普通方法和构造方法。 案例3 针对
英语四级单词
热门推荐
xxiyy0411的博客
12-18 2万+
// ==UserScript== // @name 背单词 // @description 边上网边刷英语四级单词 // @namespace Xiaomaxin // @version 1.31 // @author Xiaomaxin // @include * // @require http://cdn.bootcss.com
【第五章】Spring表达式语言 之 5.3 SpEL语法 ——跟我学spring3
jinnianshilongnian的专栏
02-23 485
  5.3  SpEL语法 5.3.1  基本表达式 一、字面量表达式： SpEL支持的字面量包括：字符串、数字类型（int、long、float、double）、布尔类型、null类型。 类型 示例 字符串 String str1 = parser.parseExpression("'Hello World!'").getValue(Strin...
Spring3.0 —— 表达式语言（SpEL）
tuxq5721
11-14 234
Spring3.0中新增加了Spring 表达式语言，可以在Spring 的任意需要配置的地方使用该功能。 Spring的表达式语言与Java注解结合，以便开发人员可以撰写和指向他们的配置，而不需要单独的XML文件写入，使得Spring开发者在不需要XML的情况下对应用进行配置。 SpelExpressionParser @Test publicvo...
spring的SPEL表达式
qq_40419080的博客
08-13 2037
SPEL表达式
使用SpringEL操作List和Map集合
Java客学习室
03-11 2677
原文链接：http://www.yiidian.com/spring/spring-el-bean.html 这个例子演示SpEL表达式怎样从List、Map集合中取值，示例如下： 一、编写Bean类 TestCollection类，用于创建Map和List对象 package com.yiidian.collection; import java.util.ArrayList; import ...
spring表达语言(SpEL）快速掌握
zhengholien的java净土
08-18 1905
在Spring3中就已经支持EL表达式了, spring Expression Language(SpEL)是类似于OGNL和EL的表达式语言, 能够在运行时构建复杂表达式, 存取对象属性、调用对象方法等, 它支持XML和Annotation两种方式, 格式：#{SpEL expression}。我使用的spring4.2.2的版本，SpEL位于spring-expression的jar包中。
Spring SpEL表达式语言
时光
06-30 975
Spring SpEL表达式语言
Spel表达式
I want to know a little more.
07-08 920
8.Spring 表达式语言 (SpEL) 8.1介绍 Spring表达式语言（简称SpEl）是一个支持查询和操作运行时对象导航图功能的强大的表达式语言. 它的语法类似于传统EL，但提供额外的功能，最出色的就是函数调用和简单字符串的模板函数。 尽管有其他可选的 Java 表达式语言，如 OGNL, MVEL,JBoss EL 等等，但 Spel 创建的初衷是了给 Spring 社区提供一种简单而高效的表达式语言，一种可贯穿整个 Spring 产品组的语言。这种语言的特性应基于 Spring 产品的..
Spel + AOP动态赋值
大摩羯先生
12-02 841
Spel提供了强大的各种结构化参数解析能力为动态传参赋值提供了友好支持，Aop提供了切面编程的便利，两者结合使得大量共同的业务逻辑可以抽象成切面，使得代码维护更便利
SpEL 表达式
fanxiaobin
04-01 1万+
前言：Spring表达式语言(简称SpEL)是一种与JSP2的EL功能类似的表达式语言，它可以在运行时查询和操作对象图。与JSP2的EL相比，SpEL功能更加强大，它甚至支持方法调用和基本字符串模板函数。SpEL可以独立于Spring容器使用——只是当成简单的表达式语言来使用；也可以在Annotation或XML配置中使用SpEL，这样可以充分利用SpEL简化Spring的Bean配置。 注：在...
从头认识Spring-1.16 SpEl对集合的操作（1）-建立集合以及访问集合的元素，以<util:list/>为例
raylee2007的专栏
02-05 4069
这一章节我们来讨论一下如何建立集合以及访问集合的元素？1.建立集合？（1）domain蛋糕类：package com.raylee.my_new_spring.my_new_spring.ch01.topic_1_20; public class Cake { private String name = ""; private double size = 0; public Str
从头认识Spring-1.16 SpEl对集合的操作（2）-查询集合以及投影元素集合
raylee2007的专栏
02-05 3464
这一章节我们来讨论一下查询集合以及投影元素集合。我们下面用一个例子说明上面的这两个部分。1.domain蛋糕类：（不变）package com.raylee.my_new_spring.my_new_spring.ch01.topic_1_21; public class Cake { private String name = ""; private double size = 0;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值