一步一步实现优雅重试

超、凢脫俗 2023-05-21 07:23 42阅读 0赞

## 重试的作用 ##

对于重试是有场景限制的，不是什么场景都适合重试，比如参数校验不合法、写操作等（要考虑写是否幂等）都不适合重试。

远程调用超时、网络突然中断可以重试。在微服务治理框架中，通常都有自己的重试与超时配置，比如dubbo可以设置retries=1、timeout=500调用失败只重试1次，超过500ms调用仍未返回则调用失败。对于开发过网络应用程序的程序员来说，重试并不陌生，由于网络的拥堵和波动，此刻不能访问服务的请求，也许过一小段时间就可以正常访问了。

对于RPC调用，或者数据入库等操作，如果一次操作失败，可以进行多次重试，提高调用成功的可能性。

## 重试的常见实现方式 ##

例如写实现一个推送用户姓名到控制台的功能。这个服务如果调用失败了，需要加上重试逻辑。

### 简单粗暴 ###

互联网注重效率，最简单的重试写法如下：

public interface UserService { 
    
        /** * 发送用户姓名到控制台 * @param userName 用户姓名 * @return 发送是否成功 */
        boolean sendUserName2Console(String userName);
    }

public class UserServiceImpl implements UserService { 
    
        public static final int RETRY_MAX_TIMES = 5;
    
        /** * 这里用System.out模拟RPC服务，如果传入字符串"abc"就返回false（失败），否则就成功 * @param userName * @return */
        @Override
        public boolean sendUserName2Console(String userName) { 
    
            if ("abc".equals(userName)) { 
                System.out.println("Please Retry！");
                return false;
            }
            System.out.println("Hello, " + userName);
            return true;
        }
    
        /** * @param userName * @return */
        public boolean sendUserName2ConsoleWithRetry(String userName) { 
            int invokeCount = 0;
            while(invokeCount < RETRY_MAX_TIMES) { 
                if (this.sendUserName2Console(userName)) { 
                    return true;
                }
                invokeCount++;
            }
            return false;
        }
    }

缺点：直接把重试写在服务实现方法体中，不易于维护。

### 代理模式 ###

使用代理模式去优化上面的写法，为其他对象提供一种代理以控制对这个对象的访问。代理对象可以在客户端和目标对象之间起到中介作用。

public class UserServiceProxyImpl implements UserService { 
    
        public static final int RETRY_MAX_TIMES = 5;
    
        private UserService userService;
    
        public UserServiceProxyImpl(UserService userService) { 
            this.userService = userService;
        }
    
        /** * 代理模式 * @param userName * @return */
        @Override
        public boolean sendUserName2Console(String userName) { 
            int invokeCount = 0;
            while(invokeCount < RETRY_MAX_TIMES) { 
                if (userService.sendUserName2Console(userName)) { 
                    return true;
                }
                invokeCount++;
            }
            return false;
        }
    }

缺点：如果UserService接口中还有其他方法要加入重试机制或者还有另一个服务也要求有重试机制，就得继续写代理方法或再写一个新的代理类，代理类越写越多

### 动态代理 ###

public class JdkDynamicProxy implements InvocationHandler { 
    
        private final Object target;
    
        public static final int RETRY_MAX_TIMES = 5;
    
        public JdkDynamicProxy(Object target) { 
            this.target = target;
        }
    
        /** * 动态代理模式，被代理类的方法调用都从invoke()方法进入，在这里加上重试逻辑 * @return */
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
            int invokeCount = 0;
            Object result = null;
            System.out.println("JdkDynamic proxy invoke");
            while(invokeCount < RETRY_MAX_TIMES) { 
                result = method.invoke(target, args);
                if (result != null && Boolean.TRUE.equals(result)) { 
                    break;
                }
                invokeCount++;
            }
            return result;
        }
    
    
        @SuppressWarnings(value = "unchecked")
        public <T> T getProxy() { 
            return (T)Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(), this);
        }

测试代码

@Test
    public void test() { 
    
        //版本三 测试
        System.out.println("--------版本三：重试逻辑写在动态代理类-----");
        UserService jdkProxy = (UserService)new JdkDynamicProxy(userService).getProxy();
        jdkProxy.sendUserName2Console("abc");
     }

测试结果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Z1emhvbmdtaW4wNQ_size_16_color_FFFFFF_t_70]

缺点：有的类没有实现接口，怎么代理?（其实就是JDK动态代理的缺点）

### 动态代理增强 ###

Cglib是一个强大的、高性能的代码生成包，它可以在运行期扩展Java类与实现Java接口，它广泛地被许多AOP及数据访问框架使用来生成动态代理对象，为他们提供方法的拦截。  
![在这里插入图片描述][20200429163909645.png]  
对此图总结一下：

*  最底层的是字节码Bytecode，字节码是Java为了保证“一次编译、到处运行”而产生的一种虚拟指令格式
 *  位于字节码之上的是ASM，这是一种直接操作字节码的框架，应用ASM需要对Java字节码、Class结构比较熟悉
 *  位于ASM之上的是CGLIB、Groovy、BeanShell，后两种并不是Java体系中的内容而是脚本语言，它们通过ASM框架生成字节码变相执行Java代码，这说明在JVM中执行程序并不一定非要写Java代码，只要你能生成Java字节码，JVM并不关心字节码的来源，当然通过Java代码生成的JVM字节码是通过编译器直接生成的，算是最“正统”的JVM字节码
 *  位于CGLIB、Groovy、BeanShell之上的就是Hibernate、Spring AOP这些框架了
 *  最上层的是Applications，即具体应用，一般都是一个Web项目或者本地跑一个程序

使用Cglib实现的动态代理代码如下

import java.lang.reflect.Method;
    
    import org.springframework.cglib.proxy.Enhancer;
    import org.springframework.cglib.proxy.MethodInterceptor;
    import org.springframework.cglib.proxy.MethodProxy;
    
    public class CglibDynamicProxy implements MethodInterceptor { 
    
        public static final int RETRY_MAX_TIMES = 5;
    
        /** * CGlib增强动态代理模式 * @return */
        @Override
        public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable { 
            int invokeCount = 0;
            Object result = null;
            System.out.println("CglibDynamic proxy invoke");
            while(invokeCount < RETRY_MAX_TIMES) { 
                result = methodProxy.invokeSuper(o, objects);
                if (result != null && Boolean.TRUE.equals(result)) { 
                    break;
                }
                invokeCount++;
            }
            return result;
        }
    
    
        @SuppressWarnings(value = "unchecked")
        public <T> T getProxy(Class clazz) { 
            Enhancer enhancer = new Enhancer();
            enhancer.setSuperclass(clazz);
            enhancer.setCallback(this);
            return (T)enhancer.create();
        }
    }

测试代码

@Test
    public void test() { 
    
        //版本四 测试
    	System.out.println("-------版本四：重试逻辑写在Cglib增强动态代理类中，实现类不感知重试-----");
    	UserService cglibProxy = (UserService)new CglibDynamicProxy().getProxy(UserServiceImpl.class);
    	cglibProxy.sendUserName2Console("abc");
    }

测试结果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Z1emhvbmdtaW4wNQ_size_16_color_FFFFFF_t_70 1]

缺点：不同的服务，重试的次数应该是不同的，因为服务对稳定性的要求各不相同，代理模式无法定制重试次数

### 模板方法模式 ###

使用抽象模板类，在模板类中写重试逻辑，重试次数可以交给模板的子类指定。

public abstract class RetryTemplate { 
    
        //默认的重试次数
        private static final int DEFAULT_RETRY_TIME = 3;
    
        //重试次数
        private int retryTime = DEFAULT_RETRY_TIME;
    
        //重试的睡眠时间
        private int sleepTime = 0;
    
    
        public RetryTemplate setSleepTime(int sleepTime) { 
            if(sleepTime <= 0) { 
                throw new IllegalArgumentException("sleepTime should be bigger than 0");
            }
    
            this.sleepTime = sleepTime;
            return this;
        }
    
        public RetryTemplate setRetryTime(int retryTime) { 
            if (retryTime <= 0) { 
                throw new IllegalArgumentException("retryTime should be bigger than 0");
            }
    
            this.retryTime = retryTime;
            return this;
        }
    
        /** * 重试的业务执行代码 * 失败时请抛出一个异常 * * @return */
        protected abstract Object doBiz() throws Exception;
    
    
        public Object execute() throws InterruptedException { 
            for (int i = 0; i < retryTime; i++) { 
                try { 
                    return doBiz();
                } catch (Exception e) { 
                    e.printStackTrace();
                    Thread.sleep(sleepTime);
                }
            }
            return null;
        }
    
        public Object submit(ExecutorService executorService) { 
            if (executorService == null) { 
                throw new IllegalArgumentException("please choose executorService!");
            }
            return executorService.submit((Callable) () -> execute());
        }
    
    }

测试代码

public class RetryTemplateTest { 
        
        public static void main(String[] args) throws Exception { 
            Object ans = new RetryTemplate() { 
                @Override
                protected Object doBiz() throws Exception { 
                    int temp = (int) (Math.random() * 10);
                    System.out.println(temp);
                    if (temp > 3) { 
                        throw new Exception("generate value bigger then 3! need retry");
                    }
                    return temp;
                }
            }.setRetryTime(5).setSleepTime(100).execute();
            System.out.println(ans);
        }
    }

测试结果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Z1emhvbmdtaW4wNQ_size_16_color_FFFFFF_t_70 2]

缺点：对业务代码有入侵，强迫对方继承模板类

### 注解 + AOP ###

@Retention(RetentionPolicy.RUNTIME)
    @Target(value = { ElementType.TYPE, ElementType.METHOD})
    @Documented
    public @interface Retryable { 
    
       /** * 重试条件，默认方法返回false就重试 * @return */
        boolean retryIfResult() default false;
    
        /** * 最大重试次数 * @return */
        int maxAttemptTimes() default 3;
    }

@Component
    public class RetryAbleService { 
    
        /** * 用注解 + AOP的形式，每个服务都可以自定义重试次数及重试条件 * 这里写死返回值为false，查看重试效果 */
         @Retryable(maxAttemptTimes = 5, retryIfResult = false)
        public boolean retryAbleAnnotatedMethod() { 
            System.out.println("retryAbleAnnotatedMethod test");
            return false;
        }
    
    }

切面编写

@Aspect
    @Component
    public class RetryAspect { 
    
        /** * 匹配所有带Retrayable注解修饰的方法 */
        @Pointcut(value = "@annotation(com.cainiao.dms.platform.web.controller.aspect.Retryable)")
        public void retryPointCut() { 
        }
    
        /** * @param joinPoint * @return * @throws Throwable */
        @Around(value = "retryPointCut()")
        public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable { 
            Object[] args = joinPoint.getArgs();
            //Retryable retryable = joinPoint.getTarget().getClass().getAnnotation(Retryable.class);
            Method method = getCurrentMethod(joinPoint);
            Retryable retryable = method.getAnnotation(Retryable.class);
            // 获取最大重试次数
            int maxAttemptTimes = retryable.maxAttemptTimes();
            if (maxAttemptTimes <= 1) { 
                return joinPoint.proceed(args);
            }
            int retryCount = 0;
            //得到什么结果才retry
            boolean retryIfResult = retryable.retryIfResult();
            while (retryCount < maxAttemptTimes) { 
                boolean result = (boolean)joinPoint.proceed(args);
                //得到什么结果才retry
                if (!(retryIfResult == result)) { 
                    return result;
                }
                retryCount++;
            }
            return joinPoint.proceed(args);
        }
    
        private Method getCurrentMethod(ProceedingJoinPoint joinPoint) { 
            try { 
                Signature sig = joinPoint.getSignature();
                MethodSignature msig = (MethodSignature)sig;
                Object target = joinPoint.getTarget();
                return target.getClass().getMethod(msig.getName(), msig.getParameterTypes());
            } catch (NoSuchMethodException e) { 
                throw new RuntimeException(e);
            }
        }
    }

测试代码

@Test
    public void test() { 
        //版本五 用注解 + AOP的形式，每个方法都可以自定义重试次数及重试条件
        System.out.println("--------版本五：用注解 + AOP的形式，每个方法都可以自定义重试次数及重试条件-----");
        retryAbleService.retryAbleAnnotatedMethod();
    }

测试结果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Z1emhvbmdtaW4wNQ_size_16_color_FFFFFF_t_70 3]

采用切面的方式比较清晰，在需要添加重试的方法上添加一个用于重试的自定义注解，然后在切面中实现重试的逻辑，主要的配置参数则根据注解中的选项来初始化。  
优点：真正的无侵入  
缺点：某些方法无法被切面拦截的场景无法覆盖，例如spring-aop无法切私有方法，final方法。直接使用aspecJ则有些小复杂；如果用spring-aop，则只能切被Spring容器管理的bean

### guava-retrying ###

优雅的重试机制要具备的几点特征  
无侵入：这个好理解，不改动当前的业务逻辑，对于需要重试的地方，可以很简单的实现  
可配置：包括重试次数，重试的间隔时间，是否使用异步方式等  
通用性：最好是无改动（或者很小改动）的支持绝大部分的场景，拿过来直接可用

Guava Retrying是谷歌开发的一个灵活方便的重试组件，包含了多种的重试策略，而且扩展起来非常容易。Guava retrying在支持重试次数和重试频度控制基础上，能够兼容支持多个异常或者自定义实体对象的重试源定义，让重试功能有更多的灵活性。Guava retrying也是线程安全的，入口调用逻辑采用的是Java.util.concurrent.Callable的call方法。

使用Guava retrying很简单，引入google的guava包

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

测试代码

@Test
    public void test() { 
    
        Callable<Boolean> task = new Callable<Boolean>() { 
            @Override
            public Boolean call() throws Exception { 
                System.out.println("Callable Task test");
                return false;
            }
        };
    
    	System.out.println("--------版本六：用guava retryer优雅重试-----");
    	//版本六 用guava retryer优雅重试
    	Retryer<Boolean> retryer = RetryerBuilder.<Boolean>newBuilder()
    	    .retryIfResult(Boolean.FALSE::equals)
    	    .retryIfException()
    	    //WaitStrategies.fixedWait(1, TimeUnit.SECONDS)间隔固定时间1秒之后重试
    	    //WaitStrategies.randomWait(3, TimeUnit.SECONDS)间隔随机时间后重试，比如间隔0~3中随机时间后重试。
    	    //WaitStrategies.randomWait(2, TimeUnit.SECONDS, 5, TimeUnit.SECONDS)最小值，最大值之间的随机时间。
    	    //WaitStrategies.incrementingWait增量重试，重试的次数越多，等待时间间隔越长。
    	    //WaitStrategies.fibonacciWait(100, 2, TimeUnit.SECONDS)用斐波那契数列来计算等待时间，而不是指数函数
    	    .withWaitStrategy(WaitStrategies.incrementingWait(200, TimeUnit.MILLISECONDS,500,TimeUnit.MILLISECONDS))
    	    //只重试10次
    	    .withStopStrategy(StopStrategies.stopAfterAttempt(6))
    	    .withRetryListener(new RetryListener() { 
    	        @Override
    	        public <V> void onRetry(Attempt<V> attempt) { 
    	            System.out.println(String.format("第【%s】次调用失败" , attempt.getAttemptNumber()));
    	        }
    	    }).build();
    
        //递增等待时长策略（提供一个初始值和步长，等待时间随重试次数增加而增加）
        try { 
            Boolean result = retryer.call(task);
        } catch (Exception e) { 
            e.printStackTrace();
        }
    }

测试结果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Z1emhvbmdtaW4wNQ_size_16_color_FFFFFF_t_70 4]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Z1emhvbmdtaW4wNQ_size_16_color_FFFFFF_t_70]: /images/20230521/3ea720a3a6da48e7ad35c7ea0c962d30.png
[20200429163909645.png]: /images/20230521/c4e039387e0a4cfab9004de88c5a55aa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Z1emhvbmdtaW4wNQ_size_16_color_FFFFFF_t_70 1]: /images/20230521/4bbfd000015541e3a7c770d95e384a2b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Z1emhvbmdtaW4wNQ_size_16_color_FFFFFF_t_70 2]: /images/20230521/e211bd7e09de441b886b2388a50d2b9e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Z1emhvbmdtaW4wNQ_size_16_color_FFFFFF_t_70 3]: /images/20230521/9d567ef1bacd4566b469a6682edda461.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Z1emhvbmdtaW4wNQ_size_16_color_FFFFFF_t_70 4]: /images/20230521/7c5fb325ccd84a098a19eca44098a4ca.png