Spring表达式语言

最新推荐文章于 2024-08-02 09:30:00 发布

外星球的地球人是外星人吗？

最新推荐文章于 2024-08-02 09:30:00 发布

阅读量173

点赞数

本文链接：https://blog.csdn.net/wjl__ai__/article/details/116268694

版权

基础使用

import org.springframework.expression.EvaluationContext;
import org.springframework.expression.Expression;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;

public class SpELFirstDemo {
	public static void main(String[] args) {
		String str = "(\"Hello \" + \"World !!!\").substring(6,12)" ;	// 表达式定义
		// 1、定义一个专属的表达式的解析工具
		ExpressionParser parser = new SpelExpressionParser() ;	// 定义一个Spring表达式解析器
		// 2、定义一个表达式的处理类
		Expression exp = parser.parseExpression(str) ;	// 从字符串里面解析出内容
		// 3、进行最终表达式的计算
		EvaluationContext context = new StandardEvaluationContext() ;
		// 4、通过表达式进行结果的计算
		System.out.println(exp.getValue(context));
	}
}

变量

import org.springframework.expression.EvaluationContext;
import org.springframework.expression.Expression;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;

public class SpELFirstDemo {
	public static void main(String[] args) {
		String str = "(\"Hello \" + \"World !!!\").substring(#start,#end)" ;	// 表达式定义
		ExpressionParser parser = new SpelExpressionParser() ;		// Spring表达式解析器
		Expression exp = parser.parseExpression(str) ;				// 解析表达式
		EvaluationContext context = new StandardEvaluationContext() ;	// 上下文计算
		context.setVariable("start", 6); 							// 定义变量
		context.setVariable("end", 12);								// 定义变量
		System.out.println(exp.getValue(context));					// 表达式计算
	}
}

表达式

import org.springframework.expression.EvaluationContext;
import org.springframework.expression.Expression;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;

public class SpELFirstDemo {
	public static void main(String[] args) {
		String str = "10 + 20" ;	// 表达式字符串
		ExpressionParser parser = new SpelExpressionParser() ;		// Spring表达式解析器
		Expression exp = parser.parseExpression(str) ;				// 解析表达式
		EvaluationContext context = new StandardEvaluationContext() ;	// 上下文计算
		Integer result = (Integer) exp.getValue(context) ;				// 表达式计算
		System.out.println(result);	
	}
}

自定义边界符

import org.springframework.expression.EvaluationContext;
import org.springframework.expression.Expression;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.ParserContext;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;

public class SpELFirstDemo {
	public static void main(String[] args) {
		String str = "#[10 + 20]" ;	// 表达式字符串
		ExpressionParser parser = new SpelExpressionParser() ;		// Spring表达式解析器
		Expression exp = parser.parseExpression(str,new ParserContext() {
			@Override
			public boolean isTemplate() {
				return true ;
			}
			@Override
			public String getExpressionSuffix() {
				return "]";
			}
			@Override
			public String getExpressionPrefix() {
				return "#[";
			}
		}) ;															// 解析表达式
		EvaluationContext context = new StandardEvaluationContext() ;	// 上下文计算
		Integer result = (Integer) exp.getValue(context) ;				// 表达式计算
		System.out.println(result);	
	}
}

Class类型表达式

package cn.mldn.mldnspring;

import org.springframework.expression.EvaluationContext;
import org.springframework.expression.Expression;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.ParserContext;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;

import java.util.Date;

public class SpELClassDemo01 {
	public static void main(String[] args) {
		String str = "T(java.lang.String)"; 	// 获取String的Class对象
		ExpressionParser parser = new SpelExpressionParser();
		Expression exp = parser.parseExpression(str);
		EvaluationContext context = new StandardEvaluationContext(exp);
		Class<?> cls = exp.getValue(context,Class.class);
		System.out.println(cls.getName());

		str = "T(Integer).parseInt('567')";		// 调用静态方法
//		ExpressionParser parser = new SpelExpressionParser();
		exp = parser.parseExpression(str);
		context = new StandardEvaluationContext(exp);
		Integer result = exp.getValue(context,Integer.class);
		System.out.println(result * 2);


		str = "new java.util.Date()";	// 实例化Date对象
		parser = new SpelExpressionParser();
		exp = parser.parseExpression(str);
		context = new StandardEvaluationContext(exp);
		Date result2 = exp.getValue(context,Date.class);
		System.out.println(result2);

		str = "1.1E10" ;	// 表达式字符串
		parser = new SpelExpressionParser() ;		// Spring表达式解析器
		exp = parser.parseExpression(str) ;				// 解析表达式
		context = new StandardEvaluationContext() ;	// 上下文计算
		Double result3 = exp.getValue(context,Double.class) ;				// 表达式计算
		System.out.printf("%11.2f",result3);			// 格式化输出
		System.out.println();

		str = "1 > 2 ? 'Hello':'World'" ;
		parser = new SpelExpressionParser();
		String result4 = parser.parseExpression(str).getValue(String.class);
		System.out.println(result4);

		parser = new SpelExpressionParser();
		String resultA = parser.parseExpression("null ?: \"www.mldn.cn\"").getValue(String.class);
		String resultB = parser.parseExpression("'mldn' ?: \"www.mldnjava.cn\"").getValue(String.class);
		System.out.println(resultA);	// 为null返回表达式2
		System.out.println(resultB);	// 不为null返回表达式1

		str = "'helloworld'[1]";
		parser = new SpelExpressionParser();
		exp = parser.parseExpression(str);
		context = new StandardEvaluationContext(exp);
		char value = exp.getValue(context,Character.class);
		System.out.println(value);

		str = "'www.mldn.cn'.toUpperCase()";
		parser = new SpelExpressionParser();
		exp = parser.parseExpression(str);
		context = new StandardEvaluationContext(exp);
		String result5 = exp.getValue(context,String.class);
		System.out.println(result5);


		str = "'www.mldn.cn'.toUpperCase().replaceAll('MLDN','mldnjava')";
		parser = new SpelExpressionParser();
		exp = parser.parseExpression(str);
		context = new StandardEvaluationContext(exp);
		String result6 = exp.getValue(context,String.class);
		System.out.println(result6);


		str = "'999' matches '\\d{3}'"; 	// 正则运算
		parser = new SpelExpressionParser();
		exp = parser.parseExpression(str);
		context = new StandardEvaluationContext(exp);
		boolean result7 = exp.getValue(context,Boolean.class);
		System.out.println(result7);

		str = "#[10 + 20]" ;	// 表达式字符串
		parser = new SpelExpressionParser() ;		// Spring表达式解析器
		exp = parser.parseExpression(str,new ParserContext() {
			@Override
			public boolean isTemplate() {
				return true ;
			}
			@Override
			public String getExpressionSuffix() {
				return "]";
			}
			@Override
			public String getExpressionPrefix() {
				return "#[";
			}
		}) ;															// 解析表达式
		context = new StandardEvaluationContext() ;	// 上下文计算
		Integer result8 = (Integer) exp.getValue(context) ;				// 表达式计算
		System.out.println(result8);



	}
}

变量设置

import org.springframework.expression.EvaluationContext;
import org.springframework.expression.Expression;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;

import java.lang.reflect.Method;
import java.util.Date;

public class SpELVarDemo01 {
	public static void main(String[] args) throws NoSuchMethodException {
		String str = "#myvar1 + #myvar2";				// 定义了两个变量
		ExpressionParser parser = new SpelExpressionParser();
		Expression exp = parser.parseExpression(str);
		EvaluationContext context = new StandardEvaluationContext(exp);
		context.setVariable("myvar1", "Hello ");		// 设置变量内容
		context.setVariable("myvar2", "World!");		// 设置变量内容
		String result = exp.getValue(context,String.class);
		System.out.println(result);
		
		str = "#myvar1 + #myvar2";				// 定义了两个变量
		parser = new SpelExpressionParser();
		exp = parser.parseExpression(str);
		context = new StandardEvaluationContext(exp);
		context.setVariable("myvar1", 100);		// 设置变量内容
		context.setVariable("myvar2", 200);		// 设置变量内容
		Integer result2 = exp.getValue(context,Integer.class);
		System.out.println(result2);

		str = "#root=='mldn' ? 'Hello MLDN' : '大家好'";	// 定义了两个变量
		parser = new SpelExpressionParser();
		exp = parser.parseExpression(str);	// 设置了一个自定义的根变量
		context = new StandardEvaluationContext("mldn");	// 根变量赋值
		String result3 = exp.getValue(context,String.class) ;
		System.out.println(result3);

		str = "#myInt('123')";					// 其中myInt表示的就是方法引用设置的别名
		Method method = Integer.class.getMethod("parseInt", String.class) ;	// 获取该方法引用的反射对象
		parser = new SpelExpressionParser();
		exp = parser.parseExpression(str);	// 设置了一个自定义的根变量
		StandardEvaluationContext context1 = new StandardEvaluationContext();
		context1.registerFunction("myInt", method); 		// 为myInt设置一个引用的具体方法
		Integer result4 = exp.getValue(context1,Integer.class) ;
		System.out.println(result4 * 2);

		str = "Time";							// Date类中的getTime()方法
		parser = new SpelExpressionParser();
		exp = parser.parseExpression(str);	// 设置了一个自定义的根变量
		context = new StandardEvaluationContext(new Date());
		Long result5 = exp.getValue(context,Long.class) ;
		System.out.println(result5);

		str = "#root?.time";									// Date类中的getTime()方法
		parser = new SpelExpressionParser();
		exp = parser.parseExpression(str);				// 设置了一个自定义的根变量
		context = new StandardEvaluationContext();// 不设置对象
		Long result6 = exp.getValue(context,Long.class) ;
		System.out.println(result6);
	}
}

集合表达式

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;

import org.springframework.expression.EvaluationContext;
import org.springframework.expression.Expression;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;

public class SpELCollectionDemo01 {
	public static void main(String[] args) {
		String str = "{'mldn','jixianit','mldnjava','mldn'}";				// 定义表达式
		ExpressionParser parser = new SpelExpressionParser();
		Expression exp = parser.parseExpression(str);
		EvaluationContext context = new StandardEvaluationContext();
		List<String> list = exp.getValue(context, List.class);	// 获取集合
		System.out.println(list);
		HashSet<String> set = exp.getValue(context,HashSet.class);
		System.out.println(set);

		str = "{'mldn','jixianit','mldnjava','mldn'}[2]";				// 定义表达式
		exp = parser.parseExpression(str);
		String val = exp.getValue(context,String.class);
		System.out.println(val);

		List<String> all = new ArrayList<>() ;	// 定义集合对象
		Collections.addAll(all, "mldn","jixianit","mldnjava") ;	// 增加一组数据
		str = "#allData[1]";						// 定义表达式
		parser = new SpelExpressionParser();
		exp = parser.parseExpression(str);
		context = new StandardEvaluationContext();
		context.setVariable("allData", all);			// 设置集合
		String result = exp.getValue(context, String.class);	// 获取集合
		System.out.println(result);

		str = "#allData[1]='www.jixianit.com'";			// 定义表达式
		exp = parser.parseExpression(str);
		context = new StandardEvaluationContext();
		context.setVariable("allData", all);					// 设置集合
		String result2 = exp.getValue(context, String.class);	// 获取集合
		System.out.println(result2);
		System.out.println(all);
	}
}

SpEL与配置文件

	<bean id="item" class="cn.mldn.mldnspring.vo.Item">
		<property name="title" value="#{'www.mldn.cn'.substring(4,8)}"/>	<!-- 字符串处理 -->
		<property name="createDate" value="#{new java.util.Date()}"/>	<!-- 实例化对象 -->
	</bean>