SpringBoot学习日记四（整合实现AOP（自定义注解）-注解式拦截&方法规则拦截）

最新推荐文章于 2023-09-15 17:25:07 发布
最新推荐文章于 2023-09-15 17:25:07 发布
阅读量771 收藏 2
点赞数
分类专栏： java 文章标签： springboot springboot实现AOP springbootAOP自定义注解式拦截 springbootAOP方法规则式拦截
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ldswan0/article/details/94171704
版权

AOP的介绍我就不说了，大家自行百度。

还是springBootDemo这个项目，使用aop，先在pow.xml中引入依赖。

<!--AOP依赖，此依赖已包含AspectJ相关依赖包。-->

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
    <version>2.0.6.RELEASE</version>
</dependency>

添加依赖之后我们就可以去实现AOP的一个简单例子。

我们首先在com.lds.springbootdemo下新建aop包。既然是注解实现就先在这个aop包下新建一个自定义注解：

AnnotationAOP.java

package com.lds.springbootdemo.aop;
import java.lang.annotation.*;

/**
 * @program: springBootDemo
 * @description: 使用AOP注解拦截
 * @author:
 * @createData:
 * @updateAuthor:
 * @updateData:
 * @updateContent: 使用AOP注解拦截
 * @Version: 1.0
 * @email: lidongshenglife@163.com
 * @blog: www.b0c0.com
 */
    /**
     * 定义了该注解可以出现在哪里。常用的：
     * TYPE：类, 接口 (包括注释类型), 或 枚举 声明
     *     FIELD：字段声明（包括枚举常量）
     *     METHOD：方法声明
     */
    @Target(ElementType.METHOD)
    /**
     * Reteniton的作用是定义被它所注解的注解保留多久
     * SOURCE
     * 被编译器忽略。
     * CLASS
     * 注解将会被保留在Class文件中，但在运行时并不会被VM保留。
     * 这是默认行为，所有没有用Retention注解的注解，都会采用这种策略。
     * RUNTIME
     * 保留至运行时。所以我们可以通过反射去获取注解信息。
     */
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface AnnotationAOP {
        String name();
    }

然后在com.lds.springbootdemo.aop包下面新建一个aspect包。里面来存放我们的切面。

我们来新建一个TestAspect.java

TestAspect.java

package com.lds.springbootdemo.aop.aspect;

import com.lds.springbootdemo.aop.AnnotationAOP;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;
import java.lang.reflect.Parameter;

/**
 * @program: springBootDemo
 * @description: AOP拦截切面类
 * @author: lidongsheng
 * @createData:
 * @updateAuthor: lidongsheng
 * @updateData:
 * @updateContent: AOP拦截切面类
 * @Version: 1.0
 * @email: lidongshenglife@163.com
 * @blog: www.b0c0.com
 */
@Aspect
@Component
public class TestAspect {

    /**
     * 注解是拦截定义切入点，切入点为com.example.aop下的所有函数
     */
    @Pointcut("@annotation(com.lds.springbootdemo.aop.AnnotationAOP)")
    public void annotationPoinCut(){
    }

    /**
     * 前置通知，方法调用前被调用 执行顺序：1
     * @param joinPoint/null
     */
    @Before("annotationPoinCut()")
    public void before(JoinPoint joinPoint){
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        AnnotationAOP action = method.getAnnotation(AnnotationAOP.class);
        Parameter[] ps =method.getParameters();
        System.out.println("该方法执行之前：注解式拦截.第一个参数:"+ps[0].toString()+"自定义注解的name值"+action.name());
    }
    /**
     * 后置通知（目标方法只要执行完了就会执行后置通知方法，不管是否出现异常） 属于方法规则式拦截 执行顺序：2
     * @param joinPoint
     */
    @After("execution(* com.lds.springbootdemo.controller.login_register.LoginController.loginValidate(..))")
    public void after(JoinPoint joinPoint){
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        AnnotationAOP action = method.getAnnotation(AnnotationAOP.class);
        System.out.println("该方法执行之后：方法规则式拦截,"+method.getName());
    }
    /**
     * 后置返回通知  在切入点return内容之后切入内容（可以用来对处理返回值做一些加工处理） 执行顺序：3
     * 这里需要注意的是:
     *      如果参数中的第一个参数为JoinPoint，则第二个参数为返回值的信息
     *       returning：限定了只有目标方法返回值与通知方法相应参数类型时才能执行后置返回通知，否则不执行，
     *       对于returning对应的通知方法参数为Object类型将匹配任何目标返回值
     * @param joinPoint
     * @param keys
     */
    @AfterReturning(value = "annotationPoinCut()",returning = "keys")
    public void doAfterReturningAdvice1(JoinPoint joinPoint,Object keys){
        System.out.println("该方法执行返回结果：注解式拦截 "+keys);
    }

}

如何使用呢？就好比我们想在登录的service中去进行aop自定义的注解去拦截来实现具体的方法。 然后我们就在登录的LoginServiceImpl的loginValidate方法上面加上：

@AnnotationAOP(name = "loginValidate")

name就是我们自定义注解接口中写的name属性。而name的值自己随便定义，就是来达到自定义功能的效果。所以自定义注解的里面的属性自己随便定义来达到我们预期的功能即可。

LoginServiceImpl.java

package com.lds.springbootdemo.service.login_register;

import com.lds.springbootdemo.aop.AnnotationAOP;
import com.lds.springbootdemo.dao.DaoSupport;
import com.lds.springbootdemo.domain.sbd_user;
import com.lds.springbootdemo.mapper.sbd_userMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @program: springbootdemo
 * @description:
 * @author:
 * @createData: 
 * @updateAuthor:
 * @updateData: 
 * @updateContent:
 * @Version: 1.0
 * @email: lidongshenglife@163.com
 * @blog: www.b0c0.com
 */

@Service
public class LoginServiceImpl implements LoginService {

    //@Autowired
    //private sbd_userMapper userMapper;
    @Autowired
    private DaoSupport dao;
    /**
     * 登录验证Service
     * @return
     */
    @Override
    @AnnotationAOP(name = "loginValidate")
    public boolean loginValidate(String account,String password) {
        boolean retu=false;
        //sbd_user em=userMapper.selectByAccount(account);
        sbd_user user= null;
        try {
            user = (sbd_user) dao.selectForOne("sbd_userMapper.selectByAccount",account);
        } catch (Exception e) {
            e.printStackTrace();
        }
        if(user!=null&&password.equals(user.getPassword())){
            retu=true;
        }
        return retu;
    }
}

然后我们就可以启动项目，去在浏览器中登录，然后通过查看控制台的输出结果来确定是否拦截成功了。

运行结果如下图所示：

上面只是用到了两个 @Before、@After、@AfterReturning。

其实最常用的还有@Around环绕通知也是最重要的通知类型，在目标方法完成前后做增强处理,像事务,日志等都是环绕通知。

TestAspect.java

package com.lds.springbootdemo.aop.aspect;

import com.lds.springbootdemo.aop.AnnotationAOP;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;
import java.lang.reflect.Parameter;

/**
 * @program: springBootDemo
 * @description: AOP拦截切面类
 * @author: lidongsheng
 * @createData:
 * @updateAuthor: lidongsheng
 * @updateData:
 * @updateContent: AOP拦截切面类
 * @Version: 1.0
 * @email: lidongshenglife@163.com
 * @blog: www.b0c0.com
 */
@Aspect
@Component
public class TestAspect {


//    /**
//     * 注解是拦截定义切入点，切入点为com.example.aop下的所有函数
//     */
//    @Pointcut("@annotation(com.lds.springbootdemo.aop.AnnotationAOP)")
//    public void annotationPoinCut(){
//    }
//
//    /**
//     * 前置通知，方法调用前被调用 执行顺序：1
//     * @param joinPoint/null
//     */
//    @Before("annotationPoinCut()")
//    public void before(JoinPoint joinPoint){
//        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
//        Method method = signature.getMethod();
//        AnnotationAOP action = method.getAnnotation(AnnotationAOP.class);
//        Parameter[] ps =method.getParameters();
//        System.out.println("注解式拦截 该方法执行之前：第一个参数:"+ps[0].toString()+"    自定义注解的name值:"+action.name());
//    }
//
//    /**
//     * 后置通知（目标方法只要执行完了就会执行后置通知方法,不管是否出现异常） 执行顺序：2
//     * @param joinPoint
//     */
//    @After("execution(* com.lds.springbootdemo.service.login_register.LoginServiceImpl.loginValidate(..))")
//    public void after(JoinPoint joinPoint){
//        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
//        Method method = signature.getMethod();
//        AnnotationAOP action = method.getAnnotation(AnnotationAOP.class);
//        System.out.println("方法规则式拦截 该方法执行之后："+method.getName());
//    }
//    /**
//     * 后置返回通知  在切入点return内容之后切入内容（可以用来对处理返回值做一些加工处理） 执行顺序：3
//     * 这里需要注意的是:
//     *      如果参数中的第一个参数为JoinPoint，则第二个参数为返回值的信息
//     *       returning：限定了只有目标方法返回值与通知方法相应参数类型时才能执行后置返回通知，否则不执行，
//     *       对于returning对应的通知方法参数为Object类型将匹配任何目标返回值
//     * @param joinPoint
//     * @param keys
//     */
//    @AfterReturning(value = "annotationPoinCut()",returning = "keys")
//    public void doAfterReturningAdvice1(JoinPoint joinPoint,Object keys){
//        System.out.println("注解式拦截 该方法执行返回结果： "+keys);
//    }

    /**
     * 环绕通知 在目标方法完成前后做增强处理，也是最重要的通知类型，像事务,日志等都是环绕通知。
     * @param joinPoint
     * @return
     */
    //@Around("annotationPoinCut()") ProceedingJoinPoint是子类，只能用在@Around中
    @Around("execution(* com.lds.springbootdemo.service.login_register.LoginServiceImpl.loginValidate(..))")
    public Object invoke(ProceedingJoinPoint joinPoint) {
        //.这里获取到所有的参数值的数组
        Object[] parameterValues = joinPoint.getArgs();
        Signature signature = joinPoint.getSignature();
        MethodSignature methodSignature = (MethodSignature) signature;
        //.通过这获取到方法的所有参数名称的字符串数组
        String[] parameterNames = methodSignature.getParameterNames();
        //得到执行方法的方法名
        String methodName=methodSignature.getMethod().getName();
        System.out.println("环绕拦截前");
        Object obj = null;
        try {
            obj = joinPoint.proceed();//调用执行目标方法并得到执行方法的返回值
        } catch (Throwable throwable) {
            throwable.printStackTrace();
            System.out.println("环绕拦截执行方法出错");
        }
        System.out.println("环绕拦截后");
        return obj;
    }


}

如果是自定义注解拦截就直接在目标方法上面加自定义注解，如果方法规则拦截直接在写切入点表达式来写要拦截的规则即可。

运行结果如下：

我已经把这个的实例放在git中了，欢迎大家拉取下载以及指出错误，可以的话给标个小星星~~~地址：

https://github.com/DeBug-Bug/springBootDemo.git

我的博客地址 www.b0c0.com 欢迎访问

呦-写bug呢
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot —— AOP注解式拦截与方法规则拦截
11-07 1108
AspectJ是一个面向切面的框架，它扩展了Java语言。AspectJ定义了AOP语法，所以它有一个专门的编译器用来生成遵守Java字节编码规范的Class文件。 　　SpringBoot中AOP的使用方式主要有两种：注解式拦截与方法规则拦截，具体使用如下文所示。 一、创建一个简单springboot 2.03项目，添加aop依赖 &lt;dependency&gt; &lt;...
SpringBoot-自定义注解AOP实现及拦截器示例
最新发布
04-12
在Spring Boot框架中，自定义注解和AOP（面向切面编程）是两种强大的工具，可以帮助我们实现灵活...在提供的&quot;SpringBoot-自定义注解AOP实现及拦截器示例代码&quot;中，你可以找到具体的实现细节，进一步学习和实践这些概念。
Spring AOP VS AspectJ
weixin_34452850的博客
07-07 289
Spring AOP 使用简单 仅支持对Spring容器管理的Bean的增强，非Spring容器管理的对象(如业务POJO等)无法被拦截 仅支持对方法级别的增强，无法对成员变量、getter&amp;setter等进行增强 动态代理类在运行时生成 无法直接对方法内部调用进行增强 无需引入额外的依赖和插件 AspectJ 使用相对复杂 可以对项目中所有对象进行增强 可以对类的方法、成员变量...
使用aop拦截自定义注解
weixin_43075758的博客
12-01 2377
使用aop拦截自定义注解校验访问权限
AOP实现拦截对象以及获取切入目标方法和注解
weixin_34159110的博客
03-28 618
AOP实现拦截对象以及获取切入目标方法和注解   一、JoinPoint是什么？   AspectJ使用org.aspectj.lang.JoinPoint接口表示目标类连接点对象，如果是环绕增强时，使用 org.aspectj.lang.ProceedingJoinPoint表示连接点对象，该类是JoinPoint的子接口。任何一个增强方法都可以 通过将第一个入参声明为JoinPoint访...
用aspectj拦截mybatis mapper的一种可行方案
电磁阻尼
04-23 2191
注意、方案没有经过大量测试，只是自己简单测试了一下 下面列出实现的大致步骤 1、我们的mapper层接口统一实现一个接口比如Mapper接口 2、Aspect切面定义时候切点匹配用this或者target eg: MethodInvocation methodInvocation = ExposeInvocationInterceptor.currentInvocation();这个句有值是因为...
SpringBoot 利用自定义注解实现AOP拦截控制
Ulrich蚊子Blog
09-27 9919
在 SpringBoot 中，利用 AOP 实现拦截控制的方法有很多，个人觉得相对比较简洁、比较简单的方式是通过自定义注解实现拦截控制。这种实现方式只需要预先定义一个新的注解，并实现拦截控制的具体业务逻辑，当我们想要拦截某一个方法进行控制时，只需要在方法前加上该注解，通常不需要做过多的调整。在实际工程应用中，这种实现方式确实有效提升了开发效率。 AOP 的基本概念 AOP 是 Aspect-oriented Programming 的缩写，常译作”面向切面编程“，通俗理解就是在程序运行的链路中，从某一个横切
自定义注解实现拦截sql.rar
10-08
2. 性能影响：虽然注解拦截提供了灵活性，但过度使用可能会对性能产生影响，因此需要权衡利弊。 3. 数据安全：动态修改SQL条件时要确保SQL注入的安全性，避免恶意输入导致的漏洞。 4. 代码可读性：过多的注解可能...
详解SpringBoot AOP 拦截器（Aspect注解方式）
08-30
在 SpringBoot 项目中，AspectJ 是一种常用的 AOP 实现方式，通过使用 AspectJ 注解，可以轻松地实现方法拦截和增强。下面将详细介绍 SpringBoot AOP 拦截器的实现方式。 一、 Filter、HandlerInterceptor 和 ...
SpringBoot使用AOP+注解实现简单的权限验证的方法
08-25
SpringBoot 使用 AOP+注解实现简单的权限验证的方法 SpringBoot 框架提供了强大的权限验证机制，以确保应用程序的安全性。其中一种方法是使用 AOP（Aspect-Oriented Programming）和注解来实现简单的权限验证。本文...
SpringBoot AOP各种注解、自定义注解、鉴权使用案例（免费下载）
02-24
SpringBoot AOP，即面向切面编程，是Spring框架中的一个重要特性，用于实现代码的横切关注点，如日志记录、事务管理、权限验证等。AOP通过使用代理模式，将这些关注点与核心业务逻辑分离，使得代码更加模块化，更...
spring aop拦截指定方法和自定义注解
mnhpo_Q的博客
04-11 5197
1、使用aop需要加入maven依赖 &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-aop...
AOP 拦截注解
mis_huang的博客
04-24 1078
package com.msxf.demo.aspect; import com.msxf.demo.annotation.Inner; import lombok.SneakyThrows; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.Around; import org.aspectj.lang.annotation.Aspect; import org.springframework.
自定义注解（AOP、拦截器）
qq_22858799的博客
09-15 1063
Slf4j@Component@Aspect/*** 定义切点*//*** 环绕通知* @return*/log.info("请求链接：{}", httpServletRequest.getRequestURL().toString());log.info("请求类型:{}", httpServletRequest.getMethod());
SpringAop与AspectJ的局限性
weixin_33946605的博客
04-14 156
2019独角兽企业重金招聘Python工程师标准&gt;&gt;&gt; ...
springboot切面AOP拦截父类或接口中标记注解的方法
OceanSky的专栏
01-18 8876
一、注解的继承性回顾 被@Inherited元注解标注的注解标注在类上的时候，子类可以继承父类上的注解。 注解未被@Inherited元注解标注的，该注解标注在类上时，子类不会继承父类上标注的注解。 注解标注在接口上，其子类及子接口都不会继承该注解 注解标注在类或接口方法上，其子类重写该方法不会继承父类或接口中方法上标记的注解 根据注解继承的特性，我们再做AOP切面拦截的时候会遇到拦截不到的问题，今天我们就讲解下对这些特殊情况如何解决，对源码不做过渡深入的讲解。 二、注解标注在父类、接口、父类方法、
springboot项目开启aop后getAnnotation拿不到原生类的解决方法
weixin_45074679的博客
05-24 1836
//获取项目所有url public String getAllUrl(ConfigurableApplicationContext run) { LOGGER.info("getAllUrl Method is called."); StringBuilder sbSql = new StringBuilder(); sbSql.append("INSERT INTO interfacelist(url,name,type) values");.
延时队列（Delayed）实现（支持失败重试机制自定义重试时间）
写Bug小能手
10-10 2901
最初的业务场景就是： 需要需要使用restTemplate调用个接口并且调用失败后需要延时重复调用（最多3次），第一次5秒，第二次10秒，第三次15秒。 1. 主要功能 最起初的话思考如果只是简单这样的话其实也好实现，重写httpClient里面就有相关的超时重试机制，但是如果要是实现了某个整体的方法来进行失败重试那不能更好。所以就根据这个想法实现了以下的几个功能： 可以更简单的针对整个方法来进行延时或者有失败重试的调用执行。 可以设置首次是否延迟执行以及延迟执行的时间。 可以设置失败重试调用的
springboot aop自定义注解
11-08
SpringBoot AOP可以通过自定义注解来实现对方法的拦截和增强。具体步骤如下： 1. 在pom.xml文件中添加spring-boot-starter-aop依赖。 2. 创建自定义注解，使用@Target和@Retention注解指定注解的作用范围和生命周期。 3. 创建切面类，使用@Aspect注解标注该类为切面类，使用@Around注解标注需要拦截的方法，并在方法中编写增强逻辑。 4. 在启动类上添加@EnableAspectJAutoProxy注解开启AOP功能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值