Spring3.0提供的表达式语言spel

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));
 
    }
}