1. Toy模板网首页
  2. > Toy博客

spring AOP中pointcut表达式详解

9月前 作者：HiSiri666666 分类：Toy博客 阅读(40) 违法举报

这篇具有很好参考价值的文章主要介绍了spring AOP中pointcut表达式详解。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

📢📢📢📣📣📣
哈喽！大家好，我是「奇点」，江湖人称 singularity。刚工作几年，想和大家一同进步🤝🤝
一位上进心十足的【Java ToB端大厂领域博主】！😜😜😜
喜欢java和python，平时比较懒，能用程序解决的坚决不手动解决😜😜😜

✨ 如果有对【java】感兴趣的【小可爱】，欢迎关注我

❤️❤️❤️感谢各位大可爱小可爱！❤️❤️❤️
————————————————

如果觉得本文对你有帮助，欢迎点赞，欢迎关注我，如果有补充欢迎评论交流，我将努力创作更多更好的文章。

由于项目很忙，最近很少有时间更新文章和大家分享，已经很及没更新文章了，让各位久等了。最近忙里偷闲抽空分享一些aop的知识。详细大家对这个很熟悉但也陌生，没有系统的整理过这个知识。

spring AOP中pointcut表达式详解,Spring,spring,java,后端,aop

 

本文主要介绍spring aop中9种切入点表达式的写法，相信不少同学跟我一样，没有系统的整理过aop中的pointcut的表达式。今天我们就抽空讲解一下pointcut表达式的用法和含义。

Spring AOP支持的AspectJ表达式概览：

  • execution: 匹配方法执行的切入点。Spring AOP主要使用的切点标识符。
  • within: 限制匹配在特定类型内的连接点。(给定class的所有方法)
  • this: 限制匹配是给定类型的实例的bean引用(Spring AOP proxy)的连接点。(代理类是给定类型的类的所有方法)
  • target: 限制匹配是给定类型的实例的目标对象(被代理对象)的连接点。(目标对象是给定类型的类的所有方法)
  • args: 匹配参数是给定类型的连接点。(方法入参是给定类型的方法)
  • @target: 匹配有给定注解的执行对象的class的连接点。(目标对象class上有给定注解的类的所有方法)
  • @args: 匹配实际传递的参数的运行时类型有给定的注解的连接点。(方法入参上有给定注解)
  • @within: 匹配有给定注解的类型的连接点。(class上有给定注解的class的所有方法)
  • @annotation: 匹配连接点的subject有给定注解的连接点。(方法上有给定注解的方法)
     

1.execute表达式

execution(* com.xx.web.controller..*.*(..))

参数说明

符号   含义
execution（）  表达式的主体；
第一个”*“符号   表示返回值的类型任意；
com.sample.service.impl  AOP所切的服务的包名
包名后面的”..“  表示当前包及子包
第二个”*“符号   表示类名，*即所有类
.*(..)  表示任何方法名，括号表示参数，两个点表示任何参数类型

基本语法格式为： execution(<修饰符模式>?<返回类型模式><方法名模式>(<参数模式>)<异常模式>?)

  • 修饰符匹配(modifier-pattern?)
  • 返回值匹配(ret-type-pattern)：可以为*，表示任何返回值，全路径的类名等
  • 类路径匹配(declaring-type-pattern?)
  • 方法名匹配(name-pattern)：可以指定方法名 或者*，代表所有。
  • set*， 代表以set开头的所有方法
  • 参数匹配((param-pattern))：可以指定具体的参数类型，多个参数间用“,”隔开，各个参数也可以用“*”来表示匹配任意类型的参数
  • String表示匹配一个String参数的方法；
  • *,String 表示匹配有两个参数的方法，第一个参数可以是任意类型，而第二个参数是String类型；
  • 可以用..表示零个或多个任意参数
  • 异常类型匹配(throws-pattern?)
     

下面是官网中的一些实例：

Aspect Oriented Programming with Spring :: Spring Framework

拦截任意公共方法

execution(public * *(..))

拦截以set开头的任意方法

execution(* set*(..))

拦截类或者接口中的方法

execution(* com.xyz.service.AccountService.*(..))
拦截 AccountService(类、接口)中定义的所有方法

拦截包中定义的方法，不包含子包中的方法

execution(* com.xyz.service.*.*(..))
拦截 com.xyz.service包中所有类中任意方法，不包含子包中的类

拦截包或者子包中定义的方法

execution(* com.xyz.service..*.*(..))
拦截 com.xyz.service包或者子包中定义的所有方法 
// 带?的表示可选
execution(modifiers-pattern? ret-type-pattern declaring-type-pattern?name-pattern(param-pattern)
            throws-pattern?)
  1. 方法修饰符匹配 modifier-pattern（可选）
  2. 方法返回值匹配 ret-type-pattern
  3. 类路径匹配 declaring-type-pattern（可选）
  4. 方法名和参数匹配 name-pattern(param-pattern)
  5. 异常类型匹配 throws-pattern（可选）

spring AOP中pointcut表达式详解,Spring,spring,java,后端,aop

 

简单事例

下面是execution的简单例子：

有两个IService接口分别有m1和m2方法，现在

ServiceImpl实现两个接口

实现切面Interceptor 切点如下

@Pointcut("execution(* com.ms.aop.execution.ServiceImpl.*(..))")
Interceptor1
public interface IService {
    void m1();
}

 

public interface IService2 {
    void m2();
}
package com.ms.aop.execution;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;


@Aspect
@Component
@Slf4j
public class Interceptor1 {

    @Pointcut("execution(* com.ms.aop.execution.ServiceImpl.*(..))")
    public void pointcut() {
    }

    @Around("pointcut()")
    public Object invoke(ProceedingJoinPoint invocation) throws Throwable {
        log.info("方法执行之前");
        Object result = invocation.proceed();
        log.info("方法执行完毕");
        return result;
    }
}

@Slf4j
@Component
public class ServiceImpl implements IService, IService2 {
    @Override
    public void m1() {
        log.info("切入点m1的execution测试！");
    }

    @Override
    public void m2() {
        log.info("切入点m2的execution测试！");
    }
}

 

测试类

@ComponentScan(basePackageClasses={Client.class})
@EnableAspectJAutoProxy
public class Client {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(Client.class);
        IService2 service = annotationConfigApplicationContext.getBean(IService2.class);
        IService service1 = annotationConfigApplicationContext.getBean(IService.class);
        service.m2();
        service1.m1();
    }
}

执行结果：

15:07:00.304 [main] INFO com.ms.aop.execution.Interceptor1 - 方法执行之前
15:07:00.304 [main] INFO com.ms.aop.execution.ServiceImpl - 切入点m2的execution测试！
15:07:00.304 [main] INFO com.ms.aop.execution.Interceptor1 - 方法执行完毕


15:07:00.305 [main] INFO com.ms.aop.execution.Interceptor1 - 方法执行之前
15:07:00.305 [main] INFO com.ms.aop.execution.ServiceImpl - 切入点m1的execution测试！
15:07:00.305 [main] INFO com.ms.aop.execution.Interceptor1 - 方法执行完毕

分析：

  1. @EnableAspectJAutoProxy：表示若spring创建的对象如果实现了接口，默认使用jdk动态代理，如果没有实现接口，使用cglib创建代理对象
  2. 所以 service 是使用jdk动态代理生成的对象，service instanceof ServiceImpl 为 false
  3. @Pointcut("this(com.ms.aop.jthis.demo1.ServiceImpl)")表示被spring代理之后生成的对象必须为com.ms.aop.jthis.demo1.ServiceImpl才会被拦截，但是service不是ServiceImpl类型的对象了，所以不会被拦截
  4. 修改代码

    @EnableAspectJAutoProxy(proxyTargetClass = true)
    proxyTargetClass=true表示使用cglib来生成代理对象

执行结果

17:34:43.297 [main] INFO com.ms.aop.execution.Interceptor1 - 方法执行之前
17:34:43.307 [main] INFO com.ms.aop.execution.ServiceImpl - 切入点m2的execution测试！
17:34:43.308 [main] INFO com.ms.aop.execution.Interceptor1 - 方法执行完毕


17:34:43.308 [main] INFO com.ms.aop.execution.Interceptor1 - 方法执行之前
17:34:43.308 [main] INFO com.ms.aop.execution.ServiceImpl - 切入点m1的execution测试！
17:34:43.308 [main] INFO com.ms.aop.execution.Interceptor1 - 方法执行完毕

使用cglib方式和jdk代理的方式效果是一致的。

排除和包含

实现某些的排除：@Pointcut切入点排除某一些类或者方法不进行拦截

	// 扫描controller层
    @Pointcut("execution(* com.xx.web.controller..*.*(..)) ")
    public void includePointcat() {
    }

    // 排除controller类
    @Pointcut("execution(* com.xx.web.controller.TempController.*(..)) ")
    public void excludePointcut() {
    }

    //切面配置
    @AfterReturning("includePointcat() && !excludePointcut()")
    public void saveSysLog(JoinPoint joinPoint) throws IOException {
        String className = joinPoint.getSignature().getDeclaringType().getSimpleName();
	    String methodName = joinPoint.getSignature().getName();
	    logger.info("{}.{} start", className, methodName);
	}

includePointcat：切入点为controller下所有类。

excludePointcut：切入点为controller下TempController类。

saveSysLog：切入点为满足 includePointcat且不满足excludePointcut的切入点的范围

2.within表达式

表达式格式：包名.* 或者 包名..*

拦截包中任意方法，不包含子包中的方法

within(com.xyz.service.*)
拦截service包中任意类的任意方法

拦截包或者子包中定义的方法

within(com.xyz.service..*)
拦截service包及子包中任意类的任意方法

within与execution相比，粒度更大，仅能实现到包和接口、类级别。而execution可以精确到方法的返回值，参数个数、修饰符、参数类型等

3.this表达式

代理对象为指定的类型会被拦截

目标对象使用aop之后生成的代理对象必须是指定的类型才会被拦截，注意是目标对象被代理之后生成的代理对象和指定的类型匹配才会被拦截 
this(com.xyz.service.AccountService)

例如下面的例子

package com.ms.aop.jthis.demo1;
​
public interface IService {
    void m1();
}

package com.ms.aop.jthis.demo1;
​
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
​
@Slf4j
@Component
public class ServiceImpl implements IService {
    @Override
    public void m1() {
        log.info("切入点this测试！");
    }
}

package com.ms.aop.jthis.demo1;
​
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
@Aspect
@Component
@Slf4j
public class Interceptor1 {
​
    @Pointcut("this(com.ms.aop.jthis.demo1.ServiceImpl)")
    public void pointcut() {
    }
​
    @Around("pointcut()")
    public Object invoke(ProceedingJoinPoint invocation) throws Throwable {
        log.info("方法执行之前");
        Object result = invocation.proceed();
        log.info("方法执行完毕");
        return result;
    }
}

package com.ms.aop.jthis.demo1;
​
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
​
@ComponentScan(basePackageClasses = {Client.class})
@EnableAspectJAutoProxy
@Slf4j
public class Client {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(Client.class);
        IService service = annotationConfigApplicationContext.getBean(IService.class);
        service.m1();
        log.info("{}", service instanceof ServiceImpl);
    }
}

注意这里的代理对象类型的定义

 @Pointcut("this(com.ms.aop.jthis.demo1.ServiceImpl)")

结果：

10:27:12.277 [main] INFO com.ms.aop.jthis.demo1.ServiceImpl - 切入点this测试！
10:27:12.277 [main] INFO com.ms.aop.jthis.demo1.Client - false
  1. @EnableAspectJAutoProxy：表示若spring创建的对象如果实现了接口，默认使用jdk动态代理，如果没有实现接口，使用cglib创建代理对象
  2. 所以 service 是使用jdk动态代理生成的对象，service instanceof ServiceImpl 为 false
  3. @Pointcut("this(com.ms.aop.jthis.demo1.ServiceImpl)")表示被spring代理之后生成的对象必须为com.ms.aop.jthis.demo1.ServiceImpl才会被拦截，但是service不是ServiceImpl类型的对象了，所以不会被拦截
  4. 修改代码

    @EnableAspectJAutoProxy(proxyTargetClass = true)
    proxyTargetClass=true表示使用cglib来生成代理对象
    执行结果:

    10:34:50.736 [main] INFO com.ms.aop.jthis.demo1.Interceptor1 - 方法执行之前
    10:34:50.755 [main] INFO com.ms.aop.jthis.demo1.ServiceImpl - 切入点this测试！
    10:34:50.756 [main] INFO com.ms.aop.jthis.demo1.Interceptor1 - 方法执行完毕
    10:34:50.756 [main] INFO com.ms.aop.jthis.demo1.Client - true
    service 为 ServiceImpl类型的对象，所以会被拦截

4.target表达式

目标对象为指定的类型被拦截

target(com.xyz.service.AccountService)
目标对象为AccountService类型的会被代理 
package com.ms.aop.target;
​
public interface IService {
    void m1();
}

package com.ms.aop.target;
​
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
​
@Slf4j
@Component
public class ServiceImpl implements IService {
    @Override
    public void m1() {
        log.info("切入点target测试！");
    }
}

package com.ms.aop.target;
​
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
​
@Aspect
@Component
@Slf4j
public class Interceptor1 {
​
    @Pointcut("target(com.ms.aop.target.ServiceImpl)")
    public void pointcut() {
    }
​
    @Around("pointcut()")
    public Object invoke(ProceedingJoinPoint invocation) throws Throwable {
        log.info("方法执行之前");
        Object result = invocation.proceed();
        log.info("方法执行完毕");
        return result;
    }
}

package com.ms.aop.target;
​
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
​
@ComponentScan(basePackageClasses = {Client.class})
@EnableAspectJAutoProxy
public class Client {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(Client.class);
        IService service = annotationConfigApplicationContext.getBean(IService.class);
        service.m1();
    }
}

执行结果

10:49:01.674 [main] INFO com.ms.aop.target.Interceptor1 - 方法执行之前
10:49:01.674 [main] INFO com.ms.aop.target.ServiceImpl - 切入点target测试！
10:49:01.674 [main] INFO com.ms.aop.target.Interceptor1 - 方法执行完毕

this 和 target 的不同点

  1. this作用于代理对象，target作用于目标对象
  2. this表示目标对象被代理之后生成的代理对象和指定的类型匹配会被拦截，匹配的是代理对象
  3. target表示目标对象和指定的类型匹配会被拦截，匹配的是目标对象

5.args 表达式

匹配方法中的参数

@Pointcut("args(com.ms.aop.args.demo1.UserModel)")
匹配只有一个参数，且类型为 com.ms.aop.args.demo1.UserModel

匹配多个参数

args(type1,type2,typeN)

匹配任意多个参数

@Pointcut("args(com.ms.aop.args.demo1.UserModel,..)")
匹配第一个参数类型为 com.ms.aop.args.demo1.UserModel的所有方法,  .. 表示任意个参数

6.@target表达式

匹配的目标对象的类有一个指定的注解

@target(com.ms.aop.jtarget.Annotation1)
目标对象中包含 com.ms.aop.jtarget.Annotation1注解，调用该目标对象的任意方法都会被拦截

7.@within表达式

指定匹配必须包含某个注解的类里的所有连接点

@within(com.ms.aop.jwithin.Annotation1)
声明有 com.ms.aop.jwithin.Annotation1注解的类中的所有方法都会被拦截

@target 和 @within 的不同点

  1. @target(注解A)：判断被调用的目标对象中是否声明了注解A，如果有，会被拦截
  2. @within(注解A)： 判断被调用的方法所属的类中是否声明了注解A，如果有，会被拦截
  3. @target关注的是被调用的对象，@within关注的是调用的方法所在的类

8.@annotation表达式

匹配有指定注解的方法（注解作用在方法上面）

@annotation(com.ms.aop.jannotation.demo2.Annotation1)
被调用的方法包含指定的注解

9.@args表达式

方法参数所属的类型上有指定的注解，被匹配

注意：是 方法参数所属的类型上有指定的注解，不是方法参数中有注解
  • 匹配1个参数，且第1个参数所属的类中有Anno1注解
@args(com.ms.aop.jargs.demo1.Anno1)
  • 匹配多个参数，且多个参数所属的类型上都有指定的注解
@args(com.ms.aop.jargs.demo1.Anno1,com.ms.aop.jargs.demo1.Anno2)
  • 匹配多个参数，且第一个参数所属的类中有Anno1注解
@args(com.ms.aop.jargs.demo2.Anno1,..)

spring AOP中pointcut表达式详解,Spring,spring,java,后端,aop

 

项目实战：

下面是切面的一个项目应用 实现服务日志的记录

@Aspect
@Component
@Slf4j
public class SealServiceControllerAspect {

    @Autowired
    private InterfaceLogDao interfaceLogDao;
    /**
     * 日志入库异步模式,线程池用fk pool
     */
    private static ForkJoinPool LOG_THREAD_POOL = new ForkJoinPool(4);

    @Pointcut("" +
            "execution(* com.xx.seal.RestSignContractResource.*(..))" +
            "|| execution(* com.xx.controller.seal.ContractProcessSignResource.*(..))"
            
    )
    public void pointCuts() {
    }

    @Around("pointCuts()")
    public Object invoke(ProceedingJoinPoint invocation) throws Throwable {
        final InterfaceLogPO po = new InterfaceLogPO();
        Object[] inParam = invocation.getArgs();
        JSONArray inParams = new JSONArray();
        if (inParam != null) {
            Arrays.stream(inParam).forEach(p -> {
                try {
                    if (p instanceof String||
                        p instanceof Number ||
                        p instanceof Boolean
                    ){
                        inParams.add(p);
                    }else if (JSONUtils.isArray(p)) {
                        try {
                            inParams.add(JSONArray.fromObject(p));
                        } catch (Exception e) {
                            log.warn("==>this aspect[{}] can not get input param ", invocation.getSignature().getName());
                        }
                    } else {
                        try {
                            inParams.add(JSONObject.fromObject(p));
                        } catch (Exception e) {
                            log.warn("==>this aspect[{}] can not get input param ", invocation.getSignature().getName());
                        }

                    }

                } catch (Exception e) {
                    log.warn("==>aspect error :can not fetch args --->{}", e.getMessage());
                }
            });
        }
        if (invocation.getTarget().getClass().getName().endsWith("Resource") ||
                invocation.getTarget().getClass().getName().endsWith("Controller")
        ) {
            po.setCategory("REST");
        } else {
            po.setCategory("SERVICE");
        }
        po.setAction(invocation.getTarget().getClass().getName() + "@" + invocation.getSignature().getName());
        po.setActionDesc("");// 从swagger的@Api注解中取
        po.setInputParam(inParams.toString());
        po.setTs(new Date());
        po.setCallStatus("OK");
        po.setUserId(InvocationInfoProxy.getUserid());
        
        po.setUserName(InvocationInfoProxy.getUsername());
        Object result = null;
        try {
            result = invocation.proceed();
        } catch (Throwable throwable) {
            po.setCallStatus("ERR");
            StringBuilder sb = new StringBuilder( throwable.getMessage()+"\n");
            sb.append(ExceptionUtils.getFullStackTrace(throwable)).append("\n");
            po.setErrorMessage(sb.toString());
            throw throwable;
        } finally {
            if (result != null) {
                if (result instanceof String  ||
                        result instanceof Number ||
                        result instanceof Boolean){
                    po.setOutputResult(result.toString());
                }else if (JSONUtils.isArray(result)) {
                    try {
                        po.setOutputResult(
                                JSONArray.fromObject(result).toString()
                        );
                    } catch (Exception e) {
                        log.warn("==>this aspect[{}] can not get output result ", invocation.getSignature().getName());
                    }

                } else {
                    try {
                        po.setOutputResult(
                                JSONObject.fromObject(result).toString()
                        );
                    } catch (Exception e) {
                        log.warn("==>this aspect[{}] can not get output result", invocation.getSignature().getName());
                    }

                }
                /*
                这部分以后要改造成基于接口的插件式!!!
                 */
                if (result instanceof Result && ((Result) result).getData() != null) {
                    //后续考虑引入策略模式
                    if (((Result) result).getData() instanceof ResultContractProcessDTO
                    ) {
                        String bizKey = ((ResultContractProcessDTO) ((Result) result).getData()).getProcessId();
                        po.setBizKey(bizKey);
                    } else {
                        try {
                            JSONObject outputResult = JSONObject.fromObject(((Result) result).getData());
                            po.setBizKey(outputResult.getString("id"));
                        } catch (Exception e) {
                            log.warn("==>this aspect[{}] can not get biz key", invocation.getSignature().getName());
                        }
                    }
                }
                if (result instanceof  ResultContractProcessDTO){
                    String bizKey = ((ResultContractProcessDTO) result).getProcessId();
                    po.setBizKey(bizKey);
                }
            }
           
            interfaceLogDao.save(po);
        }
        return result;
    }


}

希望这个文章能让大家有所收获，哪怕有一点点的收获，这样我写这个文章也就值得了。

spring AOP中pointcut表达式详解,Spring,spring,java,后端,aop

创作不易，请给小编点个赞吧，一个字一个字敲下来很费时间和精力的😄 文章来源地址https://www.toymoban.com/news/detail-548537.html

到了这里，关于spring AOP中pointcut表达式详解的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 最新最全面的Spring详解（三）——Resources，验证、数据绑定和类型转换与Spring表达式语言（SpEL）

    最新最全面的Spring详解（三）——Resources，验证、数据绑定和类型转换与Spring表达式语言（SpEL）

    本文为 【Spring】Resources与Spring表达式语言（SpEL） 等相关知识，下边将对 Resources （包含： Resource接口 、 内置的 Resource的实现 、 ResourceLoader接口 、 应用环境和资源路径 ）， 验证、数据绑定和类型转换 （包含： BeanWrapper 、 PropertyEditor属性编辑器 、 类型转换 、 配置 DataB

    2023年04月26日
    浏览(46)
  • Spring：表达式语言

    Spring：表达式语言

    Spring 表达式（Spring EL） 是一种功能强大的表达式语言，以 #{ 表达式 } 作为定界符，用于在运行时对对象进行访问和操作。通过使用 Spring 表达式达到简化开发、减少逻辑或配置的编写的目的。 Spring EL 主要可以引用 bean ，调用其属性和方法，也可以在 bean 标签中使用 value 属

    2024年02月16日
    浏览(54)

  • Spring中的SpEL表达式

    SpEL (Spring Expression Language) 是 Spring 框架中用于在运行时对对象图进行查询和操作的表达式语言。它可以在不引入 Java 代码的情况下，轻松地对对象进行值的计算、属性的读取、调用方法、访问数组和集合等。SpEL广泛应用于Spring框架的许多模块中，比如Spring MVC、Spring Data、Sp

    2024年02月15日
    浏览(49)

  • Spring表达式语言（SPEL）学习（03）

    在表达式中直接写name和getName()，这时候Expression是无法解析的，因为其不知道name和getName()对应什么意思 当表达式是基于某一个对象时，我们可以把对应的对象作为一个rootObject传递给对应的Experssion进行取值 通过指定EvaluationContext我们可以让name和getName()变得有意义，指定了Ev

    2024年02月02日
    浏览(48)
  • Spring高手之路3——揭秘Spring依赖注入和SpEL表达式

    Spring高手之路3——揭秘Spring依赖注入和SpEL表达式

    本篇会给大家举出各种 Spring 属性依赖注入的例子，方便大家理解。 我们在前面的文章中已经使用过 XML 进行 setter 方法的属性注入了，下面让我们再来回顾一下： 我们在前面的文章中也学习过如何在 bean 创建时通过编程方式设置属性： 使用XML进行setter方法注入 首先，我们需

    2024年02月08日
    浏览(45)
  • Spring Security 中自定义权限表达式

    Spring Security 中自定义权限表达式

    前言 这是我在这个网站整理的笔记,有错误的地方请指出，关注我，接下来还会持续更新。 作者：神的孩子都在歌唱 通过编程授权方法 首先，声明一个 Bean，如下所示： 然后，在注解中以如下方式引用该 Bean： Spring Security 将在每次方法调用时调用该Bean上的给定方法。 这样

    2024年02月06日
    浏览(53)

  • 揭秘Spring依赖注入和SpEL表达式

    摘要： 在本文中，我们深入探讨了Spring框架中的属性注入技术，包括setter注入、构造器注入、注解式属性注入，以及使用SpEL表达式进行属性注入。 本文分享自华为云社区《Spring高手之路3——揭秘Spring依赖注入和SpEL表达式》，作者：砖业洋__ 。 在本文中，我们深入探讨了

    2024年02月08日
    浏览(40)
  • 深入理解Spring EL表达式的高级功能

    深入理解Spring EL表达式的高级功能

    欢迎来到我的博客，代码的世界里，每一行都是一个故事 EL表达式不仅仅局限于基础用法，它还提供了丰富的高级功能。在这篇博客中，我们将揭开这些功能的神秘面纱，让你成为EL表达式的真正大师。 在EL（Expression Language）表达式中，可以使用各种操作符和语法来操作集合

    2024年01月25日
    浏览(45)

  • 【Spring Boot】Thymeleaf模板引擎 — 表达式的语法

    模板的主要作用是将后台返回的数据渲染到HTML中。那么Thymeleaf是如何解析后台数据的呢？接下来从变量、方法、条件判断、循环、运算（逻辑运算、布尔运算、比较运算、条件运算）方面学习Thymeleaf表达式支持的语法。 （1）文本赋值 赋值就是通过${}标签将后台返回的数据替

    2024年02月14日
    浏览(39)
  • Spring 定时任务@Scheduled 注解中的 Cron 表达式

    Spring 定时任务@Scheduled 注解中的 Cron 表达式

    Spring 框架提供了强大的定时任务功能，通过 @Scheduled 注解可以方便地定义和管理定时任务。其中，Cron 表达式作为定时任务触发的时间表达式，扮演着重要的角色。本篇博客将详细介绍和讲解 Cron 表达式的语法和常见用法，帮助各位更好地理解和使用 Spring 的定时任务功能。

    2024年02月11日
    浏览(42)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包