SpringBoot中使用AspectJ

原创 已于 2022-05-26 20:15:17 修改 · 4.3k 阅读 · 9 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#aop #spring boot #java #spring #junit

于 2021-08-04 16:54:38 首次发布
本文介绍如何在Spring Boot项目中利用AOP（面向切面编程）进行代码层面的解耦，包括配置依赖、创建切面类及通知方法，并通过具体示例展示了如何配合自定义注解实现更灵活的切入点定义。

pom中添加依赖

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

常规切面使用

切入指定包类目录，如@Pointcut("execution(* sb.simple.aspectj.normal.*.*(..))")

@Pointcut参数正则可以自行了解一下

  • 切面类

    package sb.simple.aspectj.normal;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.context.annotation.Configuration;

import java.util.Arrays;

/**
 * AspectJ
 * 五种通知注解：@Before/@Around/@After/@AfterReturning/@AfterThrowing
 */
@Configuration
@Aspect
public class AJNormal {

    @Pointcut("execution(* sb.simple.aspectj.normal.*.*(..))")
    public void point() { }

    /**
     * 前置通知
     * 连接点之前执行
     */
    @Before("point()")
    public void before(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
        System.out.println("before() methodName:" + methodName + ", args:" + Arrays.toString(args));
    }

    @Around("point()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        String methodName = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
        System.out.println("around() before proceed");
        Object proceed = joinPoint.proceed();
        System.out.println("around() after proceed methodName:" + methodName + ", args:" + Arrays.toString(args) + ", result:" + proceed);
        return proceed;
    }

    /**
     * 后置通知
     * 连接点方法完成后执行
     * 无论连接点执行成功与否该通知都会执行
     */
    @After("point()")
    public void after(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
        System.out.println("after() methodName:" + methodName + ", args:" + Arrays.toString(args));
    }

    /**
     * 连接点方法执行成功后执行
     * 可以拿到返回结果
     */
    @AfterReturning(value = "point()", returning = "result")
    public void result(JoinPoint joinPoint, Object result) {
        String methodName = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
        System.out.println("AfterReturning() methodName:" + methodName + ", args:" + Arrays.toString(args) + ", result:" + result);
    }

    /**
     * 连接点方法执行异常后执行
     * 可以拿到异常信息
     */
    @AfterThrowing(value = "point()", throwing = "exception")
    public void afterThrowing(JoinPoint joinPoint, Exception exception) {
        String methodName = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
        System.out.println("afterThrowing() methodName:" + methodName + ", args:" + Arrays.toString(args) + ", exception:" + exception);
    }
}

  • 被切类

    package sb.simple.aspectj.normal;

import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;

@Service
@Component
public class CalcService {

    public int add(int a, int b) {
        int result = a + b;
        System.out.println("CalcService->add() result:" + result);
        return a + b;
    }

    //测试AfterThrowing通知
    public int divider(int a, int b) {
        int result = a / b;
        System.out.println("CalcService->divider() result:" + result);
        return result;
    }
}

  • 测试类

    package sb.simple.aspectj;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import sb.simple.aspectj.annotation.CalcAnClass;
import sb.simple.aspectj.annotation.CalcAnMethod;
import sb.simple.aspectj.normal.CalcService;

@SpringBootTest
public class AJTest {


    /**普通切入*/
    @Autowired
    private CalcService calcService;

    /*
    around() before proceed
    before() methodName:add, args:[1, 2]
    CalcService->add() result:3
    AfterReturning() methodName:add, args:[1, 2], result:3
    after() methodName:add, args:[1, 2]
    around() after proceed methodName:add, args:[1, 2], result:3
     */
    @Test
    public void testAdd() {
        calcService.add(1, 2);
    }

    /*
    around() before proceed
    before() methodName:divider, args:[3, 0]
    afterThrowing() methodName:divider, args:[3, 0], exception:java.lang.ArithmeticException: / by zero
    after() methodName:divider, args:[3, 0]
     */
    @Test
    public void testDivider() {
        calcService.divider(3, 0);
    }


    /*不用@Service注解实例化aspectj就没用
    CalcService->add() result:8
     */
    @Test
    public void testAddNew() {
        new CalcService().add(3, 5);
    }
}

配合自定义注解使用

  • 自定义注解

    package sb.simple.aspectj.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
//METHOD->注解于方法 | TYPE->注解于类
@Target({ElementType.METHOD, ElementType.TYPE})
public @interface Require {

    String value();
}

  • 被切类

    package sb.simple.aspectj.annotation;

import org.springframework.stereotype.Service;

//注解于类
@Service
@Require("in class")
public class CalcAnClass {

    public void hi(String name) {
        System.out.println(getClass().getSimpleName() + ": hi:" + name);
    }
}

    package sb.simple.aspectj.annotation;

import org.springframework.stereotype.Service;

//注解于方法
@Service
public class CalcAnMethod {

    @Require("in method")
    public void hi(String name) {
        System.out.println(getClass().getSimpleName() + ": hi:" + name);
    }
}

  • 切面类

    在通知方法@Around中，通过ProceedingJoinPoint实例可以获取被切方法的方法名，方法参数，所在类，注解，注解参数等，可以通过这些数据对方法进行增强

    package sb.simple.aspectj.annotation;

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.aspectj.lang.reflect.MethodSignature;
import org.springframework.context.annotation.Configuration;

import java.lang.reflect.Method;
import java.util.Arrays;

@Configuration
@Aspect
public class AJAnnotation {

    /**注解于类@within*/
    @Pointcut("@within(sb.simple.aspectj.annotation.Require)&&execution(public * *.*(..))")
    public void pointClass() { }

    @Around("pointClass()")
    public Object aroundClass(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("aroundClass() in");

        //获取在类上的注解中的属性值
        String className = joinPoint.getTarget().getClass().getName();
        Class<?> clz = Class.forName(className);
        Require require = clz.getAnnotation(Require.class);
        System.out.println("annotation(class), clzName:" + clz.getSimpleName());
        String value = require.value();
        System.out.println("annotation(class)->Require->value:" + value);

        return joinPoint.proceed();
    }


    /**注解于方法@annotation*/
    @Pointcut("@annotation(sb.simple.aspectj.annotation.Require)")
    public void point() { }


    @Around("point()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("aroundMethod() in");

        //获取在方法上的注解的属性值
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Class<?> clz = joinPoint.getTarget().getClass();
        String name = signature.getName();
        Class[] parameterTypes = signature.getParameterTypes();
        Method method = clz.getMethod(name, parameterTypes);
        System.out.println("annotation(method), clzName:" + clz.getSimpleName() + ", name:" + name + ", parameterTypes:" + Arrays.toString(parameterTypes));
        Require require = method.getAnnotation(Require.class);
        String value = require.value();
        System.out.println("annotation(method)->Require->value:" + value);


        return joinPoint.proceed();
    }
}

  • 测试类

    package sb.simple.aspectj;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import sb.simple.aspectj.annotation.CalcAnClass;
import sb.simple.aspectj.annotation.CalcAnMethod;
import sb.simple.aspectj.normal.CalcService;

@SpringBootTest
public class AJTest {

    /**配合自定义注解切入*/
    @Autowired
    CalcAnClass calcAnClass;

    @Test
    public void anClass() {
        calcAnClass.hi("akali(class)");
    }

    @Autowired
    CalcAnMethod calcAnMethod;

    @Test
    public void anMethod() {
        calcAnMethod.hi("annie(method)");
    }
}
SpringBoot整合aspectj实现面向切面编程(即AOP)
summon的博客
06-24 5216
…上面的场景都是真实存在的需求，但是如果不能统一处理的话，基本都是一改一大片，除了对业务代码有很强的侵入性，而且难以保证不出问题。所以为了解决这种需求，AspectJ框架应运而生。不过SpringBoot官方也推出了 Spring AOP， 具体对比我就不赘述了，详细对比可以参https://www.jianshu.com/p/872d3dbdc2ca 2、创建切面类并加上@Component注解 这一步相当于把切面类的管理权交给了Spring容器，让Spring容器负责该对象的创建与销毁，我们负责使用就行
SpringBoot 利用aspectJ进行AOP切面管理
JThreeStone的博客
03-24 5325
Java是面向对象编程，Java AOP是面向切面编程，最近学习该部分内容知识，讲学习心得在这里做一个整理，以帮助后续学习以及使用。 首先什么事AOP？个人理解，在开发过程中，又核心业务，也有非核心业务。例如一个登陆功能，在登录功能中核心业务是进行登陆操作，继判断用户是否在数据库中存在；同事也有一些非核心业务，如日志记录，参数校验等。模块化开发思想，将这三部分模块进行分开处理，从而不会使得代码冗...
一文熟悉SpringBoot面向AOP编程
小橘子的博客
03-25 880
但在实际使用中，你可能会发现@Before通知中的参数类型应该是org.aspectj.lang.ProceedingJoinPoint（仅对环绕通知有效），或者根本不需要参数。在AOP中，一个关注点被模块化为一个切面（Aspect），切面包含了一组通知（Advice）和一个切点（Pointcut）。常见的通知类型有前置通知（Before）、后置通知（AfterReturning）、异常通知（AfterThrowing）和环绕通知（Around）。确保事务在正确的地方开始和结束，并正确处理事务的传播。
【SpringBoot3】面向切面 AspectJ AOP 使用详解
不积跬步无以至千里，不积小流无以成江海。一个喜欢学习分享的程序员
09-13 4746
AspectJ是一个面向切面的框架，它扩展了Java语言，并定义了AOP（面向切面编程）语法。 AspectJ支持数据埋点、日志记录、性能统计、安全控制、事务处理、异常处理等多种横切关注点。通过AspectJ，开发者可以更加直观地定义和理解代码的行为，减少对业务逻辑的干扰。
springboot项目中引入Aspectj并使用
山鬼谣的专栏
06-01 1万+
环境 springboot：2.4.4 aspectjweaver: 1.8.7 前言 今天调试接口时，遇到的aop拦截，做权限校验，但是有个参数总是没有传，又因为以前这块代码逻辑有问题，总报null指针。所以回家后，研究了aspectj包。 这里网上有一句这样的概括： spring-aop：AOP核心功能，例如代理工厂等等 aspectjweaver：简单理解，支持切入点表达式等等 aspectjrt：简单理解，支持aop相关注解等等 但是aspectjweaver是包含aspectjrt的，所以上面那句
SpringBoot 中 指定 AspectJ 的织入模式
name_sakura的博客
11-29 1092
需要注意的是，AspectJ的默认织入模式可能会因Spring Boot版本的不同而有所变化。因此，在明确指定织入模式时，最好查看所使用Spring Boot版本的文档或参考AspectJ的官方文档以确保正确性。通过上述配置，AspectJ将使用静态织入模式实现AOP。如果要使用动态代理模式，只需将。如果要使用动态代理模式，只需将上述属性的值设置为。
springboot2.1.0、AspectJ切面编程简单使用
p812438109的专栏
08-10 2994
一）、在pom.xml文件增加以下配置 <!--不指定版本的原因,如不指定版本,会默认下载springboot对应版本的jar --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop...
Springboot整合Aspectj、Aspectj基本语法
weixin_39997751的博客
06-08 1191
我们知道AOP（面向切面编程）给开发人员带来了极大的便利性，特别是有强迫症的猿们，项目中出现一堆冗余且与实际业务无关的代码，看一次想撕一次。 网上找不到比较全的相关文章，特此花时间整理下，方便你我他。 下述实例源码传送门 https://gitee.com/peterven/aoptest 开箱即用 核心依赖 <dependency> <groupId>org.springframework.boot</groupId> .
SpringBoot中使用Aspect实现切面，超详细
weixin_45131680的博客
02-20 2790
Spring中的Aspect，这是Spring的一大优势。面向切面编程往往让我们的开发更加低耦合，也大大减少了代码量，同时呢让我们更专注于业务模块的开发，把那些与业务无关的东西提取出去，便于后期的维护和迭代。相关的学习教程是看的动力节点的视频，然后整理了这篇博客作为笔记，方便以后复习时候看看，也分享给有需要的小伙伴。
【5】Spring Boot系列之 Aspects（1）【AspectJ】
ˉ-_lishk_-ˉ
02-15 438
（1）首先引入依赖 &amp;lt;dependency&amp;gt; &amp;lt;groupId&amp;gt;org.aspectj&amp;lt;/groupId&amp;gt; &amp;lt;artifactId&amp;gt;aspectjweaver&amp;lt;/artifactId&amp;gt; &amp;lt;/dependency&amp;gt; （2）日志统一管理代码 @A
SpringBoot简单使用切面类(@aspect注解)
热门推荐
Venus's Blog
09-03 3万+
Spring Boot中的AOP(Aspect Oriented Programming, 面向切面编程)可以让我们实现一些与业务逻辑无关的功能,如日志、事务、安全等。
springboot~使用自定义的aspect
m0_68064743的博客
04-25 4232
对某个类型中的方法进行拦截，然后加入固定的业务逻辑，这是AOP面向切面编程可以做的事，在springboot里实现aop的方法也有很多，spring-boot-starter-aop或者aspectjweaver都是可以实现的，不过我们在实现之前，先来看一下aop里的几个概念。 概念 切面（Aspect）：是指横切多个对象的关注点的一个模块化，事务管理就是J2EE应用中横切关注点的很好示例。在Spring AOP中，切面通过常规类（基本模式方法）或者通过使用了注解@Aspect的常规类来实现。 连接
[SpringBoot] AOP-AspectJ 切面技术
沫洺的博客
10-26 1884
SpringBoot使用AOP-AspectJ 切面技术
springboot之aspectj实现的aop
Wall的博客
08-03 1771
①需要的依赖包 &lt;!--AOP--&gt; &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-aop&lt;/artifactId&gt; &lt;version&gt;2.0.0.RELEASE&lt;/
springboot使用注解和aspectJ进行AOP编程
qq_24516549的博客
03-11 1274
1.注解类 先新建注解类 package cn.seiya2.modules.admin.annotation; import java.lang.annotation.Documented; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annot...
Spring Boot AspectJ AOP的使用
闲明苑的博客
09-20 1716
Spring Boot AspectJ AOP的使用
Springboot注解@Aspect（一）之@Aspect 作用和Aop关系详解
A乐神的博客
01-26 7555
Springboot注解@Aspect（一）之@Aspect 作用和Aop关系详解
springboot 整合aspectj
最新发布
03-25
### 如何在Spring Boot中整合AspectJ以实现AOP 要在Spring Boot项目中成功整合AspectJ并实现AOP功能，可以按照以下方法操作： #### 添加依赖项 为了支持AspectJ的功能，在`pom.xml`文件中需要引入必要的库。这些库...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值