spring的EL表达式使用示例

最新推荐文章于 2024-05-02 16:22:41 发布
最新推荐文章于 2024-05-02 16:22:41 发布
阅读量1.4k 收藏 4
点赞数 1
分类专栏： spring 文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_16498553/article/details/107347111
版权

目录

简介

代码目录

 引入包版本

 SpEl基础语法

结果

 Spring的SpEL(xml与注解)

 结果

代码下载：https://gitee.com/hong99/spring/issues/I1N1DF

最后

简介

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

代码目录

 引入包版本


<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.3.11.RELEASE</version>
</dependency>
<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>4.3.11.RELEASE</version>
</dependency>

 SpEl基础语法


/**
 * @Auther: csh
 * @Date: 2020/7/13 15:53
 * @Description:本示例演示了如何使用SpEL表达式将文本字面值解析为相应的数据类型。
 * 数据类型支持负数、小数、科学计数法及八进制、十六进制数等。默认情况下采用Double.parseDouble）方法进行数值转换。
 */
public class PropertyExprSample {
    public static void main(String[] args) {
        //创建对象
        SpElUser user = new SpElUser("hong",29);
        //构建spel解析上下文
        ExpressionParser parser = new SpelExpressionParser();
        EvaluationContext context = new StandardEvaluationContext(user);
        //获取基本属性值
        String username = (String)parser.parseExpression("userName").getValue(context);
        Integer age = (Integer)parser.parseExpression("age").getValue(context);
        System.out.println(username);
        System.out.println(age);

        //数组
        //注：不支持多维数据初始化，会报错！
        int[]arrayl=(int[])parser.parseExpression("new int[]{1,2,3}").getValue(context);
        int[][]array2=(int[][])parser.parseExpression("new int[2][3]").getValue(context);
        System.out.println(arrayl);
        System.out.println(array2);

        //list的解析
        List list=(List) parser. parseExpression("{1,2,3,4}"). getValue(context);
        List listofLists=(List) parser. parseExpression("{{'a','b'},{'x','y'}}"). getValue(context);
        System.out.println(list);
        System.out.println(listofLists);

        //map列表字符串解析
        Map userInfo=(Map)parser.parseExpression("{userName:'hong',credits:100}").getValue(context);
        List userInfo2=(List)parser.parseExpression("{{userName:'hong',credits:100}, {userName:'tom',credits:100}}").getValue(context);
        System.out.println(userInfo);
        System.out.println(userInfo2);

        //从数组,List,Map中较值
//        String interest1= (String)parser.parseExpression("list[0]").getValue(context);
//        String interest2= (String)parser.parseExpression("listofLists[0]").getValue(context);
//        String interest3= (String)parser.parseExpression("interestsMap I'interest1']").getValue(context);
//        System.out.println(interest1);
//        System.out.println(interest2);
//        System.out.println(interest3);

        //方法解析
        String substring=parser.parseExpression("'Spring SpEL'.substring(7)").getValue(String.class);
        Integer index=parser.parseExpression("'Spring SpEL'.indexOf('SpEL')").getValue(Integer.class);
        System.out.println(substring);
        System.out.println(index);
        //调用实例方法
        boolean iscorrect=parser.parseExpression("viladUsername('123456')").getValue(context,Boolean.class);
        System.out.println("iscorrect:"+iscorrect);
        //调用私有方法,将发生错误
//        iscorrect=parser.parseExpression("viladUsername2('hong')").getValue(context,Boolean.class);
//        System.out.println("iscorrect:"+iscorrect);
        //调用静态方法
        iscorrect=parser.parseExpression("viladUsername3('123456')").getValue(context,Boolean.class);
        System.out.println("iscorrect:"+iscorrect);


        //关系操作符
        boolean trueValue=parser. parseExpression("2==2"). getValue(Boolean. class);
        boolean falseValue=parser. parseExpression("2<-5.0"). getValue(Boolean. class);
        System.out.println(trueValue);
        System.out.println(falseValue);
        //字符串关系比较
        trueValue=parser. parseExpression("\"black\"< \"block\""). getValue(Boolean. class);
        System.out.println(trueValue);
        //instanceOf运算符
        falseValue=parser.parseExpression("' xyz' instanceof T(int)"). getValue(Boolean. class);
        System.out.println(falseValue);
        falseValue=parser.parseExpression(" new java.lang.Integer(1) instanceof T(java.lang.Integer)"). getValue(Boolean. class);
        System.out.println(falseValue);
        //正则运算
        trueValue=parser. parseExpression("'15.00' matches '-?\\d+(\\.\\d{2})?$'"). getValue(Boolean. class);
        System.out.println("正则"+trueValue);
        falseValue=parser. parseExpression("'5.0067' matches '\\^-?\\d+(\\.\\d{2})?$'"). getValue(Boolean. class);
        System.out.println("正则"+falseValue);
        //逻辑操作符 and或&& or或|| !
        falseValue=parser.parseExpression("true&&false").getValue(Boolean.class);
        System.out.println("逻辑判断:"+falseValue);
        String expression ="viladUsername('hong') && viladUsername('hong2')";
        Boolean value = parser.parseExpression(expression).getValue(context, Boolean.class);
        System.out.println("逻辑判断:"+value);
        //或判断
        Boolean orVaild = parser.parseExpression("true or false").getValue(Boolean.class);
        System.out.println("或判断:"+orVaild);
        //非判断
        falseValue = parser.parseExpression("!true").getValue(Boolean.class);
        System.out.println("非判断:"+falseValue);
        //算术运算符 % ^
        Integer add = parser.parseExpression("1+1").getValue(Integer.class);
        System.out.println("加法:"+add);
        //String拼接 结果:teststring
        String testString=parser. parseExpression("\"test\"+''+\"string\""). getValue(String. class);
        System.out.println(testString);
        //减法操作,运行结果等于4
        int four=parser.parseExpression("1 - -3").getValue(Integer.class);
        System.out.println("减法运算符:"+four);
        //减法操作,运行结果等于-9000
        double subtraction=parser.parseExpression("1000.00-1e4").getValue(Double.class);
        System.out.println("减法操作:"+subtraction);
        //乘法操作
        int six = parser.parseExpression("-2 * -3").getValue(Integer.class);
        System.out.println("乘法结果:"+six);
        Double twentFour = parser.parseExpression("2.0 * 3e0 * 4").getValue(Double.class);
        System.out.println("double结果："+twentFour);
        //除法操作
        double one = parser.parseExpression("8.0/ 4e0 /2").getValue(Double.class);
        System.out.println("除法操作"+one);
        //求余操作
        one = parser.parseExpression("8 / 5 % 2").getValue(Integer.class);
        System.out.println("求余操作:"+one);
        //运算符优先计算操作
        int minusTwentOne = parser.parseExpression("1+2-3*8").getValue(Integer.class);
        System.out.println("运算符优先计算操作:"+minusTwentOne);
        //三元表达式
        expression = " 1==1?true:false";
        Boolean credits = parser.parseExpression(expression).getValue(Boolean.class);
        System.out.println("三元表达式:"+credits);
        //赋值
        parser.parseExpression("userName").setValue(context,"xxxxxxxx");
        System.out.println(user.getUserName());
        //通过表达式赋值
        parser.parseExpression("userName='hong22222222222'").getValue(context);
        System.out.println(user.getUserName());
        //类型
        Class StringClass = parser.parseExpression("T(java.lang.String)").getValue(Class.class);
        System.out.println("判断是否是String,结果是:"+(StringClass==java.lang.String.class));
        Class userClass = parser.parseExpression("T(com.hong.spring.common.entity.SpElUser)").getValue(Class.class);
        System.out.println("用户的类结果是："+(userClass==com.hong.spring.common.entity.SpElUser.class));
        //变量
        context.setVariable("newUserName","hong2222");
            //赋值
        parser.parseExpression("userName=#newUserName").getValue(context);
        System.out.println("赋值后的结果是:"+user.getUserName());
        //this变量值使用 通过 #xx 来获取
        List<Integer> credisList = new ArrayList <Integer>();
        credisList.addAll(Arrays.asList(150,100,30,111,170,33));
        context.setVariable("creadis",credisList);
        List<Integer> conditionResultLit = (List<Integer>)parser.parseExpression("#creadis.?[#this>100]").getValue(context);
        System.out.println("获取大于100的结果"+conditionResultLit);
        List<Boolean> conditionResultBl = (List<Boolean>)parser.parseExpression("#creadis.![#this>100]").getValue(context);
        System.out.println("获取布尔结果："+conditionResultBl);
        //售合过滤
        Map<String,Integer> createsMap = new HashMap <String, Integer>();
        createsMap.put("hong",95);
        createsMap.put("song",110);
        createsMap.put("wiki",99);
        createsMap.put("clean",73);
        createsMap.put("arry",170);
        createsMap.put("test2",204);
        context.setVariable("creadisMap",createsMap);
        Map<Integer,String> conditionMap = (Map<Integer,String>)parser.parseExpression("#creadisMap.?[value>100]").getValue(context);
        System.out.println("获取大于100的Map结果:"+conditionMap);
    }
}

结果


hong
29
[I@2eafffde
[[I@59690aa4
[1, 2, 3, 4]
[[a, b], [x, y]]
{userName=hong, credits=100}
[{userName=hong, credits=100}, {userName=tom, credits=100}]
SpEL
7
iscorrect:false
iscorrect:true
true
false
true
false
true
正则true
正则false
逻辑判断:false
逻辑判断:false
或判断:true
非判断:false
加法:2
teststring
减法运算符:4
减法操作:-9000.0
乘法结果:6
double结果：24.0
除法操作1.0
求余操作:1.0
运算符优先计算操作:-21
三元表达式:true
xxxxxxxx
hong22222222222
判断是否是String,结果是:true
用户的类结果是：true
赋值后的结果是:hong2222
获取大于100的结果[150, 111, 170]
获取布尔结果：[true, false, false, true, true, false]
获取大于100的Map结果:{song=110, test2=204, arry=170}

 Spring的SpEL(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"
       xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
       xmlns:util="http://www.springframework.org/schema/util"
       xmlns:cotext="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
    <bean id="numberTest" class="com.hong.spring.common.entity.SpElUser" p:age="#{T(java.lang.Math).random()*100.0}" />
    <!--&lt;!&ndash;使用util&ndash;&gt;-->
    <util:properties id="uifo" location="classpath:spel/user.propertis" />
    <context:component-scan base-package="com.hong.spring.common.entity" />
    <cotext:property-placeholder properties-ref="uifo" />
</beans>

@Component("spElUser2")
public class SpElUser2 implements Serializable {
    @Value("${user.name}")
    private String userName;
    @Value("${user.age}")
    private int age;

    public SpElUser2() {
    }

    public SpElUser2(String userName, int age) {
        this.userName = userName;
        this.age = age;
    }

    public String getUserName() {
        return userName;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Boolean viladUsername(String userName){
        return this.userName.equalsIgnoreCase(userName);
    }

    private Boolean viladUsername2(String userName){
        return this.userName.equalsIgnoreCase(userName);
    }

    public static Boolean viladUsername3(String userName){
        return userName.equalsIgnoreCase(userName);
    }
}

 


/**
 * @Auther: csh
 * @Date: 2020/7/13 18:30
 * @Description:实现xml与注解
 */
public class SpringSpEl {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:/spel/applicationfile-spel.xml");
        SpElUser bean = applicationContext.getBean(SpElUser.class);
        System.out.println(bean.getAge());
        SpElUser2 spelUser2 = applicationContext.getBean("spElUser2",SpElUser2.class);
        System.out.println(JSON.toJSONString(spelUser2));

    }
}

 结果


90
{"age":29,"userName":"admin"}

代码下载：https://gitee.com/hong99/spring/issues/I1N1DF

最后

    SpEl语句非常强大，但是千万要记住不要一下子就绕进去了，因为复杂的语法真的很难看懂，并且后续不好维护！

参考文章：

Spring EL表达式使用详解

 

逍遥壮士
关注
专栏目录
Spring EL和资源调用
实践求真知
08-05 449
一 点睛 Spring EL-Spring表达式语言，支持在xml和注解上使用表达式，类似JSP的EL表达式语言。 Spring开发中经常涉及调用各种资源的情况，包含普通文件、网址、配置文件、系统环境变量等，我们可以使用Spring表达式语言实现资源的注入。 Spring主要在注解@Value的参数中使用表达式。 二 实战 演示Spring EL在以下几种情况下使用： 注入普通字符 ...
SpringEL 表达式：一种功能强大的表达式语言
算云烟
03-10 1368
SpringEL 表达式：一种功能强大的表达式语言 文章有参看其他博主博客 https://blog.csdn.net/drxRose/article/details/85085716?utm_source=distribute.pc_relevant.none-task https://blog.csdn.net/weixin_30340745/article/details/9915289...
Spring EL Hello世界示例
一名可爱的技术搬运工
05-27 182
Spring EL与OGNL和JSF EL相似，并在bean创建期间进行评估或执行。 另外，所有Spring表达式都可以通过XML或注释使用。 在本教程中，我们向您展示如何使用Spring Expression Language（SpEL）将String，integer和bean注入XML和注解属性中。 1. Spring EL依赖 在Maven pom.xml文件中声明核心Spri...
Spring3系列6-Spring 表达式语言(Spring EL)
weixin_30347009的博客
06-08 105
　本篇讲述了Spring Expression Language —— 即Spring3中功能丰富强大的表达式语言，简称SpEL。SpEL是类似于OGNL和JSF EL的表达式语言，能够在运行时构建复杂表达式，存取对象属性、对象方法调用等。所有的SpEL都支持XML和Annotation两种方式，格式：#{ SpEL expression } 一、 第一个Spring EL例子—— H...
Spring EL
fmwind的专栏
10-16 1350
Spring Expression Language（简称SpEL）是一种功能强大的表达式语言、 在Spring3中就已经支持EL表达式了, Spring Expression Language(SpEL)是类似于OGNL和JSF EL的表达式语言, 能够在运行时构建复杂表达式, 存取对象属性、调用 一、SpEL有三种用法，一种是在注解@Value中；一种是XML配置；最后一种是在代码块中使用E...
在Spring中使用SpringEL进行依赖注入的简单实例
起风了的博客
08-19 585
为了演示方便，本文所有文件均放在ch2.el包目录下。有错误之处或者其他问题的读者请留言。 1、话不多说，直接上代码 创建DemoService.java文件 package ch2.el; import org.springframework.beans.factory.annotation.Value; import org.springframework.stereotype.Se...
Spring EL表示式的运用@Value说明
08-19
这些示例代码展示了 Spring EL 表达式的强大功能，我们可以使用它来实现各种资源的注入，从而提高开发效率和代码的可维护性。 在 Spring 框架中，我们还可以使用 `@PropertySource` 注解来指定配置文件的地址，例如...
在自定义spring aop中使用el获取拦截方法的变量值。
04-26
标题中的“在自定义Spring AOP中使用EL获取拦截方法的变量值”指的是在Spring的面向切面编程（AOP）中，通过Expression Language（EL，表达式语言）来访问被拦截方法的局部变量值。这通常涉及到Spring的代理机制、...
Spring实战之使用Expression接口进行表达式求值操作示例
08-25
Spring实战之使用Expression接口进行表达式求值操作示例 Spring框架中提供了一个强大的表达式语言Expression Language（EL），它允许开发者在应用程序中使用表达式来进行计算、赋值、方法调用等操作。Expression ...
Spring EL表达式：概念、特性与应用深入解析
码到三十五
02-16 4872
在Spring框架中，Spring Expression Language（简称Spring EL）是一种功能强大的表达式语言，它支持在运行时查询和操作对象图。本文将详细介绍Spring EL表达式的概念、特点、基本语法和用法，并探讨在Spring框架中的应用场景。同时，我们还将分析Spring EL的优势和局限性，并与其他相关技术进行比较。
Spring EL表达式详细讲解及使用实例
zh2508的博客
04-09 1968
一、简介 Spring3中引入了Spring表达式语言—SpringEL,SpEL是一种强大,简洁的装配Bean的方式,他可以通过运行期间执行的表达式将值装配到我们的属性或构造函数当中,更可以调用JDK中提供的静态常量,获取外部Properties文件中的的配置 二、用法 1、文本表达式 文本表达式支持: 字符串(需要用单引号声明)、日期、数字、布尔类型及null,对数字支持负数、指数及小...
掌握Spring EL表达式的基础知识
todoitbo的博客
01-25 4972
在这篇博客中，我们将深入研究Spring中的EL表达式，解释什么是EL表达式，为什么它在Spring框架中如此重要。通过简单易懂的例子，我们将帮助读者建立对EL表达式基础概念的坚实理解。
Spring EL方法调用实例
有天你会让我妒忌的.
03-01 2573
Spring表达式语言(使用SpEL)允许开发人员使用表达式来执行方法和将返回值以注入的方式到属性，或叫作“使用SpEL方法调用”。Spring EL在注解的形式了解如何实现Spring EL方法调用与@Value注释。@Component("customerBean") public class Customer { @Value("#{'rain'.toUpperCase()}") pr...
基于Spring EL表达式处理业务表达式
trayvontang的博客
05-02 1063
SpringEL是Spring表达式，功能非常强大。我们可以能在@Value、@Cachable、自定义注解中的应用EL表达式，当然这些不是本文的重点。本文的重点是如何基于SpringEL来定制业务表达式，以便于简化我们工作，减少自己去处理解析表达式的复杂逻辑。一个简单的场景：例如，业务希望文件名是动态的，根据实际的年、月、日、季以及其他的业务数据来生成。因为有非常多的文件类型，业务希望通过表达式根据实际业务数据生成最终文件名。
Spring EL 表达式的简单介绍和使用
热门推荐
一线大码
11-28 1万+
package gtcom.governance.impl.util; import org.apache.commons.lang3.StringUtils; import org.springframework.expression.Expression; import org.springframework.expression.ExpressionParser; import org.springframework.expression.spel.standard.SpelExpressionPa
spring el 处理数学运算和布尔表达式
艾斯比
08-23 880
java 开发时, 有场景需要通过表单传入的运算符和变量计算数学结果, 我们可以使用 spring el 处理数学运算和布尔表达式, 非常方便 /* 使用 spring el 表达式 计算数学运算 判断逻辑表达式返回值 声明变量 #变量 支持 && || > < <= >= == */ // SpEL parser 可重用, 线程安全的 pu
SpringEL计算 Integer相除为0
一路向前
11-03 379
SpringEL计算 Integer相除为0 使用SpringEL进行计算的时候，数据类型是Integer，进行相除的时候，得到的结果是0，该如何处理呢？ 处理思路： 1，在公式里面，被除数乘以1.00 2，对数据类型进行判断，对于Integer进行转换。 直接上代码： 代码： 直接相除： private static final ExpressionParser PARSER = new SpelExpressionParser(); public static v..
Spring入门三（EL表达式）
Hello_1024的博客
11-20 847
通过springel表达式切换数据源
最新发布
09-10
SpringEL（Spring Expression Language）是一种强大的表达式语言，它支持在运行时查询和操作对象图。在Spring框架中，SpringEL可以用于各种场景，包括数据源切换。在处理动态数据源切换的场景中，SpringEL可以与Spring AOP（面向切面编程）结合使用，动态地根据业务逻辑来选择不同的数据源。 以下是一个简单的示例来介绍如何通过SpringEL表达式来切换数据源： 1. 首先，你需要定义多个数据源，并配置相应的DataSource Bean。 2. 接着，创建一个动态数据源组件，该组件会根据特定的规则来选择数据源。 3. 在该组件中，你可以使用SpringEL表达式来判断当前的业务场景或条件，并返回相应的数据源。 4. 最后，在实际的业务方法中，使用Spring AOP来拦截方法调用，并根据业务需求使用动态数据源组件来选择正确的数据源。 示例代码框架如下： ```java // 定义数据源 @Bean(name = "dataSource1") public DataSource dataSource1() { // 配置数据源1的详细信息 return new HikariDataSource(); } @Bean(name = "dataSource2") public DataSource dataSource2() { // 配置数据源2的详细信息 return new HikariDataSource(); } // 动态数据源组件 public class DynamicDataSource extends AbstractRoutingDataSource { @Override protected Object determineCurrentLookupKey() { // 使用SpringEL表达式计算并返回当前线程应该使用的数据源标识 return expressionResolver.evaluate("someSpringELExpression", DataSource.class); } } // 配置AOP @Aspect public class DataSourceAspect { @Before("execution(* com.yourpackage.service.*.*(..))") public void setDataSource(JoinPoint point) { // 根据业务逻辑切换数据源 DataSourceContextHolder.setDataSource("dataSource1"); } } ``` 在这个过程中，你需要在AOP的切面中使用一个合适的方法来切换数据源，而这个方法可以通过SpringEL表达式来决定使用哪个数据源。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值