java 8中如何实现异步重试机制？

Question

我正在使用 Java 8 Spring 启动。我有以下方法。

public hello() {
  try {
    // send message
  }
  catch(HttpClientErrorException e) {
     if (e.getRawStatusCode() == 401) {
          // I need to retry the same hello() method for three times as in 10sec, 20sec and 25sec.
     }
  }
}

我需要调用相同的方法三次，以便在遇到 catch 块时重试。我怎样才能异步执行此操作？

我找到了下面的代码，但它不起作用。

@Retryable( value = {RestClientException.class}, maxAttempts = 3, backoff = @Backoff(3000)) 

感谢你的帮助。

Answer 1

您可以使用@AsyncSpring 的注释来实现这一点。你必须创建一个像这样的配置：

@Configuration
@EnableRetry
@EnableAsync
class RetryConfig {}

当你想使用Asyncwith时Retry，你必须装饰Async试图调用Retryable方法的方法。另外，你必须确保你正在返回Future<>或类似的，因为你正在发送那段代码以在后台进行折腾，我还实现了回退机制，否则请求将因 500 异常而终止。

如果运行下面的代码，您可以看到主请求在线程上执行http-nio-8080-exec-1，而异步代码在不同的线程上执行task-1。

我尝试用示例服务方法来解释这一点，但本地或远程服务调用的概念是相同的。

下面给出了详细的示例：

package com.example.silentsudo.springcloudssamples;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Configuration;
import org.springframework.retry.annotation.Backoff;
import org.springframework.retry.annotation.EnableRetry;
import org.springframework.retry.annotation.Recover;
import org.springframework.retry.annotation.Retryable;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.stereotype.Service;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.CompletableFuture;

@SpringBootApplication
public class SpringCloudsSamplesApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringCloudsSamplesApplication.class, args);
    }

}

@RequestMapping(path = "sample")
@RestController
class SampleController {

    private final GreetService greetService;

    SampleController(GreetService greetService) {
        this.greetService = greetService;
    }

    @GetMapping
    public String hello() {
        System.out.println(Thread.currentThread().getName());
        return "Hello!";
    }

    @GetMapping(path = "greet")
    public String greet(@RequestParam(value = "name", defaultValue = "John") String name) {
        return greetService.greet(name);
    }

    @Async
    @GetMapping(path = "greet-async")
    public CompletableFuture<String> greetAsync(@RequestParam(value = "name", defaultValue = "John") String name) {
        return CompletableFuture.completedFuture(greetService.greet(name));
    }
}

@Configuration
@EnableRetry
@EnableAsync
class RetryConfig {

}

@Service
class GreetService {

    private final UngaBungaService ungaBungaService;

    GreetService(UngaBungaService ungaBungaService) {
        this.ungaBungaService = ungaBungaService;
    }

    @Retryable(maxAttempts = 5, value = GreetException.class, backoff = @Backoff(value = 3000L))
    public String greet(String name) {
        return ungaBungaService.lol(name);
    }

    @Recover
    public String recoverGreetException(GreetException greetException) {
        return greetException.getMessage();
    }
}

@Service
class UngaBungaService {
    public String lol(String name) {
        System.out.println(Thread.currentThread().getName());
        throw new GreetException("Called greet for " + name);
    }
}

class GreetException extends RuntimeException {
    public GreetException(String message) {
        super(message);
    }
}