Comment SpringBoot implémente les appels asynchrones avec élégance

Avant-propos

• Programmation synchrone : Dans la programmation synchrone, les tâches sont exécutées une à la fois, et seulement lorsqu'une tâche est terminée, la tâche suivante sera débloquée.

• Programmation asynchrone : Dans la programmation asynchrone, plusieurs tâches peuvent être effectuées simultanément. Vous pouvez passer à une autre tâche avant que la tâche précédente ne soit terminée.

Dans Spring Boot, nous pouvons utiliser l'annotation @Async pour implémenter un comportement asynchrone. 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

Étapes d'implémentation🎜🎜1. Définir une interface de service asynchrone AsyncService.java🎜rrreee🎜2 Implémenter l'interface définie AsyncServiceImpl.java🎜rrreee🎜🎜🎜. AsyncServiceImpl est un bean géré par spring. 🎜🎜🎜🎜Votre méthode asynchrone doit être publique et décorée de l'annotation @Async. 🎜🎜🎜🎜Le type de retour est limité à void ou Future. 🎜🎜🎜🎜3. Définissez un contrôleur AsyncController.java🎜rrreee🎜🎜🎜Le point clé est d'ajouter l'annotation pour activer l'asynchrone @EnableAsync Bien sûr, cette annotation. est ajouté aux autres L'endroit est ok. 🎜🎜🎜🎜Lorsque cette interface est appelée en externe, asyncMethod() sera exécuté par un autre thread créé par l'exécuteur de tâches par défaut, et le thread principal n'a pas besoin d'attendre la fin de la méthode asynchrone exécution. 🎜🎜🎜🎜4. Exécutez-le🎜🎜Maintenant, exécutons-le et voyons s'il revient de manière asynchrone. 🎜🎜🎜🎜🎜🎜Vous pouvez voir l'appel /asyncinterface, la dernière étape appelle la méthode. 🎜🎜<img src="https://img.php.cn/upload/article/000/887/227/168390024926989.png" alt="Comment SpringBoot implémente les appels asynchrones avec élégance">🎜🎜<img src="https://img.php.cn/upload/article/000/887/227/168390024955556.png" alt="Comment SpringBoot implémente les appels asynchrones avec élégance">🎜🎜Appelez <code>/asyncFuture , et J'ai constaté que le retour durait plus de 5 secondes. N'est-il pas asynchrone ? En fait, il est également asynchrone, comme vous pouvez le voir sur les journaux, mais ce que nous retournons est Future, et l'appel de Futrue.get() est bloqué. 🎜🎜Exécuteur de tâches asynchrones personnalisé et gestion des exceptions🎜🎜Voyons maintenant ce qui se passe si une erreur est signalée dans la méthode d'exception ? Modifiez le code asynchrone comme suit, une exception d'exécution sera levée : 🎜🎜🎜🎜Exécutez à nouveau l'interface asynchrone, comme indiqué ci-dessous, le pool de threads par défaut et la gestion des exceptions seront utilisés. 🎜🎜🎜🎜Nous pouvons aussi le faire Nous-mêmes Pour définir la gestion des exceptions et l'exécuteur de tâches asynchrone de la méthode asynchrone, nous devons configurer AsyncUncaughtExceptionHandler, comme indiqué dans le code suivant : 🎜rrreee🎜Exécutez à nouveau, les résultats sont les suivants : 🎜🎜🎜🎜@Async Comment travailler🎜🎜Doit être fait en utilisant @ L'annotation EnableAsync annote la classe d'application principale ou toute classe d'appelant de méthode asynchrone directe ou indirecte pour activer la prise en charge asynchrone. Il est principalement implémenté via le mode proxy. Le mode par défaut est Proxy et l'autre est AspectJ. Le mode proxy permet uniquement d'intercepter les appels via un proxy. N'appelez jamais une méthode asynchrone de la même classe dans laquelle elle est définie, cela ne fonctionnera pas. 🎜🎜Lors de l'annotation d'une méthode avec @Async, cela créera un proxy pour l'objet basé sur l'attribut "proxyTargetClass". Lorsque spring exécute cette méthode, il recherche par défaut la définition du pool de threads associé. Le seul framework spring Bean TaskExecutor ou Bean Executor nommé "taskExecutor" dans le contexte. Si les deux ne sont pas résolus, le framework Spring SimpleAsyncTaskExecutor sera utilisé par défaut pour gérer l'exécution des méthodes asynchrones. 🎜

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!