Spring SpEL表达式

已于 2023-02-02 13:51:33 修改
阅读量341 收藏 1
点赞数
分类专栏： spring使用 文章标签： spring java 前端
于 2023-01-31 22:57:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44316557/article/details/128823399
版权

文章目录

Spring SpEL表达式

简单使用

导入依赖

 <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-expression</artifactId>
      <version>5.3.20</version>
      <scope>compile</scope>
  </dependency>

简单解析并使用

public class test {
    public static void main(String[] args) {
    	//spel解析器
        SpelExpressionParser spel = new SpelExpressionParser();
        //解析spel表达式 返回Expression 对象（计算）
        Expression exp = spel.parseExpression("'Hello'.toUpperCase()");
        //获取值
        String value = exp.getValue(String.class);
        System.out.println(value);//输出HELLO
    }
}

关于对象的简单使用（修改对象的属性）

public class test {
    public static void main(String[] args) {
        User user = new User();
        user.setName("ck");
        user.setAge(18);
        SpelExpressionParser spel = new SpelExpressionParser();
        //多了EvaluationContext 接口
        EvaluationContext standardEvaluationContext = new StandardEvaluationContext(user);
        spel.parseExpression("age").setValue(standardEvaluationContext, 55);
        System.out.println(user.getAge());
    }
}

SpEL编译器

重复编译的设定

如果相同的表达式多次使用，每次都要解析浪费资源。可以设置让经常使用的转换为字节码。

SpelParserConfiguration spelParserConfiguration = new SpelParserConfiguration(SpelCompilerMode.IMMEDIATE, test.class.getClassLoader());
SpelExpressionParser spelExpressionParser = new SpelExpressionParser(spelParserConfiguration);

  • IMMEDIATE 立即启动编译,在第二次表达式取值时才会启用编译

  • OFF 默认，不启动编译
    在这里插入图片描述

  • MIXED 混合型 在解释形和编译型互相切换 在解释了一定数量后(100)，变成编译形

SpEL基础表达式

文本字符解析

支持字符串，日期，数字，布尔，null
字符串用单引号包住或者 "包住，单引号字符’

public class test {
    public static void main(String[] args) {
        SpelExpressionParser spelExpressionParser = new SpelExpressionParser();
        String value = (String)spelExpressionParser.parseExpression("'hello'").getValue();
        Double value1 = (Double)spelExpressionParser.parseExpression("6.2333E+4").getValue();
        int value2 = (Integer)spelExpressionParser.parseExpression("0x7FFFFFFF").getValue();
        boolean value3 = (Boolean)spelExpressionParser.parseExpression("true").getValue();
        Object value4 = spelExpressionParser.parseExpression("null").getValue();
    }
}

对象属性解析

public class test {
    public static void main(String[] args) {
        User user = new User();
        user.setName("陈克");
        user.setAge(18);
        user.setPlaceOfBirsth(new placeOfBirsth("中国","福州"));
        SpelExpressionParser parser = new SpelExpressionParser();
        StandardEvaluationContext context = new StandardEvaluationContext(user);
        //基本属性值获取
        String name = (String)parser.parseExpression("name").getValue(context);
        Integer age = (Integer)parser.parseExpression("age + 10").getValue(context);
        System.out.println(name);//陈克
        System.out.println(age);//28
        //嵌套对象属性值获取
        String city = (String)parser.parseExpression("placeOfBirsth.city").getValue(context);
        System.out.println(city);//中国
    }
}

数组，集合形式解析

不支持多维数组的初始化

public class test {
    public static void main(String[] args) {
        User user = new User();
        user.setName("陈克");
        user.setAge(18);
        user.setPlaceOfBirsth(new placeOfBirsth("中国","福州"));
        SpelExpressionParser parser = new SpelExpressionParser();
        StandardEvaluationContext context = new StandardEvaluationContext(user);
        //一维数组的 创建和初始化
        int[] array = (int[])parser.parseExpression("new int[]{1,2,3}").getValue(context);
        //多维数组的创建
        int[][] array1 = (int[][])parser.parseExpression("new int[2][3]").getValue();
        //List
        List list = (List)parser.parseExpression("{1,2,3,4}").getValue();
        //Liat中List
        List list1 = (List)parser.parseExpression("{{'a','b'},{'x','y'}}").getValue();
        //Map
        Map map = (Map)parser.parseExpression("{userName:'tom',credite:100}").getValue();
        //list中的Map
        List list3 = (List)parser.parseExpression("{{userName:'tom',credite:100},{userName:'tom1',credite:200}}").getValue();
        //map中的List
        Map map1 = (Map)parser.parseExpression("{userName:{'a','b'},credite:{'c','d'}}").getValue();
        //从数组，list，map中取出值(从对象中取出 ints为实体类的变量名)
        int value = (Integer)parser.parseExpression("ints[0]").getValue(context);
        String list = (String)parser.parseExpression("list[0]").getValue(context);
        String map = (String)parser.parseExpression("map['name']").getValue(context);
    }
}

方法解析

可以调用对象所有的可用的实例方法。静态方法。可变参方法

实体类

@Data
public class User {
    private String name;
    private Integer age;
    private placeOfBirsth placeOfBirsth;
    private List list;
    private int[] ints;
    private Map map;

    public static void say(String mes)
    {
        System.out.println(mes);
    }

    public void sleep(String mes,String... args)
    {
        System.out.println(mes + Arrays.toString(args));
    }
}

使用

public class test {
    public static void main(String[] args) {
        User user = new User();
        user.setName("陈克");
        user.setAge(18);
        user.setPlaceOfBirsth(new placeOfBirsth("中国","福州"));
        SpelExpressionParser parser = new SpelExpressionParser();
        StandardEvaluationContext context = new StandardEvaluationContext(user);
        //调用实例方法
        String name = parser.parseExpression("getName()").getValue(context,String.class);
        //调用静态方法
        String say = parser.parseExpression("say('我说')").getValue(context,String.class);
        //调用可变参方法
        String sleep = parser.parseExpression("sleep('我说','2','2')").getValue(context,String.class);

    }
}

关系操作符

public class test1 {
    public static void main(String[] args) {
        SpelExpressionParser spelExpressionParser = new SpelExpressionParser();
        //关系操作符
        Boolean value = spelExpressionParser.parseExpression("2==2").getValue(Boolean.class);
        Boolean value1 = spelExpressionParser.parseExpression("2>5").getValue(Boolean.class);
        //string比较(不支持 但是spel支持)
        Boolean value2 = spelExpressionParser.parseExpression("'不'>'持'").getValue(Boolean.class);
        //instanceof
        Boolean value3 = spelExpressionParser.parseExpression("'不' instanceof T(String)").getValue(Boolean.class);
        //正则表达式
        Boolean value4 = spelExpressionParser.parseExpression(" '8' matches '^[1-9]d*$'").getValue(Boolean.class);
        System.out.println(value4);
    }
}

逻辑操作符

  • 与操作（&& 或者 and）
  • 或操作（|| 或者 or）
  • 非（！）
public class test1 {
    public static void main(String[] args) {
        SpelExpressionParser spelExpressionParser = new SpelExpressionParser();
        //逻辑操作符
        Boolean value = spelExpressionParser.parseExpression("true and false").getValue(Boolean.class);
        Boolean value1 = spelExpressionParser.parseExpression("true && false").getValue(Boolean.class);
        Boolean value2 = spelExpressionParser.parseExpression("true || false").getValue(Boolean.class);
        Boolean value3 = spelExpressionParser.parseExpression("true or false").getValue(Boolean.class);
        Boolean value4 = spelExpressionParser.parseExpression("!true").getValue(Boolean.class);
        System.out.println(value4);
    }
}

算术运算符

在这里插入图片描述

public class test1 {
    public static void main(String[] args) {
        SpelExpressionParser spelExpressionParser = new SpelExpressionParser();
        //逻辑操作符
        Integer value = spelExpressionParser.parseExpression("1 + 1").getValue(Integer.class); //1
        Integer value1 = spelExpressionParser.parseExpression("3 * 5.658").getValue(Integer.class); //16
        Integer value2 = spelExpressionParser.parseExpression("10 / 3").getValue(Integer.class); //3
        Integer value3 = spelExpressionParser.parseExpression("10 % 3").getValue(Integer.class); //1
        Integer value4 = spelExpressionParser.parseExpression("10^3 ").getValue(Integer.class); //1000
    }
}

安全导航符

类似java8 的 Optional

用？号来判断对象是否为null。为null就返回字符串null，而不是空指针

public class test1 {
    public static void main(String[] args) {
        SpelExpressionParser spelExpressionParser = new SpelExpressionParser();
        User user = new User();
        user.setName("ck");
        user.setAge(15);
       // user.setBody(new Body("bp","bt"));
        StandardEvaluationContext context = new StandardEvaluationContext(user);

        //逻辑操作符
        String value = spelExpressionParser.parseExpression("body?.hand").getValue(context,String.class);
        System.out.println(value);
    }
}

三元操作符

Integer value = spelExpressionParser.parseExpression("name == 'ck'? age+10:age").getValue(context,Integer.class);

Elvis操作符

三元表达式类似的简写
如果name不为null则取原来的值，如果为null取value

 String value = spelExpressionParser.parseExpression("name?:'名字为空'").getValue(context,String.class);

赋值，类型，构造器，变量

赋值
public class test {
    public static void main(String[] args) {
        User user = new User();
        user.setName("陈克");
        user.setAge(18);
        user.setPlaceOfBirsth(new placeOfBirsth("中国","福州"));
        SpelExpressionParser parser = new SpelExpressionParser();
        StandardEvaluationContext context = new StandardEvaluationContext(user);
        //修改user的age值 方式一
        parser.parseExpression("age").setValue(context,55);
        //修改user的age值 方式二
        parser.parseExpression("age = 66").getValue(context);
    }
}
类型

T（全限定类名），如果在java.lang包下可以不写包名

public class test {
    public static void main(String[] args) {

        SpelExpressionParser parser = new SpelExpressionParser();
        //获得对应的class对象
        Class value = parser.parseExpression("T(String)").getValue(Class.class);
        Class value1 = parser.parseExpression("T(com.ke.spel.User)").getValue(Class.class);
        //可以直接调用静态方法
        String value2 = parser.parseExpression("T(com.ke.spel.User).say('你干嘛')").getValue(String.class);

    }
}
构造器

用new关键字，除了基本类型和String，其他都要用全限定类名

public class test {
    public static void main(String[] args) {

        SpelExpressionParser parser = new SpelExpressionParser();
        User value = parser.parseExpression("new com.ke.spel.User()").getValue(User.class);
        System.out.println(value);

    }
}
变量

在这里插入图片描述

public class test {
    public static void main(String[] args) {
        User user = new User();
        user.setName("ck");
        user.setAge(18);
        EvaluationContext context = new StandardEvaluationContext(user);
        //把变量存在EvaluationContext（其中维护着一个map）对象中
        context.setVariable("newName","cxk");
        SpelExpressionParser parser = new SpelExpressionParser();
        parser.parseExpression("name=#newName").getValue(context);
        System.out.println(user.getName());
    }
}
集合过滤

在这里插入图片描述

public class test {
    public static void main(String[] args) {

        User user = new User();
        user.setName("ck");
        user.setAge(18);
        EvaluationContext context = new StandardEvaluationContext(user);
        //存入List
        ArrayList<Integer> integers = new ArrayList<>();
        integers.addAll(Arrays.asList(50,100,150,200,250,300,350));
        context.setVariable("list",integers);
        //存入Map
        HashMap map = new HashMap<>();
        map.put("ck",20);
        map.put("cyz",30);
        map.put("cxk",40);
        map.put("gs",50);
        context.setVariable("map",map);
        SpelExpressionParser parser = new SpelExpressionParser();
        //从list找出大于200的元素（this前有#号）
        ArrayList<Integer> value = (ArrayList<Integer>)parser.parseExpression("#list.?[#this>200]").getValue(context);
        //从map找value大于30的元素（value前没有#号）
        Map value1 = (Map)parser.parseExpression("#map.?[value>30]").getValue(context);
        //从map找value大于30的元素（value前没有#号）(^代表取出符合条件的第一个)
        Map value2 = (Map)parser.parseExpression("#map.^[value>30]").getValue(context);
        //从map找value大于30的元素（value前没有#号）($代表取出符合条件的最后一个)
        Map value3 = (Map)parser.parseExpression("#map.$[value>30]").getValue(context);
         //根据条件转换并返回对应 List（!符号）
        //[60, 70, 50, 80]
        ArrayList<Integer> value4 = (ArrayList<Integer>)parser.parseExpression("#map.![value+30]").getValue(context);
        //[250, 300, 350, 400, 450, 500, 550]
        ArrayList<Integer> value5 = (ArrayList<Integer>)parser.parseExpression("#list.![#this+200]").getValue(context);
        //[false, true, false, true]
        ArrayList<Integer> value6 = (ArrayList<Integer>)parser.parseExpression("#map.![value>30]").getValue(context);
        //[false, false, false, false, true, true, true]
        ArrayList<Integer> value7 = (ArrayList<Integer>)parser.parseExpression("#list.![#this>200]").getValue(context);


    }
}

Spring使用Spel表达式

基于XML配置

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
       http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id="hello" class="springEl.Mes"
          p:mes="#{systemProperties['java.class.path']}"
          p:mes1="#{systemProperties['os.name']}"
          p:mes2="#{ T(Double).toString(T(Math).random())}"
          p:mes3="#{ hello2.mes }"
    />

    <bean id="hello2" class="springEl.Mes"
          p:mes="你好"
    />

</beans>

systemProperties可以获得系统参数，也可以调用静态方法，也可以直接引用其他bean的值

public class test {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beansEl.xml");
        Mes bean = (Mes)applicationContext.getBean("hello");
        //获取java环境变量
        System.out.println(bean.getMes());
        //获取操作系统版本 Windows 10
        System.out.println(bean.getMes1());
        //自定义设置的值0.5541974835747724
        System.out.println(bean.getMes2());
        //你好
        System.out.println(bean.getMes3());
    }
}

注解配置

配置文件peizhi.properties

username = ck
password = 666666
div = a.b.c.d

spring配置文件设置

<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:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
       http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/util https://www.springframework.org/schema/util/spring-util.xsd">
    <!--扫描springEl包下的注解-->
    <context:component-scan base-package="springEl"/>
    <!--读取配置文件-->
    <util:properties id="properties" location="classpath:peizhi.properties"/>
    <!--配置可简写spel设置-->
    <context:property-placeholder properties-ref="properties"/>
</beans>

配置直接写入数据

@Component
@Data
public class config {
    @Value("#{properties['username']}")
    private String userName;
    @Value("#{properties['password']}")
    private String passWord;
    @Value("${div}")
    private String div;
}

在配置了spel简写后可以用${字段名}来简化

WeakHashMap
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring的SPEL表达式
qq_40419080的博客
08-13 969
SPEL表达式
Spring SpEL 表达式语言
最新发布
REID丶Beginner的博客
09-21 827
Spring也有自己的EL，叫Spring Expression Language，简称SpEl。其可以在程序中单独使用，也可以在Spring应用中进行bean定义时使用。其核心是org.springframework.expression.Expression接口，Spring使用该接口来表示EL中的表达式。通过Expression接口的系列getValue()方法我们可以获取对应Expression在特定EvaluationContext下的值，也可以通过其系列setValue()方法来设值。
Spring 表达式语言（SpEL）
lanluyug的博客
01-09 1736
SpEL
spring中的spel表达式语言
yangnianbing110的专栏
05-29 1万+
spring in action第三版读书笔记 spring3.0引入了spring expression language(spel)语言,通过spel我们可以实现 1.通过bean的id对bean进行引用 2.调用方法以及引用对象中的属性 3.计算表达式的值 4.正则表达式的匹配 5.集合的操作 spel最终的目标是得到表达式计算之后的值，这些表达式可能是列举的一些值，引
Spring-SpEL表达式
雨后是冰雹
01-14 730
SpEL表达式简介用法1. 注解@Value2. XML配置3. Expression表达式语法 简介 Spring Expression Language（缩写为SpEL）是一种强大的表达式语言。在Spring 产品组合中，它是表达式计算的基础。它支持在运行时查询和操作对象图，它可以与基于 XML 和基于注解的 Spring 配置还有 bean 定义一起使用。由于它能够在运行时动态分配值，因此可以为我们节省大量Java代码。 依赖： 在这里插入代码片 用法 SpEL有三种用法，一种是在注解@Value中
Spring spel表达式使用方法示例
08-29
Spring spel表达式使用方法示例 Spring spel表达式是一种功能强大且灵活的表达式语言，它允许开发者在Spring应用程序中使用表达式来实现复杂的逻辑操作。 Spring spel表达式可以用于引用bean、调用方法、计算表达式...
spring spEL 表达式详解
02-05
- Spring框架提供了`org.springframework.expression.spel.standard.SpelExpressionParser`类来解析SpEL表达式。 - 通过`parseExpression(String expression)`方法解析表达式，然后使用`getValue(Object root...
Spring组件开发模式支持SPEL表达式
08-26
Spring组件开发模式支持SPEL表达式 Spring框架作为Java企业级应用程序的主流框架，提供了强大的组件开发模式，支持SPEL（Spring Expression Language）表达式，使得开发者能够更加灵活地使用表达式来实现业务逻辑。...
Spring_SpEl表达式使用用例
09-13
**Spring SpEL表达式使用详解** Spring Expression Language (SpEL)是Spring框架中的一种强大而灵活的表达式语言，主要用于在运行时查询和操作对象图。它提供了在配置元数据中进行表达式评估的能力，使得我们可以...
Spring实战之Bean定义中的SpEL表达式语言支持操作示例
08-25
主要介绍了Spring实战之Bean定义中的SpEL表达式语言支持操作,结合实例形式分析了Bean定义中的SpEL表达式语言操作步骤与实现技巧,需要的朋友可以参考下
Spring：SpEL表达式（了解）
chen2iu的博客
04-16 203
一、什么是SpEL表达式 SpEL表达式语言是一种表达式语言，是一种可以与一个基于spring的应用程序中的运行时对象交互的东西，总得来说SpEL表达式是一种简化开发的表达式，通过使用表达式来简化开发，减少一些逻辑、配置的编写。 二、简单的配置代码实现 1、Address和Customer类 public class Address { private String name; public String getName() { return name; }
Spring - XML方式SpEL方法注入（07）
isjinhao的博客
09-11 605
概述 在我们之前的样例中，注入的属性都是静态的基本数据类型或者是已存在的bean，但有时候我们希望某方法的返回值作为属性注入，像这种动态的属性注入就得使用到spEL。这是Spring开发的一个语法规则，可以支持很多 # # # # # # # # #...
spring中的SpEL表达式
计算机毕业论文源码，学生个人网页制作html源码。贴近用户做网络推广和互联网优化。
12-31 281
从Spring 3开始引入了Spring表达式语言，它能够以一种强大而简洁的方式将值装配到Bean属性和构造器参数中，在这个过程中所使用的表达式会在运行时计算得到值。使用SpEL你可以实现超乎想象的装配效果，这是其他装配技术很难做到的。它包含了很多特性，包括：使用bean的ID来引用bean调用方法和访问对象的属性对值进行...
Spring表达式语言:SpEL
qq_43687990的博客
10-09 472
简介 Spring表达式语言(简称SpEL):是一个支持运行时查询和操作对象图的强大的表达式语言。语法类似EL:SpEL使用#{…}作为定界符，所有在大括号中的字符都将被认为SpEL。SpEL为bean属性的动态赋值提供了便利。 通过 SpEL 可以实现： 通过 bean 的 id 对 bean 进行引用 调用方法以及引用对象中的属性 计算表达式的值 正则表达式的匹配 1.字面量的赋值 <!...
Spring3系列6 - Spring 表达式语言(Spring EL)
weixin_33713707的博客
02-10 248
Spring3系列6-Spring 表达式语言(Spring EL) 　　本篇讲述了Spring Expression Language —— 即Spring3中功能丰富强大的表达式语言，简称SpEL。SpEL是类似于OGNL和JSF EL的表达式语言，能够在运行时构建复杂表达式，存取对象属性、对象方法调用等。所有的SpEL都支持XML和Annotation两种方式，格式：#{ SpEL exp...
Sping-Spring表达式语言SpEL
小工匠
04-08 1万+
概述 SpEL：字面量 SpEL：引用 Bean、属性和方法 引用其他对象 引用其他对象的属性 调用其他方法，还可以链式操作 调用静态方法或静态属性 SpEL支持的运算符号 算数运算符：+, -, *, /, %, ^ 加号还可以用作字符串连接 比较运算符： &lt;, &gt;, ==, &lt;=, &gt;=, lt, gt, eq, le, ge 逻辑运算符号： and, or, ...
Spring 表达式语言之 SpEL 语法
热门推荐
夜-feng的专栏
07-14 1万+
5.3 SpEL语法 5.3.1 基本表达式 一、字面量表达式： SpEL支持的字面量包括：字符串、数字类型（int、long、float、double）、布尔类型、null类型。 类型 示例 字符串 String str1 = parser.parseExpression(“‘Hello World!’”).getValue(String.class); Strin
Spring 中配置文件里SPEL表达式的使用
weixin_47371330的博客
09-16 3350
在配置中使用SpEL表达式 #{表达式} <bean id="str" class="java.lang.String" c:original="hello"/> <bean id="bean2" class="com.example.spring.di.spel.Bean2"> <!-- SpEL表达式，是在Spring配置文件中原生支持的。 --> <property name="dbConfig" value=
SpEL表达式 绑定方法参数
05-26
在Spring中，可以使用SpEL表达式绑定方法参数。具体步骤如下： 1. 在方法参数上添加@org.springframework.web.bind.annotation.RequestParam注解（或其他适当的注解），并指定SpEL表达式作为其属性值。 2. 在方法...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值