Spring Boot AOP切面接口开发

最新推荐文章于 2024-06-16 17:27:55 发布
最新推荐文章于 2024-06-16 17:27:55 发布
阅读量1.5k 收藏 2
点赞数
分类专栏： SpringBoot 文章标签： spring boot 后端 aop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42346678/article/details/122846526
版权

1、自定义一个注解

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface DBChange {
​
}

2、创建切面类

@Aspect
@Component
@Log4j
public class DBChangeAop {

    //切面链接处
    @Pointcut("@annotation(com.ggdo.manager.util.DBChange)")
    public void cutMethod(){}
​
    @Before(value = "cutMethod() && @annotation(dbChange)")
    public void doBeforeCut(JoinPoint joinPoint,DBChange dbChange) throws Exception{
        log.info("Before增强");
        
        //自定义工具类解析注接类传入参数
        String projectId = (String)DBChangeResolver.newInstance().resolver(joinPoint,dbChange.projectId());
        String environmentType = (String)DBChangeResolver.newInstance().resolver(joinPoint,dbChange.environmentType());
        log.info("projectId:"+projectId);
        log.info("environmentType:"+environmentType);
        if (projectId == null || "".equals(projectId) ){
            throw new CommonException("projectId不能为空！");
        }
​
    }
​
    @After(value = "cutMethod()")
    public void doAfterCut(JoinPoint joinPoint){
       log.info("After增强");
    }
}

注：

@Aspect：表示该类是切面类。

@Pointcut("@annotation(com.ggdo.manager.util.DBChange)") ：切面连接处，添加此连接以后，有DBChange注解的地方，进行切面切入。

2.1 AOP注解详解

2.1.1 @Aspect

名称：@Aspect 类型：

注解 位置：类定义上方

作用：设置当前类为切面类

格式：

@Aspect

public class AopAdvice {

}

说明：一个beans标签中可以配置多个aop:config标签

2.2.2 @Pointcut

名称：@Pointcut

类型：注解

位置：方法定义上方

作用：使用当前方法名作为切入点引用名称

格式：

@Pointcut(“execution(* *(…))”)

public void pt() {

}

说明：被修饰的方法忽略其业务功能，格式设定为无参无返回值的方法，方法体内空实现（非抽象）

2.2.3 @Before

名称：@Before

类型：注解

位置：方法定义上方

作用：标注当前方法作为前置通知

格式：

@Before(“pt()”) public void before(){

}

特殊参数： 无

2.2.4 @After

名称：@After

类型：注解

位置：方法定义上方

作用：标注当前方法作为后置通知

格式：

@After(“pt()”)

public void after(){

}

特殊参数： 无

2.2.5 @AfterReturning

名称：@AfterReturning

类型：注解

位置：方法定义上方

作用：标注当前方法作为返回后通知

格式：

@AfterReturning(value=“pt()”,returning = “ret”)

public void afterReturning(Object ret) {

}

特殊参数： returning ：设定使用通知方法参数接收返回值的变量名

2.2.6 @AfterThrowing

名称：@AfterThrowing

类型：注解

位置：方法定义上方

作用：标注当前方法作为异常后通知

格式：

@AfterThrowing(value=“pt()”,throwing = “t”)

public void afterThrowing(Throwable t){

}

特殊参数： throwing ：设定使用通知方法参数接收原始方法中抛出的异常对象名

2.2.7 @Around

名称：@Around

类型：注解

位置：方法定义上方

作用：标注当前方法作为环绕通知

格式：

@Around(“pt()”)

public Object around(ProceedingJoinPoint pjp) throws Throwable {

        Object ret = pjp.proceed(); return ret;

}

特殊参数： 无

AOP使用XML配置情况下，通知的执行顺序由配置顺序决定，在注解情况下由于不存在配置顺序的概念的概念，参照通知所配置的方法名字符串对应的编码值顺序，可以简单理解为字母排序

同一个通知类中，相同通知类型以方法名排序为准 不同通知类中，以类名排序为准 使用@Order注解通过变更bean的加载顺序改变通知的加载顺序

3、在注解类中添加需要传入的参数。

如果切面类中需要传入参数，可在注解类中定义。

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface DBChange {
​
    String projectId() default "";
​
    String environmentType() default "";
    /**
     *传递参数的对象类型
     */
    Class<?> parameter() default Object.class;
​
    /**
     * 默认不校验参数
     * @return
     */
    boolean require() default false;
}

4、添加自定义注解在需要的方法

@PostMapping("/change")
    @DBChange(projectId = "#{resultInfo.projectId}",environmentType = "#{resultInfo.environment}" ,require = true)
    public ResponseObj changeDb(@RequestBody EdcReleaseLogDto resultInfo){
       log.info("数据源切换测试");
        return ResponseObj.fail("数据源切换失败");
    }

注：自定义注解类设置了需要传递的参数，在添加自定义注解@DBChange时，需要设置对应参数projectId和environmentType。

考虑到传入的参数不固定，设置成"#{}"形式。

5、自定义工具类，对注解传入的参数进行解析

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.reflect.MethodSignature;
​
import java.lang.reflect.Method;
​
public class DBChangeResolver {
    private static DBChangeResolver resolver ;
​
    public static DBChangeResolver newInstance(){
​
        if (resolver == null) {
            return resolver = new DBChangeResolver();
        }else{
            return resolver;
        }
​
    }
​
    /**
     * 解析注解上的值
     * @param joinPoint
     * @param str 需要解析的字符串
     * @return
     */
    public Object resolver(JoinPoint joinPoint, String str) {
​
        if (str == null) return null ;
​
        Object value = null;
        if (str.matches("#\\{\\D*\\}")) {// 如果name匹配上了#{},则把内容当作变量
            String newStr = str.replaceAll("#\\{", "").replaceAll("\\}", "");
            if (newStr.contains(".")) { // 复杂类型
                try {
                    value = complexResolver(joinPoint, newStr);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            } else {
                value = simpleResolver(joinPoint, newStr);
            }
        } else { //非变量
            value = str;
        }
        return value;
    }
​
​
    private Object complexResolver(JoinPoint joinPoint, String str) throws Exception {
​
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
​
        String[] names = methodSignature.getParameterNames();
        Object[] args = joinPoint.getArgs();
        String[] strs = str.split("\\.");
​
        for (int i = 0; i < names.length; i++) {
            if (strs[0].equals(names[i])) {
                Object obj = args[i];
                Method dmethod = obj.getClass().getDeclaredMethod(getMethodName(strs[1]), null);
                Object value = dmethod.invoke(args[i]);
                return getValue(value, 1, strs);
            }
        }
​
        return null;
​
    }
​
    private Object getValue(Object obj, int index, String[] strs) {
​
        try {
            if (obj != null && index < strs.length - 1) {
                Method method = obj.getClass().getDeclaredMethod(getMethodName(strs[index + 1]), null);
                obj = method.invoke(obj);
                getValue(obj, index + 1, strs);
            }
​
            return obj;
​
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
​
    private String getMethodName(String name) {
        return "get" + name.replaceFirst(name.substring(0, 1), name.substring(0, 1).toUpperCase());
    }
​
​
    private Object simpleResolver(JoinPoint joinPoint, String str) {
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        String[] names = methodSignature.getParameterNames();
        Object[] args = joinPoint.getArgs();
​
        for (int i = 0; i < names.length; i++) {
            if (str.equals(names[i])) {
                return args[i];
            }
        }
        return null;
    }
​
}

qq_42346678
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用Spring AOP的API接口
z020315的博客
02-20 130
用Spring AOP的API接口进行切入的好处就是，他会自动帮你创建和管理类，不用亲自和以前一样new对象，这样可以实现解耦，因为你只要设置目标类路径即可，然后无论类怎么变都无需进行改动，上面就可以把beforeLog和afterLog切入到UserServiceImpl所有方法中。System.out.println(target.getClass().getName()+"->方法："+method.getName()+"被执行");--注册bean，将所有的实体类先注册-->
Spring AOP（切面面向接口）
weixin_45127932的博客
02-25 3653
1.什么是AOP？ AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的...
SpringBoot源码学习之AOP切面编程原理
最新发布
qq_39108894的博客
06-16 817
AOP切面编程主要用于抽取与具体业务逻辑无关的逻辑并组织起来以另一种方式重新与业务逻辑“耦合”在一起。比如，在WEB项目中，往往需要对接口做鉴权、性能统计、日志记录、事务处理等，这些逻辑跟业务逻辑无关、是独立的，但它也是多数业务逻辑都需要的。将这些横跨多种业务逻辑的、与业务无关的逻辑抽取出来，在合适的地点“切入”目标方法的过程就叫做横切，而这些抽取的逻辑就叫横切关注点。
【SpringBoot随笔】SpringBoot中Aop切入接口记录参数信息
qq_44299928的博客
04-29 375
第一步：引入maven依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> 第二步：创建切面类 /** * @author yangyang * @version 1.0 *
Spring的aop开发（二）
无名小辈
04-03 236
AOP开发中相关术语： 1.切面(aspect):要实现的交叉功能，是系统模块化的一个切面或领域。如日志记录。 2.连接点（Join Point）:应用程序执行过程中插入切面的地点，可以是方法调用，异常抛出，或者要修改的 字段。 3.通知（advice）:切面的实际实现，他通知系统新的行为。如在日志通知包含了实 现日志功能的代码，...
springboot使用AOP实现切面编程
oTianKongLan123的博客
08-15 186
之前看日志里面有用到aop的技术所以想照着做一个过程如下 1创建一个@interface文件 package io.sirc.common.annotation; import java.lang.annotation.*; /** * 系统日志注解 * */ @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIM...
Springboot中自定义注解实现AOP接口开发
qq_45819235的博客
12-17 1077
1、自定义一个注解 package com.example.demo.wb; import java.lang.annotation.*; //自定义注解，名叫WB @Target({ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @Documented @Inherited public @interface WB { } 2、建一个controller，并在需要aop拦截的方法上添加自定义注解 package com.
spring-boot aop
01-23
Spring Boot AOP（面向切面编程）是一种强大的设计模式，它允许我们在不修改现有代码的情况下，插入额外的功能或监控代码。在Spring框架中，AOP主要用于日志记录、事务管理、性能统计等场景。本示例是关于如何在...
Spring Boot Aspect 切面 AOP 拦截器 Interceptor 监控control请求耗时
03-13
在Spring Boot应用中，面向切面编程（AOP）是一种强大的设计模式，它允许我们以声明式的方式插入代码，比如日志记录、事务管理或权限检查。Aspect是AOP的核心概念，它封装了关注点，使得我们可以将这些关注点与业务...
解决springboot的aop切面不起作用问题(失效的排查)
08-19
但是，在实际开发中，我们可能会遇到AOP切面不起作用的问题。下面我们将介绍如何解决SpringBoot的AOP切面不起作用问题。 SpringBoot启动类的配置 首先，我们需要检查SpringBoot的启动类是否开启了扫描。在...
Spring Boot AOP
08-19
Spring Boot AOP是Java开发中的一个关键特性，它基于Spring框架的面向切面编程（Aspect Oriented Programming）功能，使得开发者能够以一种模块化的方式处理横切关注点，如日志记录、权限验证、异常处理等。在Spring...
Spring Boot如何使用AOP实例解析
08-19
在Spring Boot中，使用AOP需要引入AspectJ依赖项，并使用@Aspect注解来定义切面。在下面的示例代码中，我们定义了一个LogComponent，用于记录日志。 首先，我们使用@Component注解来声明这是一个组件，然后使用@...
springboot AOP 自定义接口处理，多切点问题（实现当符合条件时才执行这个接口的需求）
qq_45148387的博客
05-13 991
springboot AOP 自定义接口处理，多切点问题（实现当符合条件时才执行这个接口的需求）
java spring boot实现切面编程
lxy的博客
08-31 1874
springboot面向切面的简单实现 通过注解实现切面
springboot @Aspect 切面接口
liuweidong1的博客
03-11 996
好久没写文章了 更新一个小技术点关于@Aspect 切面接口的应用,不多说上代码 @Slf4j @Aspect @Component public class InterceptorAspect { @Pointcut("execution(public * com.www.baidu.job..*.*(..))") public void Pointcut() { }//签名 @Before(value = "Pointcut()") public .
Spring AOP 切换接口实现类
若明天不见
02-07 2583
此实例为，使用Spring切面，将接口的部分方法替换为其他实例的同名同参方法 每一个接口类建立对应一个RPC Client的使用，业务场景为对特定标识用户，使用新的RPC Client的部分方法。 AOP 代理 Spring AOP 默认将标准JDK动态代理用于 AOP 代理。这使得可以代理任何接口(或一组接口)。 Spring AOP 也可以使用CGLIB代理。这对于代理类而不是接口是必需的。如果业务对象未实现接口，则默认情况下使用CGLIB。最好的做法是对接口进行编程，而不是对类进行编程。业务类通常
AOP面向切面
weixin_46621094的博客
07-30 652
1. 什么是AOP AOP（Aspect Oriented Programming）面向切面编程，是对OOP面向对象编程的补充，它提供了模块化。在OOP中，关键的是单元是对象，AOP的关键单元是切面，或者说关注点。可以简单的理解为，OOP是针对核心的集中业务，AOP是针对非核心的分散的切面业务，例如事务管理、权限、日志、安全等。 2. AOP的核心理念 3. 切入点表达式 ...
类继承/接口实现时Spring AOP切入点注意事项
shadow_zed的博客
05-20 7897
最近好多人问我说我的我的切入点没有错误啊，怎么不起作用？而且大部分情况都是写AOP切入点时带有类继承或接口实现时出现的问题。在此总结一下，方便后人查阅。 而且建议使用如IntelliJ IDEA、STS或者Eclipse装AspectJ插件自动显示切入点是否匹配目标对象/目标方法。 1、相关类 1.1、抽象基类 我们在写一些项目时，都会抽象一些基类，比如DAO、Service等。
AOP开发明确的的事项
热门推荐
楠黎倾风的博客
12-09 3万+
AOP开发明确的的事项
spring boot aop
05-13
Spring Boot AOP（面向切面编程）是 Spring Boot 框架的一个重要特性，它可以让你在程序运行期间动态地将代码横切到方法调用的过程中，从而实现一些通用的功能，如日志记录、性能监控、事务管理等。 在 Spring Boot 中，使用 AOP 需要以下几个步骤： 1. 定义切面：通过注解或 XML 配置方式定义切面，即需要横切到哪些方法中。 2. 定义切点：定义需要横切的方法集合，这些方法将被切面所横切。 3. 编写通知：定义切面在切点处执行的逻辑，包括前置通知、后置通知、异常通知、环绕通知等。 4. 将切面和切点织入到目标对象中：通过注解或 XML 配置方式将切面和切点织入到目标对象中，使切面可以在目标对象的方法执行时生效。 Spring Boot AOP 基于 AspectJ 框架实现，支持注解和 XML 配置方式，非常灵活。如果你想使用 AOP 实现一些通用的功能或业务逻辑，Spring Boot AOP 是一个不错的选择。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值