小编给大家分享一下怎么通过aop+spel表达式玩转出不一样的切面，希望大家阅读完这篇文章之后都有所收获，下面让我们一起去探讨吧！

创新互联公司专业为企业提供张掖网站建设、张掖做网站、张掖网站设计、张掖网站制作等企业网站建设、网页设计与制作、张掖企业网站模板建站服务，10余年张掖做网站经验，不只是建网站，更提供有价值的思路和整体网络服务。

什么是spel

Spring表达式语言（简称“ SpEL”）是一种功能强大的表达式语言，支持在运行时查询和操作对象图。

语言语法类似于Unified EL，但是提供了其他功能，最著名的是方法调用和基本的字符串模板功能。

此外它并不直接与Spring绑定，而是可以独立使用

spel可以支持哪些功能

• 文字表达式

• 布尔运算符和关系运算符

• 常用表达式

• 类表达式

• 访问属性，数组，列表和映射

• 方法调用

• 关系运算符

• 分配

• 调用构造函数

• Bean引用

• 数组构造

• 内联列表

• 内联Map

• 三元运算符

• 变量

• 用户定义的功能

• 集合投影

• 集合选择

• 模板表达式

上述的spel语法可以通过如下链接进行查阅 https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#expressions-language-ref

spel解析基本流程

形如下图 大体的步骤如下

1. 创建解析器

2. 解析表达式

3. 构造上下文

4. 求值

spel核心接口介绍

1、org.springframework.expression.ExpressionParser

表达式解析器，其功能主要是将字符串表达式转换为Expression对象。支持解析模板以及标准表达式字符串

其默认实现为

org.springframework.expression.spel.standard.SpelExpressionParser

2、org.springframework.expression.EvaluationContext

spel计算表达式值的“上下文”，这个Context对象可以包含多个对象，但只能有一个root(根)对象。当表达式中包含变量时，spel会根据EvaluationContext中的变量的值对表达式进行计算。可以使用setRootObject方法来设置根对象，使用setVariable方法来注册自定义变量，使用registerFunction来注册自定义函数。

其默认实现为

org.springframework.expression.spel.support.StandardEvaluationContext

3、org.springframework.expression.Expression

代表一个表达式，通过getValue方法根据上下文获得表达式值

其默认实现为

org.springframework.expression.spel.standard.SpelExpression

spel官方文档

https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#expressions

正文

前边简要介绍一下spel，下边我们就通过一个小例子来演示下。

该小例子主要是通过AOP+SPEL来实现，例子场景是：当产品价格大于10时，放入本地缓存，并通过定时器打印出本地缓存的值

1、业务逻辑实现核心代码

@Service
public class ProductServiceImpl implements ProductService {



    @Autowired
    private ProductMockDao productMockDao;

    @Override
    @LocalCacheable(key = "#product.id",condition = "#product.price ge 10")
    public Product save(Product product) {
        return productMockDao.save(product);
    }


}

2、aop切面编写

@Component
@Aspect
public class CacheAspect {


    @Around("@annotation(localCacheable)")
    public Object around(ProceedingJoinPoint pjp, LocalCacheable localCacheable) throws Throwable{
        MethodSignature methodSignature = (MethodSignature)pjp.getSignature();
        Method method = methodSignature.getMethod();
        Object[] args = pjp.getArgs();
        Object result = pjp.proceed();
        String key = pjp.getTarget().getClass().getName() + "_" + method.getName() + "_" + args.length;

        if(!StringUtils.isEmpty(localCacheable.key())){
           key = SpELParserUtils.parse(method,args,localCacheable.key(),String.class);
        }

        System.out.println("key:"+key);

        if(!StringUtils.isEmpty(localCacheable.condition())){
            boolean condition = SpELParserUtils.parse(method,args,localCacheable.condition(),Boolean.class);
            if(condition){
                LocalCache.INSTANCE.put(key,result);
            }
        }else{
            LocalCache.INSTANCE.put(key,result);
        }

        return result;

    }
}

3、解析spel核心工具类

@Slf4j
public final class SpELParserUtils {

    private static final String EXPRESSION_PREFIX = "#{";

    private static final String EXPRESSION_SUFFIX = "}";

    /**
     * 表达式解析器
     */
    private static ExpressionParser expressionParser = new SpelExpressionParser();

    /**
     *  参数名解析器，用于获取参数名
     */
    private static DefaultParameterNameDiscoverer parameterNameDiscoverer = new DefaultParameterNameDiscoverer();



    private SpELParserUtils(){}

    /**
     * 解析spel表达式
     *
     * @param method 方法
     * @param args 参数值
     * @param spelExpression  表达式
     * @param clz  返回结果的类型
     * @param defaultResult 默认结果
     * @return 执行spel表达式后的结果
     */
    public static  T parse(Method method, Object[] args, String spelExpression, Class clz, T defaultResult) {
        String[] params = parameterNameDiscoverer.getParameterNames(method);
        EvaluationContext context = new StandardEvaluationContext();
        //设置上下文变量
        for (int i = 0; i < params.length; i++) {
            context.setVariable(params[i], args[i]);
        }
        T result = getResult(context,spelExpression,clz);
        if(Objects.isNull(result)){
            return defaultResult;
        }
        return result;
    }

    /**
     * 解析spel表达式
     *
     * @param method  方法
     * @param args 参数值
     * @param spelExpression  表达式
     * @param clz  返回结果的类型
     * @return 执行spel表达式后的结果
     */
    public static  T parse(Method method, Object[] args, String spelExpression, Class clz) {
        String[] params = parameterNameDiscoverer.getParameterNames(method);
        EvaluationContext context = new StandardEvaluationContext();
        //设置上下文变量
        for (int i = 0; i < params.length; i++) {
            context.setVariable(params[i], args[i]);
        }
        return getResult(context,spelExpression,clz);
    }

    /**
     * 解析spel表达式
     *
     * @param param  参数名
     * @param paramValue 参数值
     * @param spelExpression  表达式
     * @param clz  返回结果的类型
     * @return 执行spel表达式后的结果
     */
    public static  T parse(String param, Object paramValue, String spelExpression, Class clz) {
        EvaluationContext context = new StandardEvaluationContext();
        //设置上下文变量
        context.setVariable(param, paramValue);
        return getResult(context,spelExpression,clz);
    }


    /**
     * 解析spel表达式
     *
     * @param param 参数名
     * @param paramValue 参数值
     * @param spelExpression  表达式
     * @param clz  返回结果的类型
     * @param defaultResult 默认结果
     * @return 执行spel表达式后的结果
     */
    public static  T parse(String param, Object paramValue,String spelExpression, Class clz, T defaultResult) {
        EvaluationContext context = new StandardEvaluationContext();
        //设置上下文变量
        context.setVariable(param, paramValue);
        T result = getResult(context,spelExpression,clz);
        if(Objects.isNull(result)){
            return defaultResult;
        }
        return result;

    }


    /**
     * 获取spel表达式后的结果
     *
     * @param context 解析器上下文接口
     * @param spelExpression  表达式
     * @param clz  返回结果的类型
     * @return 执行spel表达式后的结果
     */
    private static  T getResult(EvaluationContext context,String spelExpression, Class clz){
        try {
            //解析表达式
            Expression expression = parseExpression(spelExpression);
            //获取表达式的值
            return expression.getValue(context, clz);
        } catch (Exception e) {
            log.error(e.getMessage(),e);
        }
        return null;
    }


    /**
     * 解析表达式
     * @param spelExpression spel表达式
     * @return
     */
    private static Expression parseExpression(String spelExpression){
        // 如果表达式是一个#{}表达式，需要为解析传入模板解析器上下文
        if(spelExpression.startsWith(EXPRESSION_PREFIX) && spelExpression.endsWith(EXPRESSION_SUFFIX)){
            return expressionParser.parseExpression(spelExpression,new TemplateParserContext());
        }

        return expressionParser.parseExpression(spelExpression);
    }

}

4、 示例效果

看完了这篇文章，相信你对“怎么通过aop+spel表达式玩转出不一样的切面”有了一定的了解，如果想了解更多相关知识，欢迎关注创新互联行业资讯频道，感谢各位的阅读！