跳至主要內容

Spring表达式

wangdx大约 22 分钟

Spring 表达式基本使用

SpEL

  • Spring 表达式语言(Spring Expression Lanquage、简称“SpEL”)是 Spring 开发框架提供的一种提高字符串计算处理能力的工具，使开发者可以打破传统的 Java 编码方式实现更加丰富的功能
1、
package com.yootk.main;

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 YootkSpELDemo {
    public static void main(String[] args) throws Exception { // 该抛就抛
        // 字符串截取：public String substring(int start, int end)；
        // 字符串转大写：public String toUpperCase()；
        // 此时的表达式里面设置有两个变量的信息，一个是start、另一个是end
        String str = "(\"www.\" + \"yootk.com\").substring(#start, #end).toUpperCase()"; // 定义字符串
        ExpressionParser parser = new SpelExpressionParser(); // 定义SpEL解析器
        Expression exp = parser.parseExpression(str); // 表达式解析
        // 在表达式执行之前还需要考虑两个占位符的配置问题
        EvaluationContext context = new StandardEvaluationContext(); // 表达式上下文配置
        context.setVariable("start", 4); // 配置参数的信息
        context.setVariable("end", 9); // 配置参数的信息
        System.out.println("SpEL处理结果：" + exp.getValue(context)); // 表达式计算
    }
}

SpEL 解析原理

SpEL 表达式处理流程

  • 在表达式处理时，首先会对给定的字符串结构进行解析，通过断词器将表达式中的不同结构进行拆分，随后将这些拆分后的结果保存在语法树之中，最终在计算时，如果发现表达式内部有变量定义，则会进行变量内容的替换，并最终得到计算结果，
1、
package com.yootk.main;

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 YootkSpELDemo {
    public static void main(String[] args) throws Exception { // 该抛就抛
        String str = "10 + 20"; // 实现了一个加法计算
        ExpressionParser parser = new SpelExpressionParser(); // 定义SpEL解析器
        Expression exp = parser.parseExpression(str); // 表达式解析
        EvaluationContext context = new StandardEvaluationContext(); // 表达式上下文配置
        System.out.println("SpEL处理结果：" + exp.getValue(context)); // 表达式计算
    }
}

ExpressionParser 表达式解析

  • 在表达式解析处理之中，主要依靠的是 ExpressionParser 接口完成的，该接口提供了 SpelExpressionParser(Spring 表达式解析类)与 InternalSpelExpressionParser(内部表达式解析类)两个子类，考虑到子类与接口之间适配的管理，这两个子类又同时继承 TemplateAwareExpressionParser 父抽象类。最终的解析是由 InternalSpelExpressionParser 子类中所覆写的 doParseExpression()方法完成的，在该方法中会使用 Tokenizer 类进行字符串的词法分析处理。

表达式计算处理

  • 表达式的计算处理之中由于可能包含有部分的变量定义，所以在计算前需要首先构建 EvaluationContext 接口实例，并进行变量内容的配置，而具体的计算处理将根据表达式拆分后的结果进行操作，所以要使用到 SpelNode 接口之中提供的 getValue()方法来实现计算处理

ParserContext 与表达式分隔符

ParserContext 边界符配置

  • 在 Spring 表达式开发中，边界符的配置是由 ParserContext 接口实现的，类关联结构如图所示。而一旦定义了边界符之后，在使用 ExpressionParser 接口进行表达式解析时就必须明确的传入 ParserContext 接口实例才可以实现表达式的正确解析。
1、
package com.yootk.main;

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 YootkSpELDemo {
    public static void main(String[] args) throws Exception { // 该抛就抛
        String str = "#{10 + 20}"; // 实现了一个加法计算
        ExpressionParser parser = new SpelExpressionParser(); // 定义SpEL解析器
        Expression exp = parser.parseExpression(str, ParserContext.TEMPLATE_EXPRESSION); // 表达式解析
        EvaluationContext context = new StandardEvaluationContext(); // 表达式上下文配置
        System.out.println("SpEL处理结果：" + exp.getValue(context)); // 表达式计算
    }
}


2、
package com.yootk.main;

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 YootkSpELDemo {
    public static void main(String[] args) throws Exception { // 该抛就抛
        String str = "#[10 + 20]"; // 实现了一个加法计算
        ExpressionParser parser = new SpelExpressionParser(); // 定义SpEL解析器
        Expression exp = parser.parseExpression(str, new ParserContext() {

            @Override
            public boolean isTemplate() {
                return true; // 决定了模版是否启用的关键
            }

            @Override
            public String getExpressionPrefix() {
                return "#[";
            }

            @Override
            public String getExpressionSuffix() {
                return "]";
            }
        }); // 表达式解析
        EvaluationContext context = new StandardEvaluationContext(); // 表达式上下文配置
        System.out.println("SpEL处理结果：" + exp.getValue(context)); // 表达式计算
    }
}

SpEL 字面表达式

1、
package com.yootk.main;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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 YootkSpELDemo {
    private static final Logger LOGGER = LoggerFactory.getLogger(YootkSpELDemo.class);
    public static void main(String[] args) throws Exception { // 该抛就抛
        LOGGER.info("【\"'Muyan ' + \"Yootk\"\"】字面表达式：{}", spel("'Muyan ' + \"Yootk\"")); // 直接描述
        LOGGER.info("【\"#{'Muyan ' + \"Yootk\"}\"】字面表达式：{}", spel("#{ 'Muyan ' + \"Yootk\" }")); // 直接描述
        LOGGER.info("【\"#{1}\"】字面表达式：{}，对象类型：{}", spel("#{ 1 }"), spel("#{ 1 }").getClass()); // 直接描述
        LOGGER.info("【\"#{1.1}\"】字面表达式：{}，对象类型：{}", spel("#{ 1.1 }"), spel("#{ 1.1 }").getClass()); // 直接描述
        LOGGER.info("【\"#{1.1}\"】字面表达式：{}，对象类型：{}", spel("#{ 1.1 }"), spel("#{ 1.1 }").getClass()); // 直接描述
        LOGGER.info("【\"#{1.1E10}\"】字面表达式：{}，对象类型：{}", spel("#{ 1.1E10 }"), spel("#{ 1.1E10 }").getClass()); // 直接描述
        LOGGER.info("【\"#{true}\"】字面表达式：{}，对象类型：{}", spel("#{ true }"), spel("#{ true }").getClass()); // 直接描述
    }
    public static Object spel(String content) { // 实现了SpEL处理
        ExpressionParser parser = new SpelExpressionParser(); // 定义SpEL解析器
        Expression exp = parser.parseExpression(content, ParserContext.TEMPLATE_EXPRESSION); // 表达式解析
        EvaluationContext context = new StandardEvaluationContext(); // 表达式上下文配置
        return exp.getValue(context);
    }
}


2、
【"'Muyan ' + "Yootk""】字面表达式：'Muyan ' + "Yootk"
【"#{'Muyan ' + "Yootk"}"】字面表达式：Muyan Yootk
【"#{1}"】字面表达式：1，对象类型：class java.lang.Integer
【"#{1.1}"】字面表达式：1.1，对象类型：class java.lang.Double
【"#{1.1}"】字面表达式：1.1，对象类型：class java.lang.Double
【"#{1.1E10}"】字面表达式：1.1E10，对象类型：class java.lang.Double
【"#{true}"】字面表达式：true，对象类型：class java.lang.Boolean

SpEL 数学表达式

1、
package com.yootk.main;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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 YootkSpELDemo {
    private static final Logger LOGGER = LoggerFactory.getLogger(YootkSpELDemo.class);
    public static void main(String[] args) throws Exception { // 该抛就抛
        LOGGER.info("【#{ 1 + 2 - 3 * 4 / 5 }\"】数学计算表达式：{}、结果数据类型：{}", spel("#{ 1 + 2 - 3 * 4 / 5 }"), spel("#{ 1 + 2 - 3 * 4 / 5 }").getClass()); // 数学计算
        LOGGER.info("【#{ 10 % 3 }\"】数学计算表达式：{}、结果数据类型：{}", spel("#{ 10 % 3 }"), spel("#{ 10 % 3 }").getClass()); // 数学计算
        LOGGER.info("【#{ 10 mod 3 }\"】数学计算表达式：{}、结果数据类型：{}", spel("#{ 10 mod 3 }"), spel("#{ 10 mod 3 }").getClass()); // 数学计算
        LOGGER.info("【#{ 10 DIV 3 }\"】数学计算表达式：{}、结果数据类型：{}", spel("#{ 10 DIV 3 }"), spel("#{ 10 DIV 3 }").getClass()); // 数学计算
        LOGGER.info("【#{ 10 ^ 3 }\"】数学计算表达式：{}、结果数据类型：{}", spel("#{ 10 ^ 3 }"), spel("#{ 10 ^ 3 }").getClass()); // 数学计算
    }
    public static Object spel(String content) { // 实现了SpEL处理
        ExpressionParser parser = new SpelExpressionParser(); // 定义SpEL解析器
        Expression exp = parser.parseExpression(content, ParserContext.TEMPLATE_EXPRESSION); // 表达式解析
        EvaluationContext context = new StandardEvaluationContext(); // 表达式上下文配置
        return exp.getValue(context);
    }
}


2、
【#{ 1 + 2 - 3 * 4 / 5 }"】数学计算表达式：1、结果数据类型：class java.lang.Integer
【#{ 10 % 3 }"】数学计算表达式：1、结果数据类型：class java.lang.Integer
【#{ 10 mod 3 }"】数学计算表达式：1、结果数据类型：class java.lang.Integer
【#{ 10 DIV 3 }"】数学计算表达式：3、结果数据类型：class java.lang.Integer
【#{ 10 ^ 3 }"】数学计算表达式：1000、结果数据类型：class java.lang.Integer

SpEL 关系表达式

1、

package com.yootk.main;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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 YootkSpELDemo {
    private static final Logger LOGGER = LoggerFactory.getLogger(YootkSpELDemo.class);
    public static void main(String[] args) throws Exception { // 该抛就抛
        LOGGER.info("【#{ 30 != 20 }\"】关系表达式：{}", spel("#{ 30 != 20 }")); // 数学计算
        LOGGER.info("【#{ 30 NE 20 }\"】关系表达式：{}", spel("#{ 30 NE 20 }")); // 数学计算
        LOGGER.info("【#{ 'muyan' > 'MuYan' }\"】关系表达式：{}", spel("#{ 'muyan' > 'MuYan' }")); // 数学计算
        LOGGER.info("【#{ 10 + 20 eq 30 }\"】关系表达式：{}", spel("#{ 10 + 20 eq 30 }")); // 数学计算
    }
    public static Object spel(String content) { // 实现了SpEL处理
        ExpressionParser parser = new SpelExpressionParser(); // 定义SpEL解析器
        Expression exp = parser.parseExpression(content, ParserContext.TEMPLATE_EXPRESSION); // 表达式解析
        EvaluationContext context = new StandardEvaluationContext(); // 表达式上下文配置
        return exp.getValue(context);
    }
}

2、
 【#{ 30 != 20 }"】关系表达式：true
 【#{ 30 NE 20 }"】关系表达式：true
 【#{ 'muyan' > 'MuYan' }"】关系表达式：true
 【#{ 10 + 20 eq 30 }"】关系表达式：true

3、
package com.yootk.main;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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 YootkSpELDemo {
    private static final Logger LOGGER = LoggerFactory.getLogger(YootkSpELDemo.class);
    public static void main(String[] args) throws Exception { // 该抛就抛
        LOGGER.info("【#{ 30 != 20 || 10 EQ 10 }\"】逻辑运算表达式：{}", spel("#{ 30 != 20 || 10 EQ 10 }")); // 数学计算
        LOGGER.info("【#{ 'muyan' > 'MuYan' AND 'Yootk' LT 'yootk' }\"】逻辑运算表达式：{}", spel("#{ 'muyan' > 'MuYan' AND 'Yootk' LT 'yootk' }")); // 数学计算
        LOGGER.info("【#{ 10 BETWEEN {0, 100} AND 1 == 1 }\"】逻辑运算表达式：{}", spel("#{ 10 BETWEEN {0, 100} AND 1 == 1 }")); // 数学计算
        LOGGER.info("【#{ 'y' BETWEEN {'a', 'z'} }\"】逻辑运算表达式：{}", spel("#{ 'y' BETWEEN {'a', 'z'} }")); // 数学计算
    }
    public static Object spel(String content) { // 实现了SpEL处理
        ExpressionParser parser = new SpelExpressionParser(); // 定义SpEL解析器
        Expression exp = parser.parseExpression(content, ParserContext.TEMPLATE_EXPRESSION); // 表达式解析
        EvaluationContext context = new StandardEvaluationContext(); // 表达式上下文配置
        return exp.getValue(context);
    }
}

SpEL 逻辑表达式

1、
package com.yootk.main;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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 YootkSpELDemo {
    private static final Logger LOGGER = LoggerFactory.getLogger(YootkSpELDemo.class);
    public static void main(String[] args) throws Exception { // 该抛就抛
        LOGGER.info("【#{ 30 != 20 || 10 EQ 10 }\"】逻辑运算表达式：{}", spel("#{ 30 != 20 || 10 EQ 10 }")); // 数学计算
        LOGGER.info("【#{ 'muyan' > 'MuYan' AND 'Yootk' LT 'yootk' }\"】逻辑运算表达式：{}", spel("#{ 'muyan' > 'MuYan' AND 'Yootk' LT 'yootk' }")); // 数学计算
        LOGGER.info("【#{ 10 BETWEEN {0, 100} AND 1 == 1 }\"】逻辑运算表达式：{}", spel("#{ 10 BETWEEN {0, 100} AND 1 == 1 }")); // 数学计算
        LOGGER.info("【#{ 'y' BETWEEN {'a', 'z'} }\"】逻辑运算表达式：{}", spel("#{ 'y' BETWEEN {'a', 'z'} }")); // 数学计算
    }
    public static Object spel(String content) { // 实现了SpEL处理
        ExpressionParser parser = new SpelExpressionParser(); // 定义SpEL解析器
        Expression exp = parser.parseExpression(content, ParserContext.TEMPLATE_EXPRESSION); // 表达式解析
        EvaluationContext context = new StandardEvaluationContext(); // 表达式上下文配置
        return exp.getValue(context);
    }
}


2、
【#{ 30 != 20 || 10 EQ 10 }"】逻辑运算表达式：true
【#{ 'muyan' > 'MuYan' AND 'Yootk' LT 'yootk' }"】逻辑运算表达式：true
【#{ 10 BETWEEN {0, 100} AND 1 == 1 }"】逻辑运算表达式：true
【#{ 'y' BETWEEN {'a', 'z'} }"】逻辑运算表达式：true

SpEL 三目运算符

1、
package com.yootk.main;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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 YootkSpELDemo {
    private static final Logger LOGGER = LoggerFactory.getLogger(YootkSpELDemo.class);
    public static void main(String[] args) throws Exception { // 该抛就抛
        LOGGER.info("【#{ 'muyan' != null ? 'www.yootk.com' : 'www.jixianit.com' }\"】三目运算表达式：{}",
                spel("#{ 'muyan' != null ? 'www.yootk.com' : 'www.jixianit.com' }")); // 数学计算
        // 在Spring之中考虑到null的影响，所以null也是可以直接进行判断逻辑处理的
        LOGGER.info("【#{ null == null ? 'www.yootk.com' : 'www.jixianit.com' }\"】三目运算表达式：{}",
                spel("#{ null == null ? 'www.yootk.com' : 'www.jixianit.com' }")); // 数学计算
        LOGGER.info("【#{ true ? 'www.yootk.com' : 'www.jixianit.com' }\"】三目运算表达式：{}",
                spel("#{ true ? 'www.yootk.com' : 'www.jixianit.com' }")); // 数学计算
    }
    public static Object spel(String content) { // 实现了SpEL处理
        ExpressionParser parser = new SpelExpressionParser(); // 定义SpEL解析器
        Expression exp = parser.parseExpression(content, ParserContext.TEMPLATE_EXPRESSION); // 表达式解析
        EvaluationContext context = new StandardEvaluationContext(); // 表达式上下文配置
        return exp.getValue(context);
    }
}


2、
【#{ 'muyan' != null ? 'www.yootk.com' : 'www.jixianit.com' }"】三目运算表达式：www.yootk.com
【#{ null == null ? 'www.yootk.com' : 'www.jixianit.com' }"】三目运算表达式：www.yootk.com
【#{ true ? 'www.yootk.com' : 'www.jixianit.com' }"】三目运算表达式：www.yootk.com

3、
package com.yootk.main;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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 YootkSpELDemo {
    private static final Logger LOGGER = LoggerFactory.getLogger(YootkSpELDemo.class);
    public static void main(String[] args) throws Exception { // 该抛就抛
        LOGGER.info("【#{ null ? 'www.yootk.com' : 'www.jixianit.com' }\"】三目运算表达式：{}",
                spel("#{ null ? 'www.yootk.com' : 'www.jixianit.com' }")); // 数学计算
    }
    public static Object spel(String content) { // 实现了SpEL处理
        ExpressionParser parser = new SpelExpressionParser(); // 定义SpEL解析器
        Expression exp = parser.parseExpression(content, ParserContext.TEMPLATE_EXPRESSION); // 表达式解析
        EvaluationContext context = new StandardEvaluationContext(); // 表达式上下文配置
        return exp.getValue(context);
    }
}


4、
package com.yootk.main;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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 YootkSpELDemo {
    private static final Logger LOGGER = LoggerFactory.getLogger(YootkSpELDemo.class);
    public static void main(String[] args) throws Exception { // 该抛就抛
        LOGGER.info("【#{ null ?: 'www.jixianit.com' }\"】三目运算表达式：{}",
                spel("#{ null ?: 'www.jixianit.com' }")); // 数学计算
        LOGGER.info("【#{ 'yootk' ?: 'www.jixianit.com' }\"】三目运算表达式：{}",
                spel("#{ 'yootk' ?: 'www.jixianit.com' }")); // 数学计算
    }
    public static Object spel(String content) { // 实现了SpEL处理
        ExpressionParser parser = new SpelExpressionParser(); // 定义SpEL解析器
        Expression exp = parser.parseExpression(content, ParserContext.TEMPLATE_EXPRESSION); // 表达式解析
        EvaluationContext context = new StandardEvaluationContext(); // 表达式上下文配置
        return exp.getValue(context);
    }
}

SpEL 字符串处理表达式

  • 获取字符串中指定索引的字符
package com.yootk.main;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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 YootkSpELDemo {
    private static final Logger LOGGER = LoggerFactory.getLogger(YootkSpELDemo.class);
    public static void main(String[] args) throws Exception { // 该抛就抛
        // String类提供有charAt()方法，这个方法之中是接收索引返回字符的
        LOGGER.info("【#{ 'www.yootk.com'[8] }\"】字符串方法执行表达式：{}",
                spel("#{ 'www.yootk.com'[8] }"));
        LOGGER.info("【#{ 'www.yootk.com'.substring(4, 'www.yootk.com'.length()) }\"】字符串方法执行表达式：{}",
                spel("#{ 'www.yootk.com'.substring(4, 'www.yootk.com'.length()) }"));
        LOGGER.info("【#{ 'www.yootk.com'.replaceAll('yootk', 'jixianit') }\"】字符串方法执行表达式：{}",
                spel("#{ 'www.yootk.com'.replaceAll('yootk', 'jixianit') }"));
        LOGGER.info("【#{ 'www.yootk.com'.matches('\\w+\\.\\w+\\.\\w+') }\"】字符串方法执行表达式：{}",
                spel("#{ 'www.yootk.com'.matches('\\w+\\.\\w+\\.\\w+') }"));
        LOGGER.info("【#{ 'www.yootk.com' matches '\\w+\\.\\w+\\.\\w+' }\"】字符串方法执行表达式：{}",
                spel("#{ 'www.yootk.com' matches '\\w+\\.\\w+\\.\\w+' }"));
    }
    public static Object spel(String content) { // 实现了SpEL处理
        ExpressionParser parser = new SpelExpressionParser(); // 定义SpEL解析器
        Expression exp = parser.parseExpression(content, ParserContext.TEMPLATE_EXPRESSION); // 表达式解析
        EvaluationContext context = new StandardEvaluationContext(); // 表达式上下文配置
        return exp.getValue(context);
    }
}

Class 表达式

1、
package com.yootk.main;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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 YootkSpELDemo {
    private static final Logger LOGGER = LoggerFactory.getLogger(YootkSpELDemo.class);
    public static void main(String[] args) throws Exception { // 该抛就抛
        LOGGER.info("【#{ T(java.lang.String) }\"】Class表达式：{}",
                spel("#{ T(java.lang.String) }"));
    }
    public static Object spel(String content) { // 实现了SpEL处理
        ExpressionParser parser = new SpelExpressionParser(); // 定义SpEL解析器
        Expression exp = parser.parseExpression(content, ParserContext.TEMPLATE_EXPRESSION); // 表达式解析
        EvaluationContext context = new StandardEvaluationContext(); // 表达式上下文配置
        return exp.getValue(context);
    }
}


2、
package com.yootk.main;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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 YootkSpELDemo {
    private static final Logger LOGGER = LoggerFactory.getLogger(YootkSpELDemo.class);
    public static void main(String[] args) throws Exception { // 该抛就抛
        LOGGER.info("【#{ T(java.lang.Integer).MAX_VALUE }\"】Class表达式：{}",
                spel("#{ T(java.lang.Integer).MAX_VALUE }"));
        LOGGER.info("【#{ T(java.lang.Integer).parseInt('919') }\"】Class表达式：{}",
                spel("#{ T(java.lang.Integer).parseInt('919') }"));
    }
    public static Object spel(String content) { // 实现了SpEL处理
        ExpressionParser parser = new SpelExpressionParser(); // 定义SpEL解析器
        Expression exp = parser.parseExpression(content, ParserContext.TEMPLATE_EXPRESSION); // 表达式解析
        EvaluationContext context = new StandardEvaluationContext(); // 表达式上下文配置
        return exp.getValue(context);
    }
}


3、
package com.yootk.main;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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;
class Book {
    private String title;
    private double price;
    public Book(String title, double price) { // 双参构造方法
        this.title = title;
        this.price = price;
    }
    // 此时无参构造方法、Setter、Getter方法定义，略...

    @Override
    public String toString() {
        return "【图书】名称：" + this.title + "、价格：" + this.price;
    }
}
public class YootkSpELDemo {
    private static final Logger LOGGER = LoggerFactory.getLogger(YootkSpELDemo.class);
    public static void main(String[] args) throws Exception { // 该抛就抛
        LOGGER.info("【#{ new com.yootk.main.Book('Spring开发实战', 79.8) }\"】对象实例化表达式：{}",
                spel("#{ new com.yootk.main.Book('Spring开发实战', 79.8) }"));
    }
    public static Object spel(String content) { // 实现了SpEL处理
        ExpressionParser parser = new SpelExpressionParser(); // 定义SpEL解析器
        Expression exp = parser.parseExpression(content, ParserContext.TEMPLATE_EXPRESSION); // 表达式解析
        EvaluationContext context = new StandardEvaluationContext(); // 表达式上下文配置
        return exp.getValue(context);
    }
}

表达式变量操作

表达式变量

  • 为了进一步增加表达式的开发的灵活性，在每一个表达式之中可以进行若干个变量的定随后再计算前利用环境上下文进行变量的设置。由于 Java 之中的数据类型较为丰所以开发者可以根据需要为表达式中的变量设置任意的数据类型，例如:String、Integer、Method 等
1、
package com.yootk.main;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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 YootkSpELDemo {
    private static final Logger LOGGER = LoggerFactory.getLogger(YootkSpELDemo.class);
    public static void main(String[] args) throws Exception { // 该抛就抛
        String content = "#{ #varA + #varB }"; // 定义表达式
        ExpressionParser parser = new SpelExpressionParser(); // 定义SpEL解析器
        Expression exp = parser.parseExpression(content, ParserContext.TEMPLATE_EXPRESSION); // 表达式解析
        EvaluationContext context = new StandardEvaluationContext(); // 表达式上下文配置
        context.setVariable("varA", "Hello "); // 定义变量内容
        context.setVariable("varB", "YOOTK.com"); // 定义变量内容
        String resultA = exp.getValue(context, String.class); // 字符串的类型的计算处理
        LOGGER.info("字符串连接结果：{}", resultA);
        context.setVariable("varA", 10.2); // 设置变量内容
        context.setVariable("varB", 20.3); // 设置变量内容
        double resultB = exp.getValue(context, Double.class);
        LOGGER.info("数字计算结果：{}", resultB);
    }
}


2、
package com.yootk.main;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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 YootkSpELDemo {
    private static final Logger LOGGER = LoggerFactory.getLogger(YootkSpELDemo.class);
    public static void main(String[] args) throws Exception { // 该抛就抛
        String content = "#{ #root.contains('yootk') }"; // 定义表达式
        ExpressionParser parser = new SpelExpressionParser(); // 定义SpEL解析器
        Expression exp = parser.parseExpression(content, ParserContext.TEMPLATE_EXPRESSION); // 表达式解析
        EvaluationContext context = new StandardEvaluationContext("yootk.com");
        boolean result = exp.getValue(context, Boolean.class);
        LOGGER.info("字符串连接结果：{}", result);
    }
}


3、
package com.yootk.main;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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.lang.reflect.Method;

public class YootkSpELDemo {
    private static final Logger LOGGER = LoggerFactory.getLogger(YootkSpELDemo.class);
    public static void main(String[] args) throws Exception { // 该抛就抛
        // 本次的目的是希望对字符串”919“进行一个转型的处理，将其转换为Integer对象实例
        String content = "#{ #convert('919') }"; // 定义表达式
        Method method = Integer.class.getMethod("parseInt", String.class); // 获取指定方法的实例
        ExpressionParser parser = new SpelExpressionParser(); // 定义SpEL解析器
        Expression exp = parser.parseExpression(content, ParserContext.TEMPLATE_EXPRESSION); // 表达式解析
        EvaluationContext context = new StandardEvaluationContext();
        context.setVariable("convert", method);// 方法引用的实现
        Integer result = exp.getValue(context, Integer.class);
        LOGGER.info("字符串连接结果：{}", result * 2);
    }
}


4、

package com.yootk.main;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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 YootkSpELDemo {
    private static final Logger LOGGER = LoggerFactory.getLogger(YootkSpELDemo.class);
    public static void main(String[] args) throws Exception { // 该抛就抛
        // java.util.Date类中提供有getTime()方法，所以此处可以直接采用time标记进行属性表示
        String content = "#{ #var.time }"; // 定义表达式
        ExpressionParser parser = new SpelExpressionParser(); // 定义SpEL解析器
        Expression exp = parser.parseExpression(content, ParserContext.TEMPLATE_EXPRESSION); // 表达式解析
        EvaluationContext context = new StandardEvaluationContext();
        context.setVariable("var", new java.util.Date());// 方法引用的实现
        Long result = exp.getValue(context, Long.class);
        LOGGER.info("字符串连接结果：{}", result);
    }
}

5、
package com.yootk.main;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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 YootkSpELDemo {
    private static final Logger LOGGER = LoggerFactory.getLogger(YootkSpELDemo.class);
    public static void main(String[] args) throws Exception { // 该抛就抛
        // java.util.Date类中提供有getTime()方法，所以此处可以直接采用time标记进行属性表示
        String content = "#{ #var.time }"; // 定义表达式
        ExpressionParser parser = new SpelExpressionParser(); // 定义SpEL解析器
        Expression exp = parser.parseExpression(content, ParserContext.TEMPLATE_EXPRESSION); // 表达式解析
        EvaluationContext context = new StandardEvaluationContext();
        context.setVariable("var", null);// 方法引用的实现
        Long result = exp.getValue(context, Long.class);
        LOGGER.info("字符串连接结果：{}", result);
    }
}


6、
package com.yootk.main;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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 YootkSpELDemo {
    private static final Logger LOGGER = LoggerFactory.getLogger(YootkSpELDemo.class);
    public static void main(String[] args) throws Exception { // 该抛就抛
        // java.util.Date类中提供有getTime()方法，所以此处可以直接采用time标记进行属性表示
        String content = "#{ #var?.time }"; // 定义表达式
        ExpressionParser parser = new SpelExpressionParser(); // 定义SpEL解析器
        Expression exp = parser.parseExpression(content, ParserContext.TEMPLATE_EXPRESSION); // 表达式解析
        EvaluationContext context = new StandardEvaluationContext();
        context.setVariable("var", null);// 方法引用的实现
        Long result = exp.getValue(context, Long.class);
        LOGGER.info("字符串连接结果：{}", result);
    }
}

List 集合表达式

1、
package com.yootk.main;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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.List;

public class YootkSpELDemo {
    private static final Logger LOGGER = LoggerFactory.getLogger(YootkSpELDemo.class);
    public static void main(String[] args) throws Exception { // 该抛就抛
        String content = "#{ {'www.yootk.com', 'jixianit.com', 'edu.yootk.com'} }"; // 定义表达式
        ExpressionParser parser = new SpelExpressionParser(); // 定义SpEL解析器
        Expression exp = parser.parseExpression(content, ParserContext.TEMPLATE_EXPRESSION); // 表达式解析
        EvaluationContext context = new StandardEvaluationContext();
        List<String> result = exp.getValue(context, List.class); // 直接转为了 List集合
        result.forEach(System.out::println);
    }
}


2、

package com.yootk.main;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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.List;

public class YootkSpELDemo {
    private static final Logger LOGGER = LoggerFactory.getLogger(YootkSpELDemo.class);
    public static void main(String[] args) throws Exception { // 该抛就抛
        List<String> data = List.of("www.yootk.com", "www.jixianit.com", "edu.yootk.com"); // 外部集合
        String content = "#{ #all[0] }"; // 定义表达式
        ExpressionParser parser = new SpelExpressionParser(); // 定义SpEL解析器
        Expression exp = parser.parseExpression(content, ParserContext.TEMPLATE_EXPRESSION); // 表达式解析
        EvaluationContext context = new StandardEvaluationContext();
        context.setVariable("all", data); // 设置变量内容
        LOGGER.info("获取表达式计算结果：{}", exp.getValue(context, String.class));
    }
}

3、
package com.yootk.main;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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.ArrayList;
import java.util.Collections;
import java.util.List;

public class YootkSpELDemo {
    private static final Logger LOGGER = LoggerFactory.getLogger(YootkSpELDemo.class);
    public static void main(String[] args) throws Exception { // 该抛就抛
        List<String> data = new ArrayList<>(); // 外部集合
        Collections.addAll(data, "www.yootk.com", "www.jixianit.com", "edu.yootk.com");
        String content = "#{ #all[2] = 'book.yootk.com' }"; // 定义表达式
        ExpressionParser parser = new SpelExpressionParser(); // 定义SpEL解析器
        Expression exp = parser.parseExpression(content, ParserContext.TEMPLATE_EXPRESSION); // 表达式解析
        EvaluationContext context = new StandardEvaluationContext();
        context.setVariable("all", data); // 设置变量内容
        LOGGER.info("获取表达式计算结果：{}", exp.getValue(context, String.class));
        LOGGER.info("修改后的List集合：{}", data);
    }
}


4、
package com.yootk.main;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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.ArrayList;
import java.util.Collections;
import java.util.List;

public class YootkSpELDemo {
    private static final Logger LOGGER = LoggerFactory.getLogger(YootkSpELDemo.class);
    public static void main(String[] args) throws Exception { // 该抛就抛
        List<String> data = new ArrayList<>(); // 外部集合
        Collections.addAll(data, "www.yootk.com", "www.jixianit.com", "edu.yootk.com");
        String content = "#{ #all.!['【学习资源】' + #this] }"; // 定义表达式
        ExpressionParser parser = new SpelExpressionParser(); // 定义SpEL解析器
        Expression exp = parser.parseExpression(content, ParserContext.TEMPLATE_EXPRESSION); // 表达式解析
        EvaluationContext context = new StandardEvaluationContext();
        context.setVariable("all", data); // 设置变量内容
        LOGGER.info("表达式计算结果：{}", exp.getValue(context, List.class));
        LOGGER.info("修改后的List集合：{}", data);
    }
}

Map 集合表达式

SpEL 与 Map 集合

  • 项目开发设计之中可以基于 Map 集合实现数据的查询功能，传统的代码开发中都是直接通过 Map 集合提供的方法实现数据处理，而在 SpEL 之中可以通过字符串来进行 Map 集合的数据获取、数据修改以及迭代操作
1、
package com.yootk.main;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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.Map;

public class YootkSpELDemo {
    private static final Logger LOGGER = LoggerFactory.getLogger(YootkSpELDemo.class);
    public static void main(String[] args) throws Exception { // 该抛就抛
        // 这个时候创建的Map集合是无法进行修改的，属于固定内容的集合
        Map<String, String> map = Map.of("yootk", "www.yootk.com",
                "jixianit", "www.jixianit.com", "edu", "edu.yootk.com"); // 定义Map集合
        String content = "#{ #all['yootk'] }"; // 定义表达式
        ExpressionParser parser = new SpelExpressionParser(); // 定义SpEL解析器
        Expression exp = parser.parseExpression(content, ParserContext.TEMPLATE_EXPRESSION); // 表达式解析
        EvaluationContext context = new StandardEvaluationContext();
        context.setVariable("all", map); // 设置变量内容
        LOGGER.info("表达式计算结果：{}", exp.getValue(context, String.class));
    }
}


2、
package com.yootk.main;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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.HashMap;
import java.util.Map;

public class YootkSpELDemo {
    private static final Logger LOGGER = LoggerFactory.getLogger(YootkSpELDemo.class);
    public static void main(String[] args) throws Exception { // 该抛就抛
        Map<String, String> map = new HashMap<>();
        map.put("yootk", "www.yootk.com");
        map.put("jixianit", "www.jixianit.com");
        map.put("edu", "edu.yootk.com");
        String content = "#{ #all['edu'] = 'book.yootk.com' }"; // 定义表达式
        ExpressionParser parser = new SpelExpressionParser(); // 定义SpEL解析器
        Expression exp = parser.parseExpression(content, ParserContext.TEMPLATE_EXPRESSION); // 表达式解析
        EvaluationContext context = new StandardEvaluationContext();
        context.setVariable("all", map); // 设置变量内容
        LOGGER.info("表达式计算结果：{}", exp.getValue(context, String.class)); // put()方法
        LOGGER.info("原始Map集合：{}", map);
    }
}


3、
package com.yootk.main;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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.HashMap;
import java.util.List;
import java.util.Map;

public class YootkSpELDemo {
    private static final Logger LOGGER = LoggerFactory.getLogger(YootkSpELDemo.class);
    public static void main(String[] args) throws Exception { // 该抛就抛
        Map<String, String> map = new HashMap<>();
        map.put("yootk", "www.yootk.com");
        map.put("jixianit", "www.jixianit.com");
        map.put("edu", "edu.yootk.com");
        String content = "#{ #all.![#this.key + ' - ' + #this.value] }"; // 定义表达式
        ExpressionParser parser = new SpelExpressionParser(); // 定义SpEL解析器
        Expression exp = parser.parseExpression(content, ParserContext.TEMPLATE_EXPRESSION); // 表达式解析
        EvaluationContext context = new StandardEvaluationContext();
        context.setVariable("all", map); // 设置变量内容
        LOGGER.info("表达式计算结果：{}", exp.getValue(context, List.class)); // put()方法
    }
}


4、
package com.yootk.main;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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.HashMap;
import java.util.List;
import java.util.Map;

public class YootkSpELDemo {
    private static final Logger LOGGER = LoggerFactory.getLogger(YootkSpELDemo.class);
    public static void main(String[] args) throws Exception { // 该抛就抛
        Map<String, String> map = new HashMap<>();
        map.put("yootk", "www.yootk.com");
        map.put("jixianit", "www.jixianit.com");
        map.put("edu", "edu.yootk.com");
        String content = "#{ #all.?[#this.key.contains('yootk')] }"; // 定义表达式
        ExpressionParser parser = new SpelExpressionParser(); // 定义SpEL解析器
        Expression exp = parser.parseExpression(content, ParserContext.TEMPLATE_EXPRESSION); // 表达式解析
        EvaluationContext context = new StandardEvaluationContext();
        context.setVariable("all", map); // 设置变量内容
        LOGGER.info("表达式计算结果：{}", exp.getValue(context, Map.class)); // put()方法
    }
}

配置文件中整合 SpEL

SpEL 与属性内容处理

  • Spring 开发的项目可以通过 Spring 配置文件进行配置 Bean 的属性定义处理，而在使用元素进行属性内容配置时，也可以使用 SpEL 表达式对字符串的内容处<property>理后再实现注入的操作
1、
package com.yootk.vo;

import java.util.Set;

public class Message {
    private long mid;
    private String title;
    private String content;
    private Set<String> tags;

    public long getMid() {
        return mid;
    }

    public void setMid(long mid) {
        this.mid = mid;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public Set<String> getTags() {
        return tags;
    }

    public void setTags(Set<String> tags) {
        this.tags = tags;
    }
}


2、
    <bean id="message" class="com.yootk.vo.Message">
        <property name="mid" value="#{ 'muyan-yootk-10001'.split('-')[2] }"/>
        <property name="title" value="#{ 'muyan123_yootk0909'.replaceAll('\d+', '') }"/>
        <property name="content" value="#{ 'www.YOOTK.com'.toLowerCase() }"/>
        <property name="tags" value="#{ 'java;python;golang'.split(';') }"/>
    </bean>

3、
package com.yootk.test;

import com.yootk.vo.Message;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;

// 表示要进行Spring配置文件的加载，后续也可能是进行配置类的加载
@ContextConfiguration(locations = {"classpath:spring/spring-base.xml"}) // 定义XML配置文件
@ExtendWith(SpringExtension.class) // 表示此时使用外部的测试工具（JUnit5）
public class TestMessage {
    private static final Logger LOGGER =
            LoggerFactory.getLogger(TestMessage.class) ;// 获取日志实例
    @Autowired // 自动注入接口实例
    private Message message; // 要使用的业务接口
    @Test
    public void testEcho() {
        LOGGER.info("【Message数据】编号：{}、标题：{}、内容：{}、标签：{}",
                this.message.getMid(), this.message.getTitle(), this.message.getContent(),  this.message.getTags());
    }
}

基于 Annotation 使用 SpEL

注解配置

  • 现代的 Spring 应用开发，更多的是提倡基于注解的方式来进行配置，这样就可以在 Bean 类的属性上使用“@Value”的属性进行内容的配置，同时该内容也可以直接使用 SpEL 进行处理
1、
    <bean id="message" class="com.yootk.vo.Message">
        <property name="mid" value="#{ 'muyan-yootk-10001'.split('-')[2] }"/>
        <property name="title" value="#{ 'muyan123_yootk0909'.replaceAll('\d+', '') }"/>
        <property name="content" value="#{ 'www.YOOTK.com'.toLowerCase() }"/>
        <property name="tags" value="#{ 'java;python;golang'.split(';') }"/>
    </bean>

2、
    <context:annotation-config/>     <!-- 启用Annotation配置注解支持 -->
    <context:component-scan base-package="com.yootk"/>

3、

package com.yootk.vo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.util.Set;

@Component // 扫描注册Bean
public class Message {
    @Value("#{ 'muyan-yootk-10001'.split('-')[2] }")
    private long mid;
    @Value("#{ 'muyan123_yootk0909'.replaceAll('\\d+', '') }")
    private String title;
    @Value("#{ 'www.YOOTK.com'.toLowerCase() }")
    private String content;
    @Value("#{ 'java;python;golang'.split(';') }")
    private Set<String> tags;

    public long getMid() {
        return mid;
    }

    public void setMid(long mid) {
        this.mid = mid;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public Set<String> getTags() {
        return tags;
    }

    public void setTags(Set<String> tags) {
        this.tags = tags;
    }
}

4、
package com.yootk.test;

import com.yootk.vo.Message;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;

// 表示要进行Spring配置文件的加载，后续也可能是进行配置类的加载
@ContextConfiguration(locations = {"classpath:spring/spring-base.xml"}) // 定义XML配置文件
@ExtendWith(SpringExtension.class) // 表示此时使用外部的测试工具（JUnit5）
public class TestMessage {
    private static final Logger LOGGER =
            LoggerFactory.getLogger(TestMessage.class) ;// 获取日志实例
    @Autowired // 自动注入接口实例
    private Message message; // 要使用的业务接口
    @Test
    public void testEcho() {
        LOGGER.info("【Message数据】编号：{}、标题：{}、内容：{}、标签：{}",
                this.message.getMid(), this.message.getTitle(),
                this.message.getContent(),  this.message.getTags());
    }
}

Profile 配置与 SpEL 处理

Profile 管理配置数据

  • 真实的项目开发之中，往往会设置不同的 Profie 配置环境，而后每一个 Profile 环境之中会存在有相同 KEY 但是内容不同的配置项，在程序进行配置读取时，可以采用“${资源 KEY}”的模式进行资源文件配置项的加载随后再利用 SDEL 进行该内容的处理
1、
message.mid=muyan-yootk-10001
message.title=muyan123_yootk0909
message.content=www.YOOTK.com
message.tags=java;python;golang

2、
message.mid=edu-lixinghua-91915
message.title=91919lixinghua_892828edu666
message.content=www.JIXIANIT.com
message.tags=java;python;bigdata;

3、
<?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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
            http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context.xsd">
    <context:annotation-config/>     <!-- 启用Annotation配置注解支持 -->
    <context:component-scan base-package="com.yootk"/>
    <context:property-placeholder location="classpath:config/*.properties"/>
</beans>

4、

package com.yootk.vo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.util.Set;

@Component // 扫描注册Bean
public class Message {
    @Value("#{ '${message.mid}'.split('-')[2] }")
    private long mid;
    @Value("#{ '${message.title}'.replaceAll('\\d+', '') }")
    private String title;
    @Value("#{ '${message.content}'.toLowerCase() }")
    private String content;
    @Value("#{ '${message.tags}'.split(';') }")
    private Set<String> tags;

    public long getMid() {
        return mid;
    }

    public void setMid(long mid) {
        this.mid = mid;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public Set<String> getTags() {
        return tags;
    }

    public void setTags(Set<String> tags) {
        this.tags = tags;
    }
}

demo
上次编辑于:
MIT Licensed | Copyright © 2024-present WDX