精华内容
下载资源
问答
  • SpEl

    2021-05-05 09:51:53
    SpEl 创建简单java类 package com.atguigu.bean; public class Car { private String carName; public String getCarName() { return carName; } public void setCarName(String carName) { this....

    SpEl

    1. 创建简单java类

      package com.atguigu.bean;
      
      public class Car {
      
      	private String carName;
      
      	public String getCarName() {
      		return carName;
      	}
      
      	public void setCarName(String carName) {
      		this.carName = carName;
      	}
      
      	public Car(String carName) {
      		super();
      		this.carName = carName;
      	}
      
      	public Car() {
      		super();
      	}
      
      	@Override
      	public String toString() {
      		return "Car [carName=" + carName + "]";
      	}
      	
      }
      
      
      package com.atguigu.bean;
      
      public class Person {
      
      	private String lastName;
      	private Integer age;
      	private String gender;
      	private String email;
      	private Car car;
      	
      	
      	
      	public Person(Car car02) {
      		super();
      		this.car = car02;
      	}
      
      	public void myInit(){
      		System.out.println("Person对象被初始化了");
      	}
      	
      	public void myDestory(){
      		System.out.println("Person对象被销毁了");
      	}
      	
      	public Person() {
      		super();
      		System.out.println("Person对象被创建了");
      	}
      	public Person(String lastName, Integer age, String gender, String email) {
      		super();
      		this.lastName = lastName;
      		this.age = age;
      		this.gender = gender;
      		this.email = email;
      	}
      	public String getLastName() {
      		return lastName;
      	}
      	public void setLastName(String lastName) {
      		this.lastName = lastName;
      	}
      	public Integer getAge() {
      		return age;
      	}
      	public void setAge(Integer age) {
      		this.age = age;
      	}
      	public String getGender() {
      		return gender;
      	}
      	public void setGender(String gender) {
      		this.gender = gender;
      	}
      	public String getEmail() {
      		return email;
      	}
      	public void setEmail(String email) {
      		this.email = email;
      	}
      	
      	public Car getCar() {
      		return car;
      	}
      	public void setCar(Car car) {
      		this.car = car;
      	}
      	@Override
      	public String toString() {
      		return "Person [lastName=" + lastName + ", age=" + age + ", gender=" + gender + ", email=" + email + ", car="
      				+ car + "]";
      	}
      	
      }
      
      
    2. 编写配置文件,使用SpEL

      <?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.xsd">
      
      	<bean id="car" class="com.atguigu.bean.Car">
      		<property name="carName" value="宝马"></property>
      	</bean>
      
      	<!-- SpEL(spring expression language)spring表达式语言
      		 在SpEL中使用字面量
      		  引用其他bin
      		  引用其他bean的某个属性
      		调用非静态方法 
      		调用静态方法
      		 使用运算符 -->
      	<bean id="person01" class="com.atguigu.bean.Person">
      		<!-- 使用运算符 -->
      		<property name="age" value="#{12*5}"></property>
      		<!-- 取出其他bean的属性值 -->
      		<property name="lastName" value="#{car.carName}"></property>
      		<!-- 引用其他bin -->
      		<property name="car" value="#{car}"></property>
      		<!-- 调用静态方法
      			假设email是用uuid生成的
      			UUID.randomUUID().toString();
      			需要满足规则:(T(全类名).静态方法(参数))
      		 -->
      		<property name="email" value="#{T(java.util.UUID).randomUUID().toString().substring(0,5)}"></property>
      		<!-- 调用非静态方法; 对象.方法名 -->
      		<property name="gender" value="#{car.getCarName()}"></property>
      	</bean>
      </beans>
      
      
    3. 测试

      package com.atguigu.test;
      
      import org.junit.Test;
      import org.springframework.context.ApplicationContext;
      import org.springframework.context.support.ClassPathXmlApplicationContext;
      
      public class SpEl {
      
      	@Test
      	public void test(){
      		
      		ApplicationContext con = new ClassPathXmlApplicationContext("bean_spel.xml");
      		Object bean = con.getBean("person01");
      		System.out.println(bean);
              //Person对象被创建了
      		//Person [lastName=宝马, age=60, gender=宝马, email=8c55b, car=Car [carName=宝马]]
      		
      	}
      	
      }
      
      
    展开全文
  • SpEL

    千次阅读 2019-03-29 16:00:56
    Spring Expression Language (SpEL) Spring的SpEL表达是存在于org.springframework.expression和其子包中。一个简答的实现例子 ExpressionParser parser = new SpelExpressionParser(); Expression exp = parser....

    Spring Expression Language (SpEL)

    Spring的SpEL表达是存在于org.springframework.expression和其子包中。一个简答的实现例子

    ExpressionParser parser = new SpelExpressionParser();
    Expression exp = parser.parseExpression("'Hello World'"); 
    String message = (String) exp.getValue();
    

    SpEL提供了例如调用方法,访问属性,调用构造函数等功能。
    调用方法:

    ExpressionParser parser = new SpelExpressionParser();
    Expression exp = parser.parseExpression("'Hello World'.concat('!')"); 
    String message = (String) exp.getValue();
    

    访问属性

    ExpressionParser parser = new SpelExpressionParser();
    
    // invokes 'getBytes()'
    Expression exp = parser.parseExpression("'Hello World'.bytes"); 
    byte[] bytes = (byte[]) exp.getValue();
    

    调用构造函数

    ExpressionParser parser = new SpelExpressionParser();
    Expression exp = parser.parseExpression("new String('hello world').toUpperCase()"); 
    String message = exp.getValue(String.class);
    

    下面的表达式实现了从某个具体的对象中获取参数并操作

    // Create and set a calendar
    GregorianCalendar c = new GregorianCalendar();
    c.set(1856, 7, 9);
    
    // The constructor arguments are name, birthday, and nationality.
    Inventor tesla = new Inventor("Nikola Tesla", c.getTime(), "Serbian");
    
    ExpressionParser parser = new SpelExpressionParser();
    
    Expression exp = parser.parseExpression("name"); 
    String name = (String) exp.getValue(tesla);
    // name == "Nikola Tesla"
    
    exp = parser.parseExpression("name == 'Nikola Tesla'");
    boolean result = exp.getValue(tesla, Boolean.class);
    // result == true
    
    展开全文
  • spel

    千次阅读 2018-09-25 09:02:48
    SPEL:spring Exoression Language 1、spel表达式一般放入:#{…}中 2、占位符 用${…}标示 举例:#{1} 标示数字1 #{T(System).currentTimeMillions()} 标示当前时间 3、java中用@Value("#{}") 标示 4、xml中...

    SPEL:spring Exoression Language

    1、spel表达式一般放入:#{…}中
    2、占位符 用${…}标示
    举例:#{1} 标示数字1
    #{T(System).currentTimeMillions()} 标示当前时间
    3、java中用@Value("#{}") 标示
    4、xml中 c:title="#{System}"
    5、#{} 可以描述boolean,double,String,bean,和bean的属性,和bean的方法
    #{bean.method()}

    6、#{arties.Selector.selectArtist()?.toUpperCase()}
    描述:当左边的结果为null时,不会调用toUpperCase方法
    7、T(java.lang.Math).PI
    标示π

    8、spel运算符和java类中的类似,都是在spel表达式内操作
    除此之外还有 三元运算符、正则等等等、

    展开全文
  • Spring SpEL

    2020-07-14 22:14:19
    文章目录Spring SpEL一、JVM动态语言二、SpEL表达式三、SpEL的核心接口3.1 `ExpressionParser`(1) 字符串的拼接3.2 `EvaluationContext`(2) 针对特定实例对象的属性进行求值3.3 `SpelCompiler`可以将字节码直接编译...

    Spring SpEL

    一、JVM动态语言

    作用:表达式语句的动态解析。

    项目中的实践:在项目开发中,遇到一种场景,需要根据公式计算数据,而涉及到很多公式,并且公式可能会有变动。因此,在开发中我就使用到了动态解析这种方案——将计算公式存到表中。能够非常灵活地计算出结果。

    Java6.0 中内置集成了Mozila Rhino的JavaScript解析引擎,因此可以很方便地在Java中调用JavaScript函数。

    动态求和函数:

        public static void main(String[] args) throws ScriptException, NoSuchMethodException {
            ScriptEngineManager manager = new ScriptEngineManager();
            ScriptEngine engine = manager.getEngineByName("JavaScript");
            String scriptText = "function sum(a,b){ return a+b;}";
            engine.eval(scriptText);
            Invocable invocable = (Invocable) engine;
            Object result = invocable.invokeFunction("sum", 100, 99);
            System.out.println(result instanceof Double);
            System.out.println(result);
        }
    

    二、SpEL表达式

    对于仅仅需要一些简单的表达式需求的场景,使用脚本语言显得有些“笨重”,这就是介绍SpEL表达式的原因。

    • SpEL具有显式方法调用和基本字符串模板函数等特性;

    • SpEL不直接依赖于Spring框架,可以独立使用;

      可以将SpEL作为独立的动态语言使用

    使用前需要引入spring-expression:

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-expression</artifactId>
        <version>${spring.version}</version>
    </dependency>
    
    public static void main(String[] args) {
        ExpressionParser parser = new SpelExpressionParser();
        Expression expression = parser.parseExpression("'hello' + ' world'");
        String message= (String) expression.getValue();
        System.out.println(message);
    }
    

    三、SpEL的核心接口

    3.1 ExpressionParser

    (1) 字符串的拼接

    private static void testStrConcat(){
        ExpressionParser parser = new SpelExpressionParser();
        Expression expression = parser.parseExpression("'HelloWorld'.concat('!')");
        String value = (String)expression.getValue();
        System.out.println(value);
        System.out.println(expression.getValue(String.class));
    }
    

    3.2 EvaluationContext

    (2) 针对特定实例对象的属性进行求值

    创建StandardEvaluationContext实例时,指定一个跟对象作为求值的目标对象。

    private static void objPropertiesValue(){
        User user = new User();
        user.setUserName("XiaoMing");
        user.setCredits(100);
        ExpressionParser parser = new SpelExpressionParser();
        EvaluationContext context = new StandardEvaluationContext(user);
        Object userName = parser.parseExpression("userName").getValue(context);
        System.out.println(userName);
    }
    

    3.3 SpelCompiler可以将字节码直接编译成字节码

    • 由于SpelCompiler直接将表达式编译成字节码,避免了每次调用时的语法解析消耗
        public static void main(String[] args) {
            User user = new User();
            // 创建解析配置
            SpelParserConfiguration configuration = new SpelParserConfiguration(SpelCompilerMode.IMMEDIATE,
                    CompilerSample.class.getClassLoader());
            // 创建解析器
            SpelExpressionParser parser = new SpelExpressionParser(configuration);
    
            // 创建获取上下文
            EvaluationContext context = new StandardEvaluationContext(user);
    
            // 表达式
            String expression = "isVipMember('tom') && isVipMember('pip')";
    
            // 解析表达式
            Expression spELExpression = parser.parseRaw(expression);
    
            // 通过表达式求值
            System.out.println(spELExpression.getValue(context));
            System.out.println(spELExpression.getValue(context));
        }
    

    四、SpEL表达式

    4.1 文本字符解析

    文本表达式支持字符串、日期、数字(正数、实数及十六进制数)、布尔类型及null。

        public static void main(String[] args) {
            ExpressionParser parser = new SpelExpressionParser();
    
            String helloWorld = parser.parseExpression("'Hello World'").getValue(String.class);
    
            double doubleNumber = (Double) parser.parseExpression("6.0221415E+23").getValue();
            System.out.println(doubleNumber);// 6.0221415E23
            
        }
    

    4.2 对象属性解析

    使用类似“xxx.yyy.zzz”的对象属性路径轻松访问对象属性值。

    4.3 数组、集合类型解析

    在SpEL中,支持数组、集合类型(Map、List)的解析。

    4.4 方法解析

    • 支持Java可访问方法。私有方法是不能调用的;
    • 可以调用String类型的所有可访问的方法;

    4.5 操作符解析

    (1) 关系操作符

    > >= < <= ==、正则表达式、instanceof操作符

    (2)逻辑操作符

    and 或 &&or 或 ||、非操作!

    (3)算术运算操作符

    • 加法运算可用于数字、字符串、日期;
    • 减法运算可用于数字和日期;
    • 乘法和除法运算符仅用于数字;
    • 还支持%、指数幂^

    4.6 安全导航运算符(避免了空指针对象验证)

    格式为在“.”前面添加一个“?”

    如果user为空,则直接返回null,如果不为空,则获取属性值。

    "user?.userName"
    

    4.7 三元运算符

        public static void main(String[] args) {
            User user = new User();
            user.setUserName("Tom");
    
            ExpressionParser parser = new SpelExpressionParser();
            StandardEvaluationContext context = new StandardEvaluationContext(user);
    
            String result = parser.parseExpression("userName=='Tom'?'hello '+userName:'not Tom'").getValue(context, String.class);
            System.out.println(result);
        }
    

    4.8 Elvis运算符

    <var>?:<value> 如果左边变量取值为null,就取value值,否则就取var变量自身的值。

           user.setUserName(null);
            String elvisValue = parser.parseExpression("userName?:'empty Username'").getValue(context, String.class);
            System.out.println(elvisValue);
    

    4.9 赋值、类型、构造器、变量

    赋值

        public static void main(String[] args) {
            User user = new User();
            user.setUserName("Tom");
            ExpressionParser parser = new SpelExpressionParser();
            EvaluationContext context = new StandardEvaluationContext(user);
            // 通过 setValue赋值
            parser.parseExpression("userName").setValue(context, "XiaoMing");
            System.out.println(user.getUserName());
            // 通过 表达式赋值
            parser.parseExpression("userName='xiaoHong'").getValue(context);
            System.out.println(user.getUserName());
        }
    

    类型

    • 如果加载的目标类位于java.lang包下,则可以不带包名;
    • T操作符还可以直接调用类静态方法;
        public static void main(String[] args) {
            ExpressionParser parser = new SpelExpressionParser();
    
            Class stringClass = parser.parseExpression("T(java.lang.String)").getValue(Class.class);
            System.out.println(stringClass == String.class);
    
            //  直接调用静态方法
            Object randomValue = parser.parseExpression("T(java.lang.Math).random()").getValue();
            System.out.println(randomValue);
        }
    

    构造器

        public static void main(String[] args) {
            ExpressionParser parser = new SpelExpressionParser();
            User value = parser.parseExpression("new com.hef.beans.User('aaa')").getValue(User.class);
            System.out.println(value);
        }
    

    变量

    // 设置一个变量
    EvaluationContext context = new StandardEvaluationContext(value);
    context.setVariable("oneUserName", "Tom");
    parser.parseExpression("userName=#oneUserName").getValue(context);
    System.out.println(value.getUserName());
    

    4.10 集合过滤

        public static void main(String[] args) {
            ExpressionParser parser = new SpelExpressionParser();
            EvaluationContext context = new StandardEvaluationContext();
            // 过滤list
            List<Integer> valueList = new ArrayList<>();
            valueList.addAll(Arrays.asList(2,3,6,10,5,11,13));
            context.setVariable("list", valueList);
            List<Integer> value = (List<Integer>) parser.parseExpression("#list.?[#this>5]").getValue(context);
            System.out.println(value);
            // 过滤map
            Map<String, Integer> map = new HashMap<>();
            map.put("aa", 23);
            map.put("bb", 12);
            map.put("cc", 6);
    
            context.setVariable("map", map);
            // 过滤出子集
            Map<String, Integer> map1= (Map<String, Integer>) parser.parseExpression("#map.?[value>7]").getValue(context);
            System.out.println(map1);
            // 取第一个值
            Map<String, Integer> map2= (Map<String, Integer>) parser.parseExpression("#map.^[value>7]").getValue(context);
            System.out.println(map2);
            // 取最后一个值
            Map<String, Integer> map3= (Map<String, Integer>) parser.parseExpression("#map.$[value>7]").getValue(context);
            System.out.println(map3);
        }
    

    4.11 集合转换

            // 集合的转换
            List<Boolean> booleanList= (List<Boolean>) parser.parseExpression("#list.![#this>10]").getValue(context);
            System.out.println(booleanList);
    

    五、在Spring中使用SpEL

    5.1 基于XML配置

    5.2 基于注解的配置

    #{properties['password']}

    展开全文
  • SpEL-demo 一个SpEL的练习 解析字符串为文本 解析字符串为对象,实例方法调用 解析字符串为集合 在XML中使用SpEL,使用两个配置文件systemProperties和SystemEnvironments 在注解中使用SpEL(使用util:properties标签...
  • spel表达式

    2019-09-01 17:45:48
    spel总结 背景:在Spring Boot 中经常通过#{}或者${}这两种方式挂到属性上面进行获取内容,但是又经常获取不到,现在来仔细了解一下这两个的区别。 Spel表达式 例子 ​ spel 表达式(Spring Expression Language),...
  • ts-spel 解析器评估器
  • SpEL表达式

    2019-04-14 16:08:30
    Spring 表达式语言(简称SpEL):是一个支持运行时查询和操作对象图的强大的表达式语言。 语法类似于 EL:SpEL 使用 #{...} 作为定界符 , 所有在大括号中的字符都将被认为是 SpEL , SpEL 为 bean 的属性进行动态赋值...
  • Spel表达式

    2020-07-08 19:49:04
    8.Spring 表达式语言 (SpEL) 8.1介绍 Spring表达式语言(简称SpEl)是一个支持查询和操作运行时对象导航图功能的强大的表达式语言. 它的语法类似于传统EL,但提供额外的功能,最出色的就是函数调用和简单字符串的...
  • SpEL表达式总结

    万次阅读 多人点赞 2018-08-10 18:37:00
    SpEL(Spring Expression Language),即Spring表达式语言,是比JSP的EL更强大的一种表达式语言。为什么要总结SpEL,因为它可以在运行时查询和操作数据,尤其是数组列表型数据,因此可以缩减代码量,优化代码结构。...
  • SpEL 表达式

    万次阅读 2017-04-01 17:32:17
    前言:Spring表达式语言(简称SpEL)是一种与JSP2的EL功能类似的表达式语言,它可以在运行时查询和操作对象图。与JSP2的EL相比,SpEL功能更加强大,它甚至支持方法调用和基本字符串模板函数。SpEL可以独立于Spring容器...
  • spEl 表达式

    2019-12-08 22:19:01
    Spring 表达式语言 Spring Expression Language(简称 SpEL )是一个支持运行时查询和操作对象图的表达式语言 。 语法类似于 EL 表达式 ,但提供了显式方法调用和基本字符串模板函数等额外特性 。SpEL 虽然作为 ...
  • 015 spel

    2018-05-27 00:09:00
     在spring3.x之中提出了spel的方式,其目的就是在静态语言之中增加动态语言的能力. 实际上我们可以和IOC容器实现一些特别的功能. 二 . 简单的演示 @Test public void test() { //创建一个spel的表达式...
  • 2D--Spel-Absamoze 2D--Spel-Absamoze
  • 主要介绍了Spring spel表达式使用方法示例,通过一些实例向大家展示了spel表达式的用法,需要的朋友可以了解下。
  • SPEL表达式

    2020-04-16 18:44:26
    说到SPEL表达式,就容易联想到EL表达式,EL表达式是JSP的,使用起来非常方便,关于EL表达式不记得的同学去翻翻下面这个网址https://www.runoob.com/jsp/jsp-expression-language.html 下面这个博主的文章记录的比较...
  • SpEL运算符

    千次阅读 2016-07-08 18:54:20
    SpEL提供了几种运算符,这些运算符可以用在SpEL表达式中的值上。 运算符类型 运算符 算术运算 +、-、*、/、%、^ 关系运算 <、>、==、、>=、lt、gt、eq、le、ge 逻辑运算 and、or、not、| 条件运算 ?:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 21,602
精华内容 8,640
关键字:

spel