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

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

对于重试机制，您可以使用 @Retryable(value = RestClientException.class)

要触发此异常，您需要实际抛出此异常（或从 RestClientException 扩展的异常）。因为你的 catch 语句，实际上没有抛出异常，所以重试机制没有启动。

@Retryable( value = {RestClientException.class}, maxAttempts = 3, backoff = @Backoff(3000)) 
public void hello() {
  try {
    // send message
  }
  catch(HttpClientErrorException e) {
     if (e.getRawStatusCode() == 401) {
          throw new RestClientException("meaningfull message");
     }
  }
}

如果你想在 3 次重试失败后运行捕获一些代码，你可以在恢复方法上使用 @Recover 注释。

如果您想了解有关重试机制的更多信息，可以查看 here

另外不要忘记在您的配置中添加 @EnableRetry 以便使用注释。

带有 spring 引导的完整代码示例

@SpringBootApplication
public class DemoApplication {

public static void main(String[] args) {
    ConfigurableApplicationContext context = SpringApplication.run(DemoApplication.class, args);
    context.getBean(TestService.class).hello();
    context.close();
}

@Configuration
@EnableRetry
public class AppConfig {
}

@Service
public class TestService {
    @Retryable(value = {IllegalArgumentException.class}, maxAttempts = 4, backoff = @Backoff(delay = 1000, multiplier = 4))
    public void hello() {
        try {
            int a = Integer.parseInt(null);
        } catch (NumberFormatException e) {
            System.out.println("AAAAAAAAAAAAAAAA");
            throw new IllegalArgumentException("exception triggered");
        }
    }
}

}

Answer 2

您可以使用 Spring 中的 @Async 注释来实现。您必须创建这样的配置：

@Configuration
@EnableRetry
@EnableAsync
class RetryConfig {}

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

如果您运行下面的代码，您可以看到主请求在线程 http-nio-8080-exec-1 上执行，而异步代码在另一个线程 task-1.[=20 上执行=]

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

详细例子如下：

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

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

How to implement asynchronous retry mechanism in java 8?

asynchronous

java-8

spring-retry

spring-boot

带有 spring 引导的完整代码示例