SpringEL表达式注入

2022-07-27

Spring生态

Spring开源框架由Rod Johnson创建，从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。时至今日Spring已经不再是一个简单的编程框架了，在整个Spring生态中包含了许多应用在特定场景的具体框架，如”Spring Framework”,”Spring Security”，“Srping Boot”，”Spring Cloud“等等。其中Spring Framework框架是整个生态的核心基础，每个框架都有自己独立的代码仓库。

Spring生态系统提供许多有用的编程框架或工具集，当下最为流行的Spirng项目：Spring Framework，Spring Security，Spring Boot，Spring Cloud等。

Spring Framework

SpringFramework项目是整个Spring生态的基础，Spring Framework项目又包含多个子模块，如：spring-core，spring-beans，spring-context，spring-aop，spring web，spring-webmvc等等。

Spring Boot

Spring Boot是一个开发基于Spring Framework的项目，它默认继承了嵌入式的Tomcat，配置注解化，支持快速集成第三方开发组件(如Mybatis)，大大降低了使用Spring的门槛，而且内置了许多可以直接用于生产环境的功能，是目前用于开发微服务架构项目的不二选择。

Spring Cloud

Spring Cloud为开发基于微服务架构的软件系统提供了一整套工具集合，其中包含了开发各个微服务组件的具体项目，如:Spring Cloud Conifg，Spring Cloud Netflix , Spring Cloud Sletuth , Spring Cloud Gateway等等。Spring Cloud的基础是Spring Boot，基于Spring Boot可以大大简化开发各微服务组件的流程。

Spring Security

Spring Security是用于实现认证和授权，以及访问控制的安全框架，在java生态与之提供类似的功能还有一个框架:Apache Shiro.Spring Security依赖于Spring Framework，也就是说如果要使用Spring Security，那么应用架构也必须是基于Spring Framework的。这大大限制了Spring Security的使用场景；反之，Shiro就没有这样限制，而且从项目架构上Shiro更加间接。Spring Security提供了非常丰富的安全控制的功能，在某些方面甚至比Shiro更加完善，与之对应的是掌握Spring Security的复杂度比较大。因此，对于在应用中是否选择Spring Security需要根据实际需求来决定。

Spel表达式

在Spring3中引入了Spring表达式语言，支持在运行时查询和操作对象图，可以与基于XML和基于注解的Spring配置还有bean定义一起使用，表达式语言给静态Java语言增加了动态功能。Spel是单独模块，只依赖于core模块，不依赖于其他模块，可以单独使用，因为Spel是以API接口的形式创建的，所以允许将其集成到其他应用程序和框架中。

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

变量

变量通过EvaluationContext接口的setVariable(variableName,value)方法定义，在表达式使用#variableName引用，除了引用自定义变量，Spel还允许引用根对象及当前上下文对象，使用#root引用根对象，使用#this引用当前上下文对象。

ExpressionParser parser = new SpelExpressionParser();
EvaluationContext context = new StandardEvaluationContext("test");
context.setVariable("variable", "test");
String result1 = parser.parseExpression("#variable").getValue(context,
Str
ing.class);
System.out.println(result1); //test
String result2 = parser.parseExpression("#root").getValue(context,
String.
class);
System.out.println(result2); //test
String result3 = parser.parseExpression("#this").getValue(context,
String.
class);
System.out.println(result3); //test

类型表达式

在Spel表达式中，使用T(Type)运算符会调用类的作用域和方法。换句话说，就是可以通过该类类型表达式来操作类。使用T(Type)来表示java.lang.Class实例，Type必须是类全限定名，”java,lang”包除外，因为Spel已经内置了该包，即该包下的类可以不指定具体的报名，使用类类型表达式还可以进行访问静态方法和类静态字段。

例如，在XML配置文件中的使用示例，要调用java.lang.Math来获取0-1的的随机数

1	<property name="random" value="#{T(java.lang.Math).random()}"/>

例1：Expression表达式引用：

public class Demo {
    /**
     * Expression表达式应用
     */
    public static void test1(){
        ExpressionParser parser = new SpelExpressionParser();

        // java.lang 包类访问
        Class<String> result1 = parser.parseExpression("T(String)").getValue(Class.class);
        System.out.println(result1);  // class java.lang.String

        //类静态字段访问
        int result3 = parser.parseExpression("T(Integer).MAX_VALUE").getValue(int.class);
        System.out.println(result3); // 2147483647

        //类静态方法调用
        int result4 = parser.parseExpression("T(Integer).parseInt('1')").getValue(int.class);
        System.out.println(result4); // 1

    }
    public static void main(String[] args) {
        test1();
    }
}

例2：基于xml实现表达式求值，表达式使用T(Type)运算符

实体类：

public class HelloWorld {
    private String message;

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

    public void getMessage(){
        System.out.println("Your Message : " + message);
    }

}

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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">

    <bean id="helloWorld" class="TType.HelloWorld">
        <property name="message" value="#{T(java.lang.Math).random()}" />
    </bean>

</beans>

测试方法：

ApplicationContext context = new
ClassPathXmlApplicationContext("file:/Spe
l1.xml");
HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
obj.getMessage();

例3：表达式使用T(Type)运算符调用执行代码的操作类

<?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-3.0.xsd ">

    <bean id="helloWorld" class="TType.HelloWorld">
        <property name="message" value="#{T(java.lang.Runtime).getRuntime().exec('calc')}" />
    </bean>

</beans>

测试方法：

ApplicationContext context = new
ClassPathXmlApplicationContext("file:/Spe
l2.xml");
HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
obj.getMessage();

Spel表达式用法

基于注解
xml配置
代码块中使用Expression

定界符

Spel使用#{}作为定界符，所以在大括号中的字符都将被认为是Spel表达式，在其中可以使用Spel运算符，变量，引用bean及其属性和方法等。

#{}是Spel的定界符，用于指明Spel表达式并执行；${}主要用于加载外部属性文件中的值。
#{} 和 ${} 可以混合使⽤，但是必须 #{} 在外⾯，${} 在⾥⾯，如 #{’${}’}，注意单引号是字符串类型才添加的。

基于注解Annotation

@Value注解可以放在字段、方法和方法/构造参数里，以指定默认值。

例如：修饰成员变量，Spring容器会根据SpEL表达式语法筛选修改数据，然后赋值给@Value修饰的变量。

1 2	@Value("#{表达式}") public String arg;

比如可以:

package anno;
import org.springframework.beans.factory.annotation.Value;
/**
* Student实体类
**/public class Student {
private String name;
private int age;
private String sex;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
    
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", sex='" + sex + '\'' +
'}';
 }
public Student(String name, int age, String sex){
this.name = name;
this.age = age;
this.sex = sex;
}
public class Student {

private String name;


private int age;

private String sex;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", sex='" + sex + '\'' +
'}';
}
public Student(String name, int age, String sex){
this.name = name;
this.age = age;
this.sex = sex;
}
public Student(){
}
}

配置类Myconfig

package anno;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
/**
* 在配置类中将Bean注⼊IOC容器
**/
@Configuration
public class MyConfig {
@Bean
public static Student student() {
return new Student();
}
}

测试代码

AnnotationConfigApplicationContext applicationContext = new
AnnotationConf
igApplicationContext(MyConfig.class);
Student student = (Student) applicationContext.getBean("student");
System.out.println(student);

结果是空的，没有赋值。

可以直接在配置文件中进行属性赋值，调用有参构造函数

配置类文件myconfig

@Configuration
//@PropertySource(value={"classpath:/student.properties"})
public class MyConfig {
    @Bean
    public static Student student() {
        //return new Student();
        return new Student("tom",2,"boy");
    }
}

这样输出的值就会产生赋值。

基于xml配置实现

student实体类

package xml;

/**
 * Student实体类
 **/
public class Student {
    private String name;
    private int age;
    private String sex;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                '}';
    }

}

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:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd">

    <bean id="student" class="xml.Student">
        <property name="name" value="Tom"/>
        <property name="age" value="#{ T(java.lang.Math).random() * 10.0 }"/>
        <property name="sex" value="Boy"/>
    </bean>
</beans>

测试代码

public class Demo2 {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("file:xml\\SpEL.xml");
        Student student = (Student) context.getBean("student");
        System.out.println(student);
        // 输出：Student{name='Tom', age=*, sex='Boy'}
    }

}

代码块中使用Expression

ExpressionParser:表示解析器，默认实现是org.springframework.expression.spel.standard包中的SpelExpressionParser 类，使用parseExpression方法将字符串表达式转换为Expression对象，对于parseContext接口，用于定义字符串表达式是不是模板，及模板开始与结束字符。
EvaluationContext:表示上下文环境，默认实现是 org.springframework.expression.spel.support 包中的 StandardEvaluationContext 类,使用setRootObject方法来设置根对象，使用setVariable ⽅法来注册⾃定义变量，使⽤ registerFunction 来注册⾃定义函数等等。
Expression：表示表达式对象，默认实现是org.springframework.expression.spel.standard 包中的 SpelExpression，提供getValue方法用于获取表达式值，提供setValue方法用于设置对象值。

例如：

public static void test1(){
       // 第一步 创建解析器：SpEL使用ExpressionParser接口表示解析器，提供SpelExpressionParser默认实现
       ExpressionParser parser = new SpelExpressionParser();

       // 第二步 解析表达式：使用ExpressionParser的parseExpression来解析相应的表达式为Expression对象，这里调用concat方法进行拼接
       Expression expression = parser.parseExpression("('Hello' + ' World').concat(#end)");

       // 第三步 构造上下文：准备比如变量定义等等表达式需要的上下文数据
       EvaluationContext context = new StandardEvaluationContext();
       context.setVariable("end", "!");

       // 第四步 求值：通过Expression接口的getValue方法根据上下文获得表达式值
       System.out.println(expression.getValue(context));
   }

SpEl表达式注入

EvaluationContext 表示上下⽂环境，系统提供了2个EvaluationContext接⼝实现类

SimpleEvaluationContext:仅支持Spel语言语法的一个子集，不包括java类型引用，构造函数和bean引用。
StandardEvaluationContext:支持全部Spel语法，在不指定EvaluationContext的情况下默认采用的是StandardEvaluationContext。

SpEl表达式是可以操作类及其方法的，可以通过类型表达式T(Type)来调用任意类方法。在不指定EvaluationContext的情况下默认采用的是StandardEvaluationContext，而它包含了SPEL的所有功能，允许用户在可以控制输入的情况下成功造成任意代码执行。

例如：

public static void test1(){
       String spel = "T(java.lang.Runtime).getRuntime().exec(\"calc\")";
       ExpressionParser parser = new SpelExpressionParser();
       Expression expression = parser.parseExpression(spel);
       System.out.println(expression.getValue());

   }