SpEL 表达式_strpbrk函数

public class Person {
	private Integer id;
	private String name;
	private Date birth;

	// 无参数的构造器
	public Person() {
	}

	// 初始化全部成员变量的构造器
	public Person(Integer id, String name, Date birth) {
		this.id = id;
		this.name = name;
		this.birth = birth;
	}

	// 省略所有的setter和getter方法
}

public class SpELTest {
	public static void main(String[] args) {
		// 创建一个ExpressionParser对象，用于解析表达式
		ExpressionParser parser = new SpelExpressionParser();
		// 最简单的字符串表达式
		Expression exp = parser.parseExpression("'HelloWorld'");
		System.out.println("'HelloWorld'的结果： " + exp.getValue());
		// 调用方法的表达式
		exp = parser.parseExpression("'HelloWorld'.concat('!')");
		System.out.println("'HelloWorld'.concat('!')的结果： " + exp.getValue());
		// 调用对象的getter方法
		exp = parser.parseExpression("'HelloWorld'.bytes");
		System.out.println("'HelloWorld'.bytes的结果： " + exp.getValue());
		// 访问对象的属性(d相当于HelloWorld.getBytes().length)
		exp = parser.parseExpression("'HelloWorld'.bytes.length");
		System.out.println("'HelloWorld'.bytes.length的结果：" + exp.getValue());
		// 使用构造器来创建对象
		exp = parser.parseExpression("new String('helloworld')" + ".toUpperCase()");
		System.out.println("new String('helloworld')" + ".toUpperCase()的结果是： " + exp.getValue(String.class));
		Person person = new Person(1, "孙悟空", new Date());
		exp = parser.parseExpression("name");
		// 以指定对象作为root来计算表达式的值
		// 相当于调用person.name表达式的值
		System.out.println("以persn为root，name表达式的值是： " + exp.getValue(person, String.class));
		exp = parser.parseExpression("name=='孙悟空'");
		StandardEvaluationContext ctx = new StandardEvaluationContext();
		// 将person设为Context的root对象
		ctx.setRootObject(person);
		// 以指定Context来计算表达式的值
		System.out.println(exp.getValue(ctx, Boolean.class));
		List<Boolean> list = new ArrayList<Boolean>();
		list.add(true);
		EvaluationContext ctx2 = new StandardEvaluationContext();
		// 将list设置成EvaluationContext的一个变量
		ctx2.setVariable("list", list);
		// 修改list变量的第一个元素的值
		parser.parseExpression("#list[0]").setValue(ctx2, "false");
		// list集合的第一个元素被改变
		System.out.println("list集合的第一个元素为：" + parser.parseExpression("#list[0]").getValue(ctx2));
	}
}

'HelloWorld'的结果： HelloWorld
'HelloWorld'.concat('!')的结果： HelloWorld!
'HelloWorld'.bytes的结果： [B@22a71081
'HelloWorld'.bytes.length的结果：10
new String('helloworld').toUpperCase()的结果是： HELLOWORLD
以persn为root，name表达式的值是： 孙悟空
true
list集合的第一个元素为：false

exp.getValue(person, String.class) //以person对象为root对象计算表达式的值

<!-- 使用util.properties加载指定资源文件 -->
<util:properties id="confTest"
	location="classpath:test_zh_CN.properties"/>
<!--
配置setName()的参数时，在表达式中调用方法
配置setAxe()的参数时，在表达式中创建对象
配置调用setBooks()的参数时，在表达式中访问其他Bean的属性 -->
<bean id="author" class="org.crazyit.app.service.impl.Author"
	p:name="#{T(java.lang.Math).random()}"
	p:axe="#{new org.crazyit.app.service.impl.SteelAxe()}"
	p:books="#{ {confTest.a , confTest.b} }"/>

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

//创建一个数组
Expression exp = parser.parseExpression("new String[]{'java','spring'});

// 创建一个ExpressionParser对象，用于解析表达式
ExpressionParser parser = new SpelExpressionParser();
//创建一个List
List<String> list=new ArrayList<>();
list.add("Java");
list.add("Spring");
//创建一个Map
Map<String,Double> map=new HashMap<>();
map.put("key_1", 25.0);
map.put("key_2", 60.0);
//创建一个EvaluationContext对象，作为SpEL解析变量的上下文
EvaluationContext  ctx=new StandardEvaluationContext();
//设置两个变量
ctx.setVariable("myList", list);
ctx.setVariable("myMap", map);
//访问List集合的第二个元素
String tempString=parser.parseExpression("#myList[1]").getValue(ctx,String.class);
System.out.println("List集合的第二个元素为："+tempString);
//访问Map集合的指定元素
Double tempDouble=parser.parseExpression("#myMap[key_2]").getValue(ctx, Double.class);
System.out.println("Map集合中key为key_2的值为："+tempDouble);

//调用String对象的substring()方法
String temp=parser.parseExpression("'HelloWorld'.substring(2,5)").getValue(String.class);
System.out.println(temp);

// 创建一个ExpressionParser对象，用于解析表达式
ExpressionParser parser = new SpelExpressionParser();
// 创建一个List
List<String> list = new ArrayList<>();
list.add("Java");
list.add("Spring");
// 创建一个EvaluationContext对象，作为SpEL解析变量的上下文
EvaluationContext ctx = new StandardEvaluationContext();
// 设置一个变量
ctx.setVariable("myList", list);
// 对集合的第一个元素进行赋值
parser.parseExpression("#myList[0]='我爱你中国'").getValue(ctx);
// 下面测试输出
System.out.println("List更改后的第一个元素的值为：" + list.get(0));
// 使用三目运算符
System.out.println(parser.parseExpression("#myList.size()>3 ? 'myList长度大于3':'myList长度不大于于3'").getValue(ctx));

System.out.println(parser.parseExpression("T(java.lang.Math).random()").getValue());
System.out.println(parser.parseExpression("T(System).getProperty('os.name')").getValue());

//使用安全操作，将输出null
System.out.println("安全操作结果："+parser.parseExpression("#foo?.bar").getValue());
//不适用安全操作，将引发异常
System.out.println("安全操作结果："+parser.parseExpression("#foo.bar").getValue());

parser.parseExpression("#myList.?[length()>7]").getValue(ctx);
parser.parseExpression("#myMap.?[value()>80]").getValue(ctx);

// 创建一个ExpressionParser对象，用于解析表达式
ExpressionParser parser = new SpelExpressionParser();
// 创建一个List
List<String> list = new ArrayList<>();
list.add("Java");
list.add("Spring");
// 创建一个EvaluationContext对象，作为SpEL解析变量的上下文
EvaluationContext ctx = new StandardEvaluationContext();
// 设置一个变量
ctx.setVariable("myList", list);
System.out.println(parser.parseExpression("#myList.![length()]").getValue(ctx));

// 创建一个ExpressionParser对象，用于解析表达式
ExpressionParser parser = new SpelExpressionParser();
Person p1=new Person(1, "小明", 162);
Person p2=new Person(2, "小红", 182);
Expression expr =parser.parseExpression("我的名字是#{name}，身高是#{height}",new TemplateParserContext());
//将使用p1对象的name、height填充上面表达式模板中的#{}
System.out.println(expr.getValue(p1));
//将使用p2对象的name、height填充上面表达式模板中的#{}
System.out.println(expr.getValue(p2));