Einführung in die Verwendung von AOP in Springboot (Codebeispiel)

Dieser Artikel bietet Ihnen eine Einführung in die Verwendung von AOP in Springboot (Codebeispiele). Ich hoffe, dass er für Freunde hilfreich ist.

Schritt 1: Abhängigkeiten hinzufügen

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

Schritt 2: Definieren Sie eine Aspektklasse

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");
    }
}

Hinweis:

Wenn dieselbe Aspektklasse zwei @Befores definiert, kann die Ausführungsreihenfolge der beiden @Befores nicht bestimmt werden

Für @Around Unabhängig davon, ob es einen Rückgabewert hat oder nicht, muss pjp.proceed() innerhalb der Methode aufgerufen werden. Andernfalls hat die Schnittstelle im Controller keine Chance, ausgeführt zu werden, was ebenfalls zum Fehler von @Before The führt Der Controller, der für den

-Test ausgelöst wird, lautet wie folgt:

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;
    }
}

Die Konfiguration ist abgeschlossen. Überprüfen Sie den Effekt. Die Ausgabe lautet wie folgt:

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

Wie Sie sehen können, ist die Ausführung der Aspektmethode wie folgt:

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

Wenn @AfterThrowing konfiguriert ist und eine Ausnahme auftritt, erfolgt die Ausführung wie folgt:

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

Das obige ist der detaillierte Inhalt vonEinführung in die Verwendung von AOP in Springboot (Codebeispiel). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!