Wie Springboot Aop-Erfassungsanmerkungen verwendet, um die asynchrone Geschäftsausführung zu implementieren

1. Lassen Sie uns zunächst über verschiedene Möglichkeiten sprechen, Threads zu erstellen (kurze Liste).

1 Erben Sie die Thread-Klasse und überschreiben Sie die Ausführungsmethode:

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 . Implementieren Sie die Callable-Schnittstelle und verwenden Sie FutureTask, um einen Thread zu erstellen (Sie können den Rückgabewert erhalten):

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接口的线程");
    }
}

4. Verwenden Sie den Thread-Pool, um einen Thread zu erstellen (verwenden Sie hier das bereitgestellte Thread-Pool-Framework Executors, um einen Thread-Pool zu erstellen). :

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

2. Lassen Sie uns über Springs eigenes @ sprechen. Die Möglichkeit, asynchrone Aufgaben mithilfe von Async-Annotationen zu implementieren, ist eigentlich sehr einfach. Fügen Sie einfach die Annotation @EnableAsync in die Startklasse der Anwendung ein, um die Verwendung asynchroner Annotationen zu ermöglichen, und fügen Sie dann @Async ein auf einer Methode der Business-Klasse.

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()+"执行");
            }
        });
    }
}

Business-Klassenmethode (Beispiel):

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

3. Dann entwerfen wir, wie wir benutzerdefinierte Annotationen verwenden, um asynchrone Aufgaben zu implementieren Bestimmen der Erstellung asynchroner Threads basierend auf ihrem wahren oder falschen Wert.

Wir setzen es auf die Methode der Business-Klasse:

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

Dann verwenden wir AOP, um diese Annotation zu scannen:

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

Wir können sehen, dass wir Around verwenden, um einen Methodenstapel zu finden, der Annotationen im Ausführungsthread nach der Erfassung enthält it, Das entsprechende Verbindungspunktobjekt kann abgerufen werden.

Verwenden Sie die getSignture-Methode des Verbindungspunktobjekts ProcedJoinPoint, um die Signatur in den Methodensignaturtyp MethdSignture umzuwandeln, und verwenden Sie dann die getMethod-Methode dieses Typs, um die Methode selbst abzurufen Sie können die Annotation der Methode abrufen und die Attribute der Annotation verwenden. Erhalten Sie direkt den wahren oder falschen Wert des Werts, um zu bestimmen, ob die Methode synchron oder asynchron übergeben wird. (Der Quellcode nutzt den Reflexionsmechanismus).

Das obige ist der detaillierte Inhalt vonWie Springboot Aop-Erfassungsanmerkungen verwendet, um die asynchrone Geschäftsausführung zu implementieren. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!