Introduction to the use of aop in springboot (code example)

This article brings you an introduction to the use of aop in springboot (code examples). It has certain reference value. Friends in need can refer to it. I hope it will be helpful to you.

Step 1: Add dependencies

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

Step 2: Define an aspect class

package com.example.demo.aop;
import java.lang.reflect.Method;
import java.util.Arrays;
import javax.servlet.http.HttpServletRequest;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import static com.sun.xml.internal.ws.dump.LoggingDumpTube.Position.Before;
@Component
@Aspect // 将一个java类定义为切面类
@Order(-1)//如果有多个aop,这里可以定义优先级,越小级别越高
public class LogDemo {
    private static final Logger LOG = LoggerFactory.getLogger(LogDemo.class);

    @Pointcut("execution(* com.example.demo.test.TestController.test(..))")//两个..代表所有子目录，最后括号里的两个..代表所有参数
    public void logPointCut() {
    }
    @Before("logPointCut()")
    public void doBefore(JoinPoint joinPoint) throws Throwable {
        // 接收到请求，记录请求内容
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        System.out.println("before");

    }

    @After(value = "logPointCut()")
    public void after(JoinPoint joinPoint) {
        System.out.println("after");
    }


    @AfterReturning(returning = "ret", pointcut = "logPointCut()")// returning的值和doAfterReturning的参数名一致
    public void doAfterReturning(Object ret) throws Throwable {
        System.out.println("AfterReturning");
    }

    @Around("logPointCut()")
    public void doAround(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("around1");
        Object ob = pjp.proceed();//环绕通知的进程方法不能省略，否则可能导致无法执行
        System.out.println("around2");
    }
}

Note:

If the same aspect class defines two @Befores, the execution order of the two @Befores cannot be determined.

For @Around, no matter whether it has a return value or not, pjp.proceed() must be called inside the method; otherwise, the interface in the Controller will not have a chance to be executed, which also results in @Before not being executed. The controller that will be triggered for the

test is as follows:

package com.example.demo.test;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;


@Controller
public class TestController {

    @RequestMapping(value = "test",method = RequestMethod.GET)
    @ResponseBody
    public String test(String name){
        System.out.println("============method");
        return name;
    }
}

The configuration is completed, check the effect, the output is as follows:

around1
before============method
around2
after
AfterReturning

As you can see, the execution of the aspect method is as follows:

around-->before-->method-->around-->after-->AfterReturning

If @AfterThrowing is configured, when an exception occurs, the execution is as follows:

around-->before-->method-->around-->after-->AfterThrowing

The above is the detailed content of Introduction to the use of aop in springboot (code example). For more information, please follow other related articles on the PHP Chinese website!