How to use aop in SpringBoot project

Preface

IOC and AOP are the two core concepts in Spring. Let me briefly introduce my understanding:

IOC: Inversion of control, which is to manually create the The object process is handed over to Spring. Spring helps us produce objects, manage objects, manage objects and the dependencies between objects. It reduces the coupling of the code and facilitates our later maintenance of the project. To give a more popular example:
Under normal circumstances, we are at home, hungry, and cook by ourselves.
When using IOC, when we are at home and hungry, we call the merchant and the food is delivered.
IOC is equivalent to a merchant, and cooking is equivalent to creating an object.
That is to say, under normal circumstances, when a class needs to call methods of other classes, we manually create objects through new, factory or other methods.
When using IOC, we only need to inject the object.

AOP: Aspect-oriented (convenient) programming, you can supervise and control a certain type of object, call the specified code before and after calling the method of this type of object, thereby extending a method to achieve enhancement Effects of module functionality. To give a simple example:
Under normal circumstances, eat directly.
When using AOP, a nanny is watching over you, helping you wash your hands before eating and cleaning up the dishes after eating.
AOP is equivalent to a nanny, and eating is equivalent to calling specific methods.
In other words, when we want to supplement the method, we do not modify the method directly, but supplement it through AOP. When we don't want to replenish or need to replace the replenishment, we can directly operate the AOP.
1. Pointcut: Pointcut, used to define which method will be intercepted, such as execution(* cn.springcamp.springaop.service..(…))

2. Advice: Intercepted method Actions to be executed later

3. Aspect: Aspect, combine Pointcut and Advice to form an aspect

4. Join Point: An instance of Pointcut during execution

4. Weaver: A framework that implements AOP, such as AspectJ or Spring AOP

1. The SpringBoot project introduces AOP dependencies

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

The startup class is added with the @EnableAspectJAutoProxy annotation, which can be omitted. Because in the default configuration properties of AOP, the spring.aop.auto property is turned on by default.
There is no need to introduce AspectJ dependencies anymore.

2. Ordinary method

Aspect class code:

package com.example.myblog.test;


import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class AOPTest {
    //定义切入点
    @Pointcut("execution(public * com.example.myblog.test.AOPTestClient.*(..))")
    public void aspectTest(){}

    //前置通知，切入点执行之前执行
    @Before("aspectTest()")
    public void doBefore(JoinPoint joinPoint){
        System.out.println("前置通知");
    }
    //后置通知，切入点执行之后执行
    @After("aspectTest()")
    public void doAfter(JoinPoint joinPoint){
        System.out.println("后置通知");
    }
    //最终通知，，切入点执行之后执行
    @AfterReturning("aspectTest()")
    public void doAfterReturning(JoinPoint joinPoint){
        System.out.println("最终通知");
    }
    //异常通知，切入点抛出异常执行
    @AfterThrowing("aspectTest()")
    public void deAfterThrowing(JoinPoint joinPoint){
        System.out.println("异常通知");
    }
    //环绕通知，切入点执行前、后执行
    @Around("aspectTest()")
    public Object deAround(ProceedingJoinPoint joinPoint) throws Throwable{
        System.out.println("未执行");
        Object result = joinPoint.proceed();
        System.out.println("已执行");
        //返回结果
        return result;
    }
}

Pointcut class code:

package com.example.myblog.test;

import org.springframework.stereotype.Component;

@Component
public class AOPTestClient {
    public void test(){
        System.out.println("正在测试AOP");
    }
}

Test class code:

package com.example.myblog;

import com.example.myblog.test.*;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@SpringBootTest
@RunWith(SpringJUnit4ClassRunner.class)
public class MyblogApplicationTests {
    
    @Autowired
    private AOPTestClient aopTestClient;

    @Test
    public void testAOP(){
        aopTestClient.test();
    }
}

Test results:

3. Annotation method

Custom annotation code:

package com.example.myblog.test;

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

//表示次注解可以标注在类和方法上
@Target({ElementType.METHOD, ElementType.TYPE})
//运行时生效
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
    //定义一个变量，可以接受参数
    String desc() default " ";
}

Aspect class code:

package com.example.myblog.test;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class AOPAnnotationTest {
    //定义切入点
    @Pointcut("@annotation(com.example.myblog.test.MyAnnotation)")
    public void aspectTest(){}

    //前置通知，切入点执行之前执行
    @Before("aspectTest()")
    public void doBefore(JoinPoint joinPoint){
        System.out.println("前置通知");
    }
    //后置通知，切入点执行之后执行
    @After("aspectTest()")
    public void doAfter(JoinPoint joinPoint){
        System.out.println("后置通知");
    }
    //最终通知，，切入点执行之后执行
    @AfterReturning("aspectTest()")
    public void doAfterReturning(JoinPoint joinPoint){
        System.out.println("最终通知");
    }
    //异常通知，切入点抛出异常执行
    @AfterThrowing("aspectTest()")
    public void deAfterThrowing(JoinPoint joinPoint){
        System.out.println("异常通知");
    }
    //环绕通知，切入点执行前、后执行
    @Around("aspectTest()")
    public Object deAround(ProceedingJoinPoint joinPoint) throws Throwable{
        System.out.println("未执行");
        Object result = joinPoint.proceed();
        System.out.println("已执行");
        //返回结果
        return result;
    }
}

Pointcut class code:

package com.example.myblog.test;

import org.springframework.stereotype.Component;

@Component
public class AOPAnnotationTestClient {
    @MyAnnotation
    public void test(){
        System.out.println("正在测试AOP");
    }
}

Test class code:

@Test
    public void testAOPAnnotation(){
        aopAnnotationTestClient.test();
    }

Test result:

The above is the detailed content of How to use aop in SpringBoot project. For more information, please follow other related articles on the PHP Chinese website!