@Testpublic Integer sampleRetry(int code) {    System.out.println("sampleRetry,时间：" + LocalTime.now());    int times = 0;    while (times < MAX_TIMES) {        try {            postCommentsService.retryableTest(code);        } catch (Exception e) {            times++;            System.out.println("重试次数" + times);            if (times >= MAX_TIMES) {                //记录落库，后续定时任务兜底重试                //do something record...                 throw new RuntimeException(e);            }        }    }    System.out.println("sampleRetry,返回！");    return null;}

2.2 动态代理模式版本

在某些情况下，一个对象不适合或不能直接引用另一个对象，这时我们可以使用代理对象来起到中介作用，它可以在客户端和目标对象之间进行通信。使用代理对象的好处在于，它兼容性比较好，每个重试方法都可以调用。

使用方式

public class DynamicProxyTest implements InvocationHandler {    private final Object subject;    public DynamicProxy(Object subject) {        this.subject = subject;    }      /**     * 获取动态代理     *     * @param realSubject 代理对象     */    public static Object getProxy(Object realSubject) {        //    我们要代理哪个真实对象，就将该对象传进去，最后是通过该真实对象来调用其方法的        InvocationHandler handler = new DynamicProxy(realSubject);        return Proxy.newProxyInstance(handler.getClass().getClassLoader(),                realSubject.getClass().getInterfaces(), handler);    }    @Override    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {        int times = 0;        while (times < MAX_TIMES) {            try {                // 当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用                return method.invoke(subject, args);            } catch (Exception e) {                times++;                System.out.println("重试次数" + times);                if (times >= MAX_TIMES) {                    //记录落库，后续定时任务兜底重试                    //do something record...                     throw new RuntimeException(e);                }            }        }        return null;    }}

测试demo

@Test public Integer V2Retry(int code) {         RetryableTestServiceImpl realService = new RetryableTestServiceImpl();        RetryableTesterviceImpl proxyService = (RetryableTestServiceImpl) DynamicProxyTest.getProxy(realService);        proxyService.retryableTest(code);}

2.3 字节码技术生成代理重试

CGLIB 是一种代码生成库，它能够扩展 Java 类并在运行时实现接口。它具有功能强大、高性能和高质量的特点。使用 CGLIB 可以生成子类来代理目标对象，从而在不改变原始类的情况下，实现对其进行扩展和增强。这种技术被广泛应用于 AOP 框架、ORM 框架、缓存框架以及其他许多 Java 应用程序中。CGLIB 通过生成字节码来创建代理类，具有较高的性能。

使用方式

public class CglibProxyTest implements MethodInterceptor {    @Override    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {        int times = 0;        while (times < MAX_TIMES) {            try {                //通过代理子类调用父类的方法                return methodProxy.invokeSuper(o, objects);            } catch (Exception e) {                times++;                if (times >= MAX_TIMES) {                    throw new RuntimeException(e);                }            }        }        return null;    }    /**     * 获取代理类     * @param clazz 类信息     * @return 代理类结果     */    public Object getProxy(Class clazz){        Enhancer enhancer = new Enhancer();        //目标对象类        enhancer.setSuperclass(clazz);        enhancer.setCallback(this);        //通过字节码技术创建目标对象类的子类实例作为代理        return enhancer.create();    }}

测试demo

@Test public Integer CglibRetry(int code) {        RetryableTestServiceImpl proxyService = (RetryableTestServiceImpl) new CglibProxyTest().getProxy(RetryableTestServiceImpl.class);        proxyService.retryableTest(code);}

2.4 HSF调用超时重试

在我们日常开发中，调用第三方 HSF服务时出现瞬时抖动是很常见的。为了降低调用超时对业务造成的影响，我们可以根据业务特性和下游服务特性，使用 HSF 同步重试的方式。如果使用的框架没有特别设置，HSF 接口超时默认不会进行自动重试。在注解 @HSFConsumer 中，有一个参数 retries，通过它可以设置失败重试的次数。默认情况下，这个参数的值默认是0。

  @HSFConsumer(serviceVersion = "1.0.0", serviceGroup = "hsf",clientTimeout = 2000, methodSpecials = {            @ConsumerMethodSpecial(methodName = "methodA", clientTimeout = "100", retries = "2"),            @ConsumerMethodSpecial(methodName = "methodB", clientTimeout = "200", retries = "1")})    private XxxHSFService xxxHSFServiceConsumer;

HSFConsumer超时重试原理

一次HSF的服务调用过程示意图：

HSF 超时重试发生在AsyncToSyncInvocationHandler # invokeType(.): 如果配置的retries参数大于0则使用retry()方法进行重试，且重试只发生在TimeoutException异常的情况下。

源码分析

private RPCResult invokeType(Invocation invocation, InvocationHandler invocationHandler) throws Throwable {        final ConsumerMethodModel consumerMethodModel = invocation.getClientInvocationContext().getMethodModel();        String methodName = consumerMethodModel.getMethodName(invocation.getHsfRequest());        final InvokeMode invokeType = getInvokeType(consumerMethodModel.getMetadata(), methodName);        invocation.setInvokeType(invokeType);        ListenableFuture<RPCResult> future = invocationHandler.invoke(invocation);        if (InvokeMode.SYNC == invokeType) {            if (invocation.getBroadcastFutures() != null && invocation.getBroadcastFutures().size() > 1) {                //broadcast                return broadcast(invocation, future);            } else if (consumerMethodModel.getExecuteTimes() > 1) {                //retry                return retry(invocation, invocationHandler, future, consumerMethodModel.getExecuteTimes());            } else {                //normal                return getRPCResult(invocation, future);            }        } else {            // pseudo response, should be ignored            HSFRequest request = invocation.getHsfRequest();            Object appResponse = null;            if (request.getReturnClass() != null) {                appResponse = ReflectUtils.defaultReturn(request.getReturnClass());            }            HSFResponse hsfResponse = new HSFResponse();            hsfResponse.setAppResponse(appResponse);            RPCResult rpcResult = new RPCResult();            rpcResult.setHsfResponse(hsfResponse);            return rpcResult;        }    }

从上面这段代码可以看出，retry 重试只有发生在同步调用当中。消费者方法的元数据的执行次数大于1（consumerMethodModel.getExecuteTimes() > 1）时会走到retry方法去尝试重试：

private RPCResult retry(Invocation invocation, InvocationHandler invocationHandler,                            ListenableFuture<RPCResult> future, int executeTimes) throws Throwable {        int retryTime = 0;        while (true) {            retryTime++;            if (retryTime > 1) {                future = invocationHandler.invoke(invocation);            }            int timeout = -1;            try {                timeout = (int) invocation.getInvokerContext().getTimeout();                RPCResult rpcResult = future.get(timeout, TimeUnit.MILLISECONDS);                return rpcResult;            } catch (ExecutionException e) {                throw new HSFTimeOutException(getErrorLog(e.getMessage()), e);            } catch (TimeoutException e) {                //retry only when timeout                if (retryTime < executeTimes) {                    continue;                } else {                    throw new HSFTimeOutException(getErrorLog(e.getMessage()), timeout + "", e);                }            } catch (Throwable e) {                throw new HSFException("", e);            }        }    }

HSFConsumer超时重试原理利用的是简单的while循环+ try-catch

缺陷：

1、只有方法被同步调用时候才会发生重试。

2、只有hsf接口出现TimeoutException才会调用重试方法。

3、如果为某个 HSFConsumer 中的 method 设置了 retries 参数，当方法返回时出现超时异常，HSF SDK 会自动重试。重试实现的方式是一个 while+ try-catch循环。所以，如果自动重试的接口变得缓慢，而且重试次数设置得过大，会导致 RT 变长，极端情况下还可能导致 HSF 线程池被打满。因此，HSF 的自动重试特性是一个基础、简单的能力，不推荐大面积使用。

2.5 Spring Retry

Spring Retry 是 Spring 系列中的一个子项目，它提供了声明式的重试支持，可以帮助我们以标准化的方式处理任何特定操作的重试。这个框架非常适合于需要进行重试的业务场景，比如网络请求、数据库访问等。使用 Spring Retry，我们可以使用注解来设置重试策略，而不需要编写冗长的代码。所有的配置都是基于注解的，这使得使用 Spring Retry 变得非常简单和直观。

POM依赖

<dependency>    <groupId>org.springframework.retry</groupId>    <artifactId>spring-retry</artifactId></dependency><dependency>    <groupId>org.springframework</groupId>    <artifactId>spring-aspects</artifactId></dependency>

启用@Retryable

引入spring-retry jar包后在spring boot的启动类上打上@EnableRetry注解。

@EnableRetry@SpringBootApplication(scanBasePackages = {"me.ele.camp"},excludeName = {"me.ele.oc.orm.OcOrmAutoConfiguraion"})@ImportResource({"classpath*:sentinel-tracer.xml"})public class Application {    public static void main(String[] args) {        System.setProperty("APPID","alsc-info-local-camp");        System.setProperty("project.name","alsc-info-local-camp");}

service实现类添加@Retryable注解

    @Override    @Retryable(value = BizException.class, maxAttempts = 6)    public Integer retryableTest(Integer code) {        System.out.println("retryableTest,时间：" + LocalTime.now());        if (code == 0) {            throw new BizException("异常", "异常");        }        BaseResponse<Object> objectBaseResponse = ResponseHandler.serviceFailure(ResponseErrorEnum.UPDATE_COMMENT_FAILURE);        System.out.println("retryableTest,正确！");        return 200;    }    @Recover    public Integer recover(BizException e) {        System.out.println("回调方法执行！！！！");        //记日志到数据库 或者调用其余的方法        return 404;        };

可以看到代码里面，实现方法上面加上了注解 @Retryable，@Retryable有以下参数可以配置：

value	抛出指定异常才会重试；
include	和value一样，默认为空，当exclude也为空时，默认所有异常；
exclude	指定不处理的异常；
maxAttempts	最大重试次数，默认3次；
backoff	重试等待策略，默认使用@Backoff，@Backoff的value默认为1000(单位毫秒)；
multiplier	指定延迟倍数）默认为0，表示固定暂停1秒后进行重试，如果把multiplier设置为1.5，则第一次重试为2秒，第二次为3秒，第三次为4.5秒；

Spring-Retry还提供了@Recover注解，用于@Retryable重试失败后处理方法。如果不需要回调方法，可以直接不写回调方法，那么实现的效果是，重试次数完了后，如果还是没成功没符合业务判断，就抛出异常。可以看到传参里面写的是 BizException e，这个是作为回调的接头暗号（重试次数用完了，还是失败，我们抛出这个BizException e通知触发这个回调方法）。

注意事项：

@Recover注解来开启重试失败后调用的方法，此注解注释的方法参数一定要是@Retryable抛出的异常，否则无法识别。
@Recover标注的方法的返回值必须与@Retryable标注的方法一致。
该回调方法与重试方法写在同一个实现类里面。
由于是基于AOP实现，所以不支持类里自调用方法。
方法内不能使用try catch，只能往外抛异常，而且异常必须是Throwable类型的。

原理

Spring-retyr调用时序图：

Spring Retry 的基本原理是通过 @EnableRetry 注解引入 AOP 能力。在 Spring 容器启动时，会扫描所有带有 @Retryable 和 @CircuitBreaker（熔断器）注解的方法，并为其生成 PointCut 和 Advice。当发生方法调用时，Spring 会委托拦截器 RetryOperationsInterceptor 进行调用，拦截器内部实现了失败退避重试和降级恢复方法。这种设计模式使得重试逻辑的实现非常简单易懂，并且能够充分利用 Spring 框架提供的 AOP 能力，从而实现高效而优雅的重试机制。

缺陷

尽管 Spring Retry 工具能够优雅地实现重试，但它仍然存在两个不太友好的设计：

首先，重试实体被限定为 Throwable 子类，这意味着重试针对的是可捕获的功能异常，但实际上我们可能希望依赖某个数据对象实体作为重试实体，但是 Spring Retry 框架必须强制将其转换为 Throwable 子类。

其次，重试根源的断言对象使用的是 doWithRetry 的 Exception 异常实例，这不符合正常内部断言的返回设计。

Spring Retry 建议使用注解来对方法进行重试，重试逻辑是同步执行的。重试的“失败”是指 Throwable 异常，如果你要通过返回值的某个状态来判断是否需要重试，则可能需要自己判断返回值并手动抛出异常。

2.6 Guava Retrying

Guava Retrying 是基于 Google 的核心类库 Guava 的重试机制实现的一个库，它提供了一种通用方法，可以使用 Guava 谓词匹配增强的特定停止、重试和异常处理功能来重试任意 Java 代码。这个库支持多种重试策略，比如指定重试次数、指定重试时间间隔等。此外，它还支持谓词匹配来确定是否应该重试，以及在重试时应该做些什么。Guava Retrying 的最大特点是它能够灵活地与其他 Guava 类库集成，这使得它非常易于使用。

POM依赖

      <dependency>      <groupId>com.github.rholder</groupId>      <artifactId>guava-retrying</artifactId>      <version>2.0.0</version>    </dependency>

测试demo

public static void main(String[] args) {     Callable<Boolean> callable = new Callable<Boolean>() {            @Override            public Boolean call() throws Exception {                // do something useful here                log.info("call...");                throw new RuntimeException();            }        };        Retryer<Boolean> retryer = RetryerBuilder.<Boolean>newBuilder()             //retryIf 重试条件                .retryIfException()                .retryIfRuntimeException()                .retryIfExceptionOfType(Exception.class)                .retryIfException(Predicates.equalTo(new Exception()))                .retryIfResult(Predicates.equalTo(false))           //等待策略：每次请求间隔1s                .withWaitStrategy(WaitStrategies.fixedWait(1, TimeUnit.SECONDS))          //停止策略 : 尝试请求6次              .withStopStrategy(StopStrategies.stopAfterAttempt(6))                //时间限制 : 某次请求不得超过2s               .withAttemptTimeLimiter(          AttemptTimeLimiters.fixedTimeLimit(2, TimeUnit.SECONDS))           //注册一个自定义监听器（可以实现失败后的兜底方法）              .withRetryListener(new MyRetryListener()).build();        try {            retryer.call(callable);        } catch (Exception ee) {            ee.printStackTrace();        }}

当发生重试之后，假如我们需要做一些额外的处理动作，比如发个告警邮件啥的，那么可以使用RetryListener。每次重试之后，guava-retrying会自动回调我们注册的监听。可以注册多个RetryListener，会按照注册顺序依次调用。

public class MyRetryListener implements RetryListener {    @Override    public <V> void onRetry(Attempt<V> attempt) {         // 第几次重试        System.out.print("[retry]time=" + attempt.getAttemptNumber());        // 距离第一次重试的延迟        System.out.print(",delay=" + attempt.getDelaySinceFirstAttempt());        // 重试结果: 是异常终止, 还是正常返回        System.out.print(",hasException=" + attempt.hasException());        System.out.print(",hasResult=" + attempt.hasResult());        // 是什么原因导致异常        if (attempt.hasException()) {            System.out.print(",causeBy=" + attempt.getExceptionCause().toString());            // do something useful here        } else {            // 正常返回时的结果            System.out.print(",result=" + attempt.getResult());        }        System.out.println();    }}

RetryerBuilder是一个factory创建者，可以定制设置重试源且可以支持多个重试源，可以配置重试次数或重试超时时间，以及可以配置等待时间间隔，创建重试者Retryer实例。

RetryerBuilder的重试源支持Exception异常对象和自定义断言对象，通过retryIfException 和retryIfResult设置，同时支持多个且能兼容。

retryIfException，抛出runtime异常、checked异常时都会重试，但是抛出error不会重试。
retryIfRuntimeException只会在抛runtime异常的时候才重试，checked异常和error都不重试。
retryIfExceptionOfType允许我们只在发生特定异常的时候才重试，比如NullPointerException和IllegalStateException都属于runtime异常，也包括自定义的error。
retryIfResult可以指定你的Callable方法在返回值的时候进行重试。

StopStrategy：停止重试策略，提供以下方式：

StopAfterDelayStrategy	设定一个最长允许的执行时间；比如设定最长执行10s，无论任务执行次数，只要重试的时候超出了最长时间，则任务终止，并返回重试异常
NeverStopStrategy	用于需要一直轮训知道返回期望结果的情况。
StopAfterAttemptStrategy	设定最大重试次数，如果超出最大重试次数则停止重试，并返回重试异常。
WaitStrategy	等待时长策略（控制时间间隔）
FixedWaitStrategy	固定等待时长策略。
RandomWaitStrategy	随机等待时长策略（可以提供一个最小和最大时长，等待时长为其区间随机值）。
IncrementingWaitStrategy	递增等待时长策略（提供一个初始值和步长，等待时间随重试次数增加而增加）。
ExponentialWaitStrategy	指数等待时长策略
FibonacciWaitStrategy	等待时长策略
ExceptionWaitStrategy	异常时长等待策略
CompositeWaitStrategy	复合时长等待策略