Comment Springboot utilise les annotations de capture Aop pour mettre en œuvre une exécution asynchrone métier

1. Tout d'abord, parlons de plusieurs façons de créer des threads (brève liste)

1 Héritez de la classe Thread et remplacez la méthode run :

public class ExtendsThread extends Thread{
    @Override
    public void run() {
        try{
            System.out.println(Thread.currentThread().getName()+"执行");
        }catch (Exception e){
 
        }
    }
    public static void main(String[] args) {
        new Thread(new ExtendsThread()).start();
    }
}

2 Implémentez l'interface Runnable et remplacez la méthode run :

public class ImplementsRunnable implements Runnable{
    @Override
    public void run() {
        try{
            System.out.println(Thread.currentThread().getName()+"执行");
        }catch (Exception e){
 
        }
    }
    public static void main(String[] args) {
        new Thread(new ImplementsRunnable()).start();
        //这里还可以使用匿名内部类的写法创建一个线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行");
            }
        },"匿名内部类实现Runnable接口的线程");
    }
}

3. . Implémentez l'interface Callable, utilisez FutureTask pour créer un thread (vous pouvez obtenir la valeur de retour) :

public class CallableAndFuture implements Callable<String> {
    @Override
    public String call() throws Exception {
        Thread.sleep(3000);
        System.out.println(Thread.currentThread().getName()+"执行");
        return "success";
    }
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<String> futureTask = new FutureTask<>(new CallableAndFuture());
//        futureTask.run();   主线程执行call方法
        new Thread(futureTask).start();
        String result = futureTask.get();
        System.out.println(result);
    }
}

4. Utilisez le pool de threads pour créer un thread (ici, utilisez le framework de pool de threads fourni Executors pour créer un pool de threads) :

public class Executor {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"执行");
            }
        });
    }
}

2. Parlons de Spring @ La façon d'implémenter des tâches asynchrones à l'aide d'annotations asynchrones est en fait très simple. Il suffit de mettre l'annotation @EnableAsync sur la classe de démarrage de l'application pour activer l'utilisation d'annotations asynchrones, puis de mettre @Async. sur une méthode de la classe affaires.

@SpringBootApplication
@EnableAsync
public class AopApplication {
    public static void main(String[] args) {
        SpringApplication.run(AopApplication.class, args);
    }
}

Méthode de classe affaires (exemple) :

   @Async
    public void insertDb(){
        /*service code......*/
        System.out.println("2----->收到请求,写入数据库  ");
    }

3. Ensuite, concevons comment utiliser des annotations personnalisées pour implémenter des tâches asynchrones

Nous écrivons d'abord une annotation :

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAsync {
    //规定value是异步开关
    boolean value() default false;
}

Nous définissons la valeur de l'annotation sur le type booléen, donc déterminer la création de threads asynchrones en fonction de sa valeur vraie ou fausse.

On le met sur la méthode de la classe affaires :

  @MyAsync(value = true)
    public void deleteDb(){
        /*service code......*/
        System.out.println("delete------>数据删除");
    }

Ensuite on utilise AOP pour scanner cette annotation :

Aspect
@Component
public class AopUtils {
    @Around(value = "@annotation(com.example.aop.Aop异步.MyAsync)")
    public void listenMyAsync(ProceedingJoinPoint joinPoint) throws Throwable {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        MyAsync annotation = method.getAnnotation(MyAsync.class);
        boolean value = annotation.value();
        if (value)
            new Thread(new Runnable() {
                @SneakyThrows
                @Override
                public void run() {
                    joinPoint.proceed();
                }
            }).start();
        else
            joinPoint.proceed();
    }
}

On voit qu'on utilise Around pour trouver une pile de méthodes contenant des annotations dans le thread d'exécution Après capture. il, L'objet de point de connexion correspondant peut être obtenu.

Utilisez la méthode getSignture de l'objet point de connexion ProcedJoinPoint pour obtenir la signature. Vous pouvez forcer la conversion de la signature en signature de méthode de type MethdSignture, puis utiliser la méthode getMethod de ce type pour obtenir la méthode elle-même. peut obtenir l'annotation de la méthode et utiliser les attributs de l'annotation. Obtenez directement la valeur vraie ou fausse de la valeur pour déterminer si la méthode est transmise de manière synchrone ou asynchrone. (Le code source utilise le mécanisme de réflexion).

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!