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

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

我使用的是 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.
     }
  }
}

我需要调用相同的方法 3 次，以便在它遇到 catch 块时重试。 如何异步执行此操作？

我找到了下面的代码，但没有用。

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

感谢您的帮助。

解决方法

对于重试机制，您可以使用 @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 boot的完整代码示例

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

}

,

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

@Configuration
@EnableRetry
@EnableAsync
class RetryConfig {}

当您想将 Async 与 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);
    }
}