Bagaimana untuk menggunakan aop dalam projek SpringBoot

Kata Pengantar

IOC dan AOP ialah dua konsep teras dalam Spring Biar saya memperkenalkan secara ringkas pemahaman saya:

IOC: Penyongsangan kawalan, iaitu mencipta proses objek secara manual. diserahkan kepada Spring membantu kami menghasilkan objek, mengurus objek, mengurus objek dan kebergantungan antara objek. Ia mengurangkan gandingan kod dan memudahkan penyelenggaraan projek kami kemudian. Untuk memberikan contoh yang lebih popular:
Dalam keadaan biasa, kami berada di rumah, kami lapar, dan kami memasak sendiri.
Apabila menggunakan IOC, apabila berada di rumah dan lapar, kami menelefon peniaga dan makanan dihantar.
IOC bersamaan dengan pedagang, dan memasak adalah bersamaan dengan mencipta objek.
Maksudnya, dalam keadaan biasa, apabila kelas perlu memanggil kaedah kelas lain, kami mencipta objek secara manual melalui kaedah baharu, kilang atau kaedah lain.
Apabila menggunakan IOC, kita hanya perlu menyuntik objek.

AOP: Pengaturcaraan berorientasikan aspek (mudah), yang boleh menyelia dan mengawal jenis objek tertentu, dan memanggil kod tertentu sebelum dan selepas memanggil kaedah objek tersebut, dengan itu memanjangkan kaedah untuk mencapai peningkatan Kesan kefungsian modul . Untuk memberikan contoh mudah:
Dalam keadaan biasa, makan terus.
Apabila menggunakan AOP, pengasuh mengawasi anda, membantu anda mencuci tangan sebelum makan dan membersihkan pinggan selepas makan.
AOP bersamaan dengan pengasuh, dan makan adalah bersamaan dengan memanggil kaedah tertentu.
Dalam erti kata lain, apabila kita ingin menambah kaedah, kita tidak mengubah cara secara langsung, tetapi menambahnya melalui AOP. Apabila kami tidak mahu mengisi semula atau perlu menggantikan pengisian semula, kami boleh terus mengendalikan AOP.
1. Pointcut: Pointcut, digunakan untuk menentukan kaedah yang akan dipintas, seperti pelaksanaan(* cn.springcamp.springaop.service..(…))

2 Tindakan yang akan dilaksanakan kemudian

3 Aspek: Menggabungkan Pointcut dan Nasihat untuk membentuk satu aspek

4 : Rangka kerja yang melaksanakan AOP, seperti AspectJ atau Spring AOP

1. Projek SpringBoot memperkenalkan kebergantungan AOP

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

Kelas permulaan ditambah dengan anotasi @EnableAspectJAutoProxy, yang boleh diabaikan. Kerana dalam sifat konfigurasi lalai AOP, sifat spring.aop.auto dihidupkan secara lalai.

Tidak perlu memperkenalkan kebergantungan AspectJ lagi.

2. Kaedah biasa

Kod kelas aspek:

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

Kod kelas pointcut:

package com.example.myblog.test;

import org.springframework.stereotype.Component;

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

Kod kelas ujian:

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

Ujian hasil:

3. Kaedah anotasi

Kod anotasi tersuai:

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

Kod kelas aspek:

rreee

Pointcut kod:

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

Kod ujian:

package com.example.myblog.test;

import org.springframework.stereotype.Component;

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

Hasil ujian:

Atas ialah kandungan terperinci Bagaimana untuk menggunakan aop dalam projek SpringBoot. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!