Wie SpringBoot asynchrone Aufrufe elegant implementiert

Vorwort

• Synchronische Programmierung: Bei der synchronen Programmierung werden Aufgaben einzeln ausgeführt, und erst wenn eine Aufgabe abgeschlossen ist, wird die Blockierung der nächsten Aufgabe aufgehoben.

• Asynchrone Programmierung: Bei der asynchronen Programmierung können mehrere Aufgaben gleichzeitig ausgeführt werden. Sie können zu einer anderen Aufgabe wechseln, bevor die vorherige Aufgabe abgeschlossen ist.

In Spring Boot können wir die Annotation @Async verwenden, um asynchrones Verhalten zu implementieren. Spring Boot中，我们可以使用@Async注解来实现异步行为。

实现步骤

1.定义一个异步服务接口AsyncService.java

public interface AsyncService {

    void asyncMethod() throws InterruptedException;

    Future<String> futureMethod() throws InterruptedException;
}

2.实现定义的接口AsyncServiceImpl.java

@Service
@Slf4j
public class AsyncServiceImpl implements AsyncService  {

    @Async
    @Override
    public void asyncMethod() throws InterruptedException {
        Thread.sleep(3000);
        log.info("Thread: [{}], Calling other service..", Thread.currentThread().getName());
    }

    @Async
    @Override
    public Future<String> futureMethod() throws InterruptedException {
        Thread.sleep(5000);
        log.info("Thread: [{}], Calling other service..", Thread.currentThread().getName());
        return new AsyncResult<>("task Done");
    }
}

• AsyncServiceImpl 是一个 spring 管理的 bean。

• 您的异步方法必须是公共的，而且是被@Async注解修饰。

• 返回类型被限制为 void 或 Future。

3.定义一个控制器AsyncController.java

@EnableAsync
@RestController
@Slf4j
public class AsyncController {
    @Autowired
    AsyncService asyncService;

    @GetMapping("/async")
    public String asyncCallerMethod() throws InterruptedException {
        long start = System.currentTimeMillis();
        log.info("call async method, thread name: [{}]", Thread.currentThread().getName());
        asyncService.asyncMethod();
        String response = "task completes in :" +
                (System.currentTimeMillis() - start) + "milliseconds";
        return response;
    }

    @GetMapping("/asyncFuture")
    public String asyncFuture() throws InterruptedException, ExecutionException {
        long start = System.currentTimeMillis();
        log.info("call async method, thread name: [{}]", Thread.currentThread().getName());
        Future<String> future = asyncService.futureMethod();
        // 阻塞获取结果
        String taskResult = future.get();
        String response = taskResult + "task completes in :" +
                (System.currentTimeMillis() - start) + "milliseconds";
        return response;
    }
}

• 关键点，需要添加启用异步的注解@EnableAsync ，当然这个注解加在其他地方也ok得。

• 当外部调用该接口时，asyncMethod()将由默认任务执行程序创建的另一个线程执行，主线程不需要等待完成异步方法执行。

4.运行一下

现在我们运行一下看看，是不是异步返回的。

可以看到调用/async接口，最终一步调用了方法。

调用/asyncFuture，发现返回5秒多，难道不是异步的吗？其实也是异步的，看日志可以看出来，只不过我们返回的是Future,调用Futrue.get()是阻塞的。

自定义异步任务执行器和异常处理

我们现在看看如果异常方法中报错了会怎么样？修改异步代码如下所示，会抛运行时异常：

再次执行异步接口，如下所示，会使用默认的线程池和异常处理。

我们也可以自定义异步方法的处理异常和异步任务执行器，我们需要配置 AsyncUncaughtExceptionHandler，如下代码所示：

@Configuration
public class AsynConfiguration extends AsyncConfigurerSupport {
   @Override
   public Executor getAsyncExecutor() {
      ThreadPoolTaskExecutor executor = new 
                ThreadPoolTaskExecutor();
      executor.setCorePoolSize(3);
      executor.setMaxPoolSize(4);
      executor.setThreadNamePrefix("asyn-task-thread-");
      executor.setWaitForTasksToCompleteOnShutdown(true);
      executor.initialize();
      return executor;
  }
  @Override
  public AsyncUncaughtExceptionHandler  
         getAsyncUncaughtExceptionHandler() {
     return new AsyncUncaughtExceptionHandler() {
   
        @Override
        public void handleUncaughtException(Throwable ex, 
           Method method, Object... params) {
           System.out.println("Exception: " + ex.getMessage());
           System.out.println("Method Name: " + method.getName());
           ex.printStackTrace();
        }
    };
  }
}

再次运行，得到的结果如下：

@Async如何工作的

必须通过使用 @EnableAsync注解注解主应用程序类或任何直接或间接异步方法调用程序类来启用异步支持。主要通过代理模式实现，默认模式是 Proxy，另一种是 AspectJ。代理模式只允许通过代理拦截调用。永远不要从定义它的同一个类调用异步方法，它不会起作用。

当使用 @Async对方法进行注解时，它会根据“proxyTargetClass”属性为该对象创建一个代理。当 spring 执行这个方法时，默认情况下它会搜索关联的线程池定义。上下文中唯一的 spring 框架 TaskExecutor bean 或名为“taskExecutor”的 Executor bean。如果这两者都不可解析，默认会使用spring框架SimpleAsyncTaskExecutor

Implementierungsschritte🎜🎜1. Definieren Sie eine asynchrone Serviceschnittstelle AsyncService.java🎜rrreee🎜2. Implementieren Sie die definierte Schnittstelle AsyncServiceImpl.java🎜🎜🎜 AsyncServiceImpl ist eine Bean, die von spring verwaltet wird. 🎜🎜🎜🎜Ihre asynchrone Methode muss öffentlich sein und mit der Annotation @Async versehen sein. 🎜🎜🎜🎜Der Rückgabetyp ist auf void oder Future beschränkt. 🎜🎜🎜🎜3. Definieren Sie einen Controller AsyncController.java🎜rrreee🎜🎜🎜Der entscheidende Punkt ist das Hinzufügen der Annotation, um asynchrones @EnableAsync zu aktivieren wird zu anderen hinzugefügt Der Ort ist ok. 🎜🎜🎜🎜Wenn diese Schnittstelle extern aufgerufen wird, wird asyncMethod() von einem anderen Thread ausgeführt, der vom Standard-Task-Executor erstellt wurde, und der Hauptthread muss nicht auf den Abschluss der asynchronen Methode warten Ausführung. 🎜🎜🎜🎜4. Führen Sie es aus🎜🎜Jetzt lassen Sie es uns ausführen und sehen, ob es asynchron zurückkehrt. 🎜🎜🎜🎜🎜🎜Sie können den Aufruf /async Schnittstelle, der letzte Schritt ruft die Methode auf. 🎜🎜<img src="/static/imghw/default1.png" data-src="https://img.php.cn/upload/article/000/887/227/168390024926989.png" class="lazy" alt="Wie SpringBoot asynchrone Aufrufe elegant implementiert">🎜🎜<img src="/static/imghw/default1.png" data-src="https://img.php.cn/upload/article/000/887/227/168390024965912.png" class="lazy" alt="Wie SpringBoot asynchrone Aufrufe elegant implementiert">🎜🎜Call <code>/asyncFuture , und festgestellt, dass die Rückgabe länger als 5 Sekunden dauerte. Ist es nicht asynchron? Tatsächlich ist es auch asynchron, wie Sie den Protokollen entnehmen können, aber was wir zurückgeben, ist Future und der Aufruf von Futrue.get() wird blockiert. 🎜🎜Angepasster asynchroner Task-Executor und Ausnahmebehandlung🎜🎜Sehen wir uns nun an, was passiert, wenn in der Ausnahmemethode ein Fehler gemeldet wird? Ändern Sie den asynchronen Code wie folgt. Es wird eine Laufzeitausnahme ausgelöst: 🎜🎜🎜🎜Führen Sie die asynchrone Schnittstelle erneut aus, wie unten gezeigt, der Standard-Thread-Pool und die Ausnahmebehandlung werden verwendet. 🎜🎜🎜🎜Wir können es auch Um die Ausnahmebehandlung der asynchronen Methode und den asynchronen Task-Executor zu definieren, müssen wir AsyncUncaughtExceptionHandler konfigurieren, wie im folgenden Code gezeigt: 🎜rrreee🎜Erneut ausführen, die Ergebnisse sind wie folgt: 🎜🎜🎜🎜@Async So funktioniert es🎜🎜Muss getan werden Durch die Verwendung der Annotation @ Die EnableAsync kommentieren Sie die Hauptanwendungsklasse oder eine beliebige direkte oder indirekte asynchrone Methodenaufruferklasse, um die asynchrone Unterstützung zu aktivieren. Es wird hauptsächlich über den Proxy-Modus implementiert. Der Standardmodus ist Proxy und der andere ist AspectJ. Im Proxy-Modus können Anrufe nur über einen Proxy abgefangen werden. Rufen Sie niemals eine asynchrone Methode aus derselben Klasse auf, in der sie definiert ist, da sie sonst nicht funktioniert. 🎜🎜Wenn Sie eine Methode mit @Async annotieren, wird ein Proxy für das Objekt basierend auf dem Attribut „proxyTargetClass“ erstellt. Wenn spring diese Methode ausführt, sucht es standardmäßig nach der zugehörigen Thread-Pool-Definition. Das einzige Spring Framework TaskExecutor Bean oder Executor Bean mit dem Namen „taskExecutor“ im Kontext. Wenn keines davon auflösbar ist, wird standardmäßig das Spring-Framework SimpleAsyncTaskExecutor verwendet, um die Ausführung asynchroner Methoden zu verarbeiten. 🎜

Das obige ist der detaillierte Inhalt vonWie SpringBoot asynchrone Aufrufe elegant implementiert. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!