package com.zf.spel;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.Expression;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.common.TemplateParserContext;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;
/**
*
* @author ZF
*
*/
public class ExpressionTest {
public static void main(String[] args) throws NoSuchMethodException, SecurityException {
/**
* 1.直接量表达式
*/
System.out.println("=========1.直接量表达式========");
// 创建一个ExpressionParser，用于解析表达式
ExpressionParser parser = new SpelExpressionParser();
// 计算结果为"Hello World "
String helloworld = parser.parseExpression("'Hello World'").getValue(String.class);
Double num = parser.parseExpression("0.23").getValue(Double.class);
System.out.println(helloworld + " ====== " + num);
/**
* 2.在表达式中创建数组
*/
System.out.println("=========2.在表达式中创建数组========");
// 创建一个数组
Expression exp = parser.parseExpression("new String[]{'JAVA','Struts','Spring'}");
System.out.println(exp.getValue());
// 创建二维数组
exp = parser.parseExpression("new int[2][4]");
System.out.println(exp.getValue());
/**
* 3.在表达式中创建List集合
*/
System.out.println("=========3.在表达式中创建List集合========");
// 创建一个List集合
exp = parser.parseExpression("{'JAVA','Struts','Spring'}");
System.out.println(exp.getValue());
// 创建"二维"List集合
exp = parser.parseExpression("{{'疯狂JAVA讲义',''},{'左传','战国策'}}");
System.out.println(exp.getValue());
/**
* 3.在表达式中访问List、Map等集合元素
*/
List<String> list = new ArrayList<String>();
list.add("JAVA");
list.add("Spring");
Map<String, Double> map = new HashMap<String, Double>();
map.put("JAVA", 80.0);
map.put("Spring", 89.0);
EvaluationContext ctx = new StandardEvaluationContext();
ctx.setVariable("myList", list);
ctx.setVariable("myMap", map);
// 访问List集合的第二个元素
System.out.println(parser.parseExpression("#myList[1]").getValue(ctx));
// 访问Map集合的指定元素
System.out.println(parser.parseExpression("#myMap['JAVA']").getValue(ctx));
/**
* 4.调用方法
*/
System.out.println("=========4.调用方法========");
// 调用String对象的substring(0计数的起始位置,结束位置不包含该位置的值)方法
System.out.println(parser.parseExpression("'HelloWord!'.substring(5,9)").getValue());
List<String> list2 = new ArrayList<String>();
list2.add("java");
list2.add("struts");
list2.add("spring");
list2.add("hibernate");
// 设置一个变量
ctx.setVariable("myList2", list2);
System.out.println(parser.parseExpression("#myList2.subList(1,3)").getValue(ctx));
/**
*
* 5.算术、比较、逻辑、赋值、三目等运算符
* 算术支持:加(+)、减(-)、乘(*)、除(/)、求余（%）、幂（^）运算
* 比较支持:eq("=="),ne("!="),le("<="),lt("<"),gt(">"),ge(">="),div("/"),mod("%"),not("!")，正则表达式及instanceof操作
* 逻辑支持:且（and）、或(or)、非(!或NOT)。
* 赋值支持:允许给自定义变量赋值，也允许给跟对象赋值，直接使用“#variableName=value”即可赋值：
* 三目支持：如“2>1?true:false”将返回true
*/
System.out.println("=========5.算术、比较、逻辑、赋值、三目等运算符========");
List<String> list3 = new ArrayList<String>();
list3.add("java");
list3.add("struts");
list3.add("spring");
list3.add("hibernate");
// 设置一个变量
ctx.setVariable("myList3", list3);
// 对集合的第一个元素进行赋值
parser.parseExpression("#myList3[0]='疯狂java讲义'").getValue(ctx);
// 下面将输出 疯狂java讲义
System.out.println(list3.get(0));
// 使用三目运算符
System.out.println(
parser.parseExpression("#myList3.size()>3 ?" + "'myList3长度大于3' : 'myList3长度不大于3'").getValue(ctx));
// 关系表达式
System.out.println(parser.parseExpression("2.0 between {1,3}").getValue(Boolean.class));
/**
* 逻辑表达式 且（and）、或(or)、非(!或NOT)。
*
*/
System.out.println(parser.parseExpression("2 > 1 and (!true or !false)").getValue(Boolean.class));
System.out.println(parser.parseExpression("2 > 1 and (NOT true or NOT false)").getValue(Boolean.class));
/**
* 字符串连接及截取表达式
*/
// 字符串连接
System.out.println(parser.parseExpression("'Hello'+' Word!'").getValue(String.class));
// 字符串截取，目前只能截取一个
System.out.println(parser.parseExpression("'Hello Word!'[0]").getValue(String.class));
/**
* 三目运算与Elivis运算
*
* 三目运算符 “表达式1?表达式2:表达式3”用于构造三目运算表达式，如“2>1?true:false”将返回true；
* Elivis运算符“表达式1?:表达式2”从Groovy语言引入用于简化三目运算符的，
* 当表达式1为非null时则返回表达式1，当表达式1为null时则返回表达式2， 简化了三目运算符方式“表达式1? 表达式1:表达式2”，
* 如“null?:false”将返回false，而“true?:false”将返回true
*
*
*/
System.out.println(parser.parseExpression("2 > 1 ? true : false").getValue(Boolean.class));
System.out.println(parser.parseExpression("null ?: false").getValue(Boolean.class));
/**
* 6.类型运算符 T（）
*
* 使用“T(Type)”来表示java.lang.Class实例，“Type”必须是类全限定名，
* “java.lang”包除外，即该包下的类可以不指定包名；使用类类型表达式还可以进行访问类静态方法及类静态字段。
*/
System.out.println("=========6.类型运算符 T（）========");
// java.lang包类访问
System.out.println(parser.parseExpression("T(String)").getValue(Class.class));
// 其它包类的访问
System.out.println(parser.parseExpression("T(com.zf.spelXml.Author)").getValue(Class.class));
// 类静态字段访问
System.out.println(parser.parseExpression("T(Integer).MAX_VALUE").getValue(Integer.class));
// 类静态方法调用
System.out.println(parser.parseExpression("T(Integer).parseInt('1')").getValue(int.class));
/**
* 类的实例化
* 类实例化同样使用java关键字“new”，类名必须是全限定名，但java.lang包内的类型除外，如String、Integer。
*
*/
System.out.println(parser.parseExpression("new String('helloworld String')").getValue(String.class));
System.out.println(parser.parseExpression("new java.util.Date()").getValue(Date.class));
/**
* instanceof表达式
*
*/
System.out.println(parser.parseExpression("'abc' instanceof T(String)").getValue(Boolean.class));
/**
* 7.调用构造器
*
* substring(2,4)从0开始，不包括最后一个值
*/
System.out.println("=========7.调用构造器========");
System.out.println(parser.parseExpression("new String('HelloWord').substring(2,4)").getValue(String.class));
// System.out.println(parser.parseExpression("new
// javax.swing.JFrame('测试')"+".setVisible('true')").getValue());
/**
* 8.变量定义及引用
*
* 变量定义通过EvaluationContext接口的setVariable(variableName, value)方法定义；
* 在表达式中使用“#variableName”引用； 除了引用自定义变量，SpE还允许引用根对象及当前上下文对象，
* 使用“#root”引用根对象,引用SpEL的EvaluationContext 的root对象，
* 使用“#this”引用当前上下文对象,引用SpEL当前正在计算的对象；
*/
System.out.println("=========8.变量定义及引用========");
ctx.setVariable("variable", "haha");
System.out.println(parser.parseExpression("#variable").getValue(ctx, String.class));
ctx = new StandardEvaluationContext("hihi");
System.out.println(parser.parseExpression("#root").getValue(ctx, String.class));
System.out.println(parser.parseExpression("#this").getValue(ctx, String.class));
/**
* 9.自定义函数
*
*/
System.out.println("=========9.自定义函数========");
StandardEvaluationContext ctx2 = new StandardEvaluationContext();
Method parseInt = Integer.class.getDeclaredMethod("parseInt", String.class);
ctx2.registerFunction("parseInt", parseInt);
ctx2.setVariable("parseInt2", parseInt);
System.out.println(parser.parseExpression("#parseInt('3') == #parseInt2('3')").getValue(ctx2, Boolean.class));
/**
* 10.安全导航操作
*
*/
System.out.println("=========10.安全导航操作========");
System.out.println(parser.parseExpression("#foo?.bar").getValue());
// 以下语句将会产生异常
// System.out.println(parser.parseExpression("#foo.bar").getValue());
/**
* 11.集合选择
* 语法格式：collection.?[condition_expr]
*
*
*
*/
System.out.println("=========11.集合选择========");
// 将返回不可修改的空List
System.out.println(parser.parseExpression("{}").getValue(List.class));
// 对于字面量列表也将返回不可修改的List
System.out.println(parser.parseExpression("{1,2,3,4}").getValue(List.class).get(1));
// 不可修改的List，以下代码将会抛出异常java.lang.UnsupportedOperationException 不支持请求的操作
// System.out.println(parser.parseExpression("{1,2,3,4}").getValue(List.class).set(0,5));
// 对于列表中只要有一个不是字面量表达式，将只返回原始List，
// 不会进行不可修改处理
String expression3 = "{{1+2,2+4},{3,4+4}}";
List<List<Integer>> result3 = parser.parseExpression(expression3).getValue(List.class);
// 修改{1+2,2+4}中的下标为1第二个元素值为25
System.out.println(result3.get(0).set(1, 25));
System.out.println(result3.get(0));
// 声明二维数组并初始化
System.out.println(parser.parseExpression("new int[2]{1,2}").getValue(int[].class).length);
// 定义一维数组并且初始化
System.out.println(parser.parseExpression("new int[1]{9}").getValue(int[].class).length);
// 定义多维数组但不初始化
System.out.println("多维数组" + parser.parseExpression(expression3).getValue(int[][][].class).length);
// 错误的定义多维数组，多维数组不能初始化，以下代码会报错
// String expression4="new int[][][]{1}{2}{3}";
// System.out.println(parser.parseExpression(expression4).getValue(int[][][].class).length);
/**
* 使用较少:三维数组
*
*/
int score[][][] = { { { 5, 1 }, { 6, 7 } }, { { 9, 4 }, { 8, 3 } } };
System.out.print(score[0][0][0] + "\t");
System.out.print(score[0][0][1] + "\t");
System.out.print(score[0][0][0] + "\t");
System.out.print(score[0][0][1] + "\t");
System.out.print(score[1][0][0] + "\t");
System.out.print(score[1][0][1] + "\t");
System.out.print(score[1][1][0] + "\t");
System.out.print(score[1][1][1] + "\t");
System.out.println("\n =========书J2EE企业应用实战事例========");
/**
* 书J2EE企业应用实战事例
*/
List<String> list4=new ArrayList<String>();
list4.add("疯狂JAVA讲义");
list4.add("疯狂Ajax讲义");
list4.add("疯狂XML讲义");
list4.add("经典JAVA EE企业应用实战 ");
ctx.setVariable("myList4",list4);
//判断集合元素值的长度length()方法大于7，所以"疯狂XML讲义"将会移除 不会显示
System.out.println(parser.parseExpression("#myList4.?[length()>7]").getValue(ctx));
Map<String,Double> map2=new HashMap<String, Double>();
map2.put("java",89.0);
map2.put("Spring",82.0);
map2.put("英语",75.0);
ctx.setVariable("myMap2", map2);
//判断Map集合的value值大于80，所以只会保留前两个
System.out.println(parser.parseExpression("#myMap2.?[value>80]").getValue(ctx));
/**
* 12.集合投影
* 语法格式：collection.![condition_expr]
*
*/
System.out.println("=========12.集合投影========");
List<String> list5=new ArrayList<String>();
list5.add("疯狂JAVA讲义");
list5.add("疯狂Ajax讲义");
list5.add("疯狂XML讲义");
list5.add("经典JAVA EE企业应用实战 ");
ctx.setVariable("myList5", list5);
//得到的新集合的元素是原集合的每个元素length()方法的返回值
System.out.println(parser.parseExpression("#myList5.![length()]").getValue(ctx));
List<Person> listPerson=new ArrayList<Person>();
listPerson.add(new Person(1, "张三",18));
listPerson.add(new Person(2, "李四",20));
listPerson.add(new Person(3, "王五",26));
ctx.setVariable("listPerson", listPerson);
//得到的新集合的元素是原集合的每个元素的name属性值
System.out.println(parser.parseExpression("#listPerson.![name]").getValue(ctx));
/**
* 上面list5.add("经典JAVA EE企业应用实战 ");中的元素 长度为16，注意中间只有一个空格，敲两个空格将会是一个长度
*
* java字符串去除空格
* 1、" 12 5 ".trim():只去掉前后首尾空格，中间的任然保留
* 2、" qw we ew ".replace(" ",""):去掉所有空格
* 3、或者replaceAll(" +",""); 去掉所有空格
* 4、str = .replaceAll("\\s*", "");去掉所有空格
*/
String test=new String(" qw e r t y f ff gfg fg ");
System.out.println(test.replace(" ", ""));
/**
* 13.表达式模板
*
*/
System.out.println("=========13.表达式模板========");
Person person1=new Person(1, "张三", 19);
Person person2=new Person(2, "张三", 25);
//将person1对象的name,age,填充到表达式#{}中
System.out.println(parser.parseExpression("我的名字是#{name},年龄是#{age}",new TemplateParserContext()).getValue(person1));
//将person2对象的name,age,填充到表达式#{}中
System.out.println(parser.parseExpression("我的名字是#{name},年龄是#{age}",new TemplateParserContext()).getValue(person1));
}
}
