Java面向容错编程之重试机制

来源：Java面向容错编程之重试机制 (qq.com)

容错编程是一种旨在确保应用程序的可靠性和稳定性的编程思想，它采取以下措施：

1.异常处理：通过捕获和处理异常来避免应用程序崩溃。

2.错误处理：通过检查错误代码并采取适当的措施，如重试或回滚，来处理错误。

3.重试机制：在出现错误时，尝试重新执行代码块，直到成功或达到最大尝试次数。

4.备份机制：在主要系统出现故障时，切换到备用系统以保持应用程序的正常运行。

5.日志记录：记录错误和异常信息以便后续排查问题。

容错编程是一种重要的编程思想，它能够提高应用程序的可靠性和稳定性，同时提高代码的健壮性。

一、为什么需要重试

在做业务技术时，设计具备可复用、可扩展、可编排的系统架构至关重要，它直接决定着业务需求迭代的效率。但同时业务技术人员也应具备悲观思维：在分布式环境下因单点问题导致的HSF服务瞬时抖动并不少见，比如系统瞬时抖动、单点故障、服务超时、服务异常、中间件抖动、网络超时、配置错误等等各种软硬件问题。如果直接忽略掉这些异常则会降低服务的健壮性，严重时会影响用户体验、引起用户投诉，甚至导致系统故障。因此在做方案设计和技术实现时要充分考虑各种失败场景，针对性地做防御性编程。

我们在调用第三方接口时，经常会遇到失败的情况，针对这些情况，我们通常会处理失败重试和失败落库逻辑。然而，重试并不是适用于所有场景的，例如参数校验不合法、读写操作是否适合重试，数据是否幂等。远程调用超时或网络突然中断则可以进行重试。我们可以设置多次重试来提高调用成功的概率。为了方便后续排查问题和统计失败率，我们也可以将失败次数和是否成功记录落库，便于统计和定时任务兜底重试。

培训研发组在大本营、培训业务、本地e站等多业务对各种失败场景做了充分演练，并对其中一些核心流程做了各种形式的失败重试处理，比如骑手考试提交、同步数据到洞察平台、获取量子平台圈人标签等。本文总结了一些我们在面对服务失败时如何进行优雅重试，比如aop、cglib等同时对重试工具\组件的源码和注意事项进行总结分析。

二、如何重试

2.1   简单重试方法

测试demo

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

缺陷：

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依赖

    org.springframework.retry
    spring-retry


    org.springframework
    spring-aspects

启用@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