So verwenden Sie aop im SpringBoot-Projekt

Vorwort

IOC und AOP sind die beiden Kernkonzepte im Frühling. Lassen Sie mich kurz mein Verständnis vorstellen:

IOC: Inversion der Kontrolle, also die Konvertierung vorherige Der Prozess der manuellen Erstellung von Objekten wird an Spring übergeben. Spring hilft uns, Objekte zu erstellen, Objekte zu verwalten und Abhängigkeiten zwischen Objekten zu erkennen. Es reduziert die Kopplung des Codes und erleichtert uns die spätere Wartung des Projekts. Um ein populäreres Beispiel zu nennen:
Unter normalen Umständen sind wir zu Hause, haben Hunger und kochen selbst.
Wenn wir bei IOC zu Hause sind und Hunger haben, rufen wir den Händler an und das Essen wird uns geliefert.
IOC entspricht einem Händler und Kochen entspricht der Herstellung eines Objekts.
Das heißt, wenn eine Klasse unter normalen Umständen Methoden anderer Klassen aufrufen muss, erstellen wir Objekte manuell über neue, Factory- oder andere Methoden.
Bei Verwendung von IOC müssen wir nur das Objekt injizieren.

AOP: Aspektorientierte (bequeme) Programmierung, Sie können einen bestimmten Objekttyp überwachen und steuern und den angegebenen Code vor und nach dem Aufruf der Methode dieses Objekttyps aufrufen, um ihn zu erweitern eine Methode, um den Effekt der Verbesserung der Modulfunktionen zu erzielen. Geben wir ein einfaches Beispiel:
Unter normalen Umständen direkt essen.
Bei der Anwendung von AOP passt ein Kindermädchen auf Sie auf, hilft Ihnen beim Händewaschen vor dem Essen und beim Abräumen des Geschirrs nach dem Essen.
AOP entspricht einem Kindermädchen, und Essen entspricht dem Aufruf bestimmter Methoden.
Mit anderen Worten, wenn wir die Methode ergänzen möchten, ändern wir die Methode nicht direkt, sondern ergänzen sie durch AOP. Wenn wir nicht nachfüllen möchten oder den Nachschub ersetzen müssen, können wir das AOP direkt bedienen.
1. Pointcut: Wird verwendet, um zu definieren, welche Methode abgefangen wird, z. B. Ausführung(* cn.springcamp.springaop.service..(…))

2. Aktionen, die nach dem Abfangen der Methode

3 ausgeführt werden sollen. Aspekt: ​​Pointcut und Advice werden zu einem Aspekt

4 kombiniert #

4. Weaver: Ein Framework, das AOP implementiert, wie AspectJ oder Spring AOP

1. Das SpringBoot-Projekt führt AOP-Abhängigkeiten ein

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

Startup-Klasse @EnableAspectJAutoProxy-Annotation, die weggelassen werden kann. Denn in den Standardkonfigurationseigenschaften von AOP ist die Eigenschaft spring.aop.auto standardmäßig aktiviert.

Es besteht keine Notwendigkeit mehr, AspectJ-Abhängigkeiten einzuführen.

2. Gewöhnlicher Weg

Aspektklassencode:

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-Klassencode:

package com.example.myblog.test;

import org.springframework.stereotype.Component;

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

Testklassencode:

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

Testergebnis:

3. Anmerkungsmethode

Benutzerdefinierter Anmerkungscode: #🎜 🎜#

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-Klassencode:

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-Klassencode:

package com.example.myblog.test;

import org.springframework.stereotype.Component;

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

Testklassencode:

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

Testergebnis: # 🎜🎜#

Das obige ist der detaillierte Inhalt vonSo verwenden Sie aop im SpringBoot-Projekt. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!