Spring Retry重试组件、Guava Retry重试组件

我不是女神ヾ 2023-07-08 16:22 672阅读 0赞

个人看法**：** spring-retry更好。

软硬件环境**：** IntelliJ IDEA、SpringBoot2.2.4.RELEASE。

Spring的Retry组件：

提示**：** spring-retry的使用方式可分为注解式和编码式，注解式采用代理模式依赖于AOP，而编程式则可以直接调用方法。注解式无疑更优雅，但是使用注解式的时候，要注意避免各个AOP执行顺序差异带来的问题，在这个环节的末尾，会简单介绍如何避免这个问题。本文主要介绍的是注解式用法中基础的常用的内容；至于spring-retry的编程式用法、spring-retry的注解式用法的其它内容可详见https://github.com/spring-projects/spring-retry。

准备工作：

  1. 第一步： 在pom.xml中引入依赖。

    1. <!-- spring-retry -->
    2. <dependency>
    3.     <groupId>org.springframework.retry</groupId>
    4.     <artifactId>spring-retry</artifactId>
    5. </dependency>
    7. <!-- aop支持 -->
    8. <dependency>
    9.     <groupId>org.springframework.boot</groupId>
    10.     <artifactId>spring-boot-starter-aop</artifactId>
    11. </dependency>
  2. 第二步： 在某个配置类(如启动类)上，启用@EnableRetry。
    在这里插入图片描述

Spring Retry的编码式使用：

提示：编码式使用spring-retry不是主要内容，这里就简单举个例子就行了。

  1. public Object retryCoding() throws Throwable { 
  2.     /* * spring-retry1.3.x版本开始提供建造者模式支持了，可 * 详见https://github.com/spring-projects/spring-retry */
  3.     RetryTemplate template = new RetryTemplate();
  5.     // 设置重试策略
  6.     SimpleRetryPolicy simpleRetryPolicy = new SimpleRetryPolicy();
  7.     simpleRetryPolicy.setMaxAttempts(5);
  8.     template.setRetryPolicy(simpleRetryPolicy);
  10.     // 执行
  11.     Object result = template.execute(
  12.             new RetryCallback<Object, Throwable>() { 
  13.                 @Override
  14.                 public Object doWithRetry(RetryContext context) throws Throwable { 
  15.                     // 第一次请求，不算重试， 所以第一次请求时，context.getRetryCount()值为0
  16.                     throw new RuntimeException("第" + (context.getRetryCount() + 1) + "次调用失败!");
  17.                 }
  18.             },
  19.             new RecoveryCallback<Object>() { 
  20.                 @Override
  21.                 public Object recover(RetryContext context) throws Exception { 
  22.                     Throwable lastThrowable = context.getLastThrowable();
  23.                     return "走recover逻辑了! \t异常类是" + lastThrowable.getClass().getName()
  24.                             + "\t异常信息是" + lastThrowable.getMessage();
  25.                 }
  26.             });
  27.     System.out.println(result);
  28.     return result;
  29. }

注：1.3.x开始，spring-retry提供建造者模式支持RetryTemplate的创建了。

Spring Retry的注解式使用：

  • @Retryable默认项**：** 默认最多请求3次，默认重试时延迟1000ms再进行请求。

    • 注：重试两次, 加上本身那一次一起3次。
    • 注：默认在所有异常的情况下，都进行重试；若重试的这几次都没有成功，都出现了异常，那么最终抛出的是最后一次重试时出现的异常。

    • 示例：

      1. 被调用的方法：

        1. private int times = 0;
        3. /** * - 默认最多请求3次(注: 重试两次, 加上本身那一次一起3次) * * - 默认在所有异常的情况下，都进行重试; 若重试的这几次都没有成功,都出现了异常, * 那么最终抛出的是最后一次重试时出现的异常 */
        4. @Retryable
        5. public String methodOne() { 
        6.     times++;
        7.     int i = ThreadLocalRandom.current().nextInt(10);
        8.     if (i < 9) { 
        9.         if (times == 3) { 
        10.             throw new IllegalArgumentException("最后一次重试时, 发生了IllegalArgumentException异常");
        11.         }
        12.         throw new RuntimeException("times=" + times + ", 当前i的值为" + i);
        13.     }
        14.     return "在第【" + times + "】次调用时, 调通了!";
        15. }
      2. 测试方法：
        在这里插入图片描述
      3. 程序输出：
        在这里插入图片描述

  • @Retryable的include与exclude**：** 默认最多请求3次，默认重试时延迟1000ms再进行请求。

    • 在尝试次数内：

      • 情况一：如果抛出的是include里面的异常(或其子类异常)，那么仍然会继续重试。
      • 情况二：如果抛出的是include范围外的异常(或其子类异常) 或者 抛出的是exclude里面的异常(或其子类异常), 那么不再继续重试，直接抛出异常。
        注：若抛出的异常即是include里指定的异常的子类，又是exclude里指定的异常的子类,那么判断当前异常是按include走，还是按exclude走，需要根据【更短路径原则】。如下面的methodTwo方法所示， RuntimeException 是 IllegalArgumentException的超类，IllegalArgumentException 又是 NumberFormatException的超类，此时因为IllegalArgumentException离NumberFormatException“路径更短”，所以抛出的NumberFormatException按照IllegalArgumentException算，走include。

    • 示例：

      1. 被调用的方法：

        1. private int times = 0;
        3. /** * - 在尝试次数内， * 1. 如果抛出的是include里面的异常(或其子类异常)，那么仍然会继续重试 * 2. 如果抛出的是include范围外的异常(或其子类异常) 或者 抛出的是 * exclude里面的异常(或其子类异常), 那么不再继续重试，直接抛出异常 * * 注意: 若抛出的异常即是include里指定的异常的子类，又是exclude里指定的异常的子类,那么 * 判断当前异常是按include走，还是按exclude走，需要根据【更短路径原则】。 * 如本例所示, RuntimeException 是 IllegalArgumentException的超类， * IllegalArgumentException 又是 NumberFormatException的超类, * 此时因为IllegalArgumentException离NumberFormatException“路径更短”, * 所以抛出的NumberFormatException按照IllegalArgumentException算,走include。 */
        4. @Retryable(include = { IllegalArgumentException.class}, exclude = { RuntimeException.class})
        5. public String methodTwo() { 
        6.     times++;
        7.     /// if (times == 1) { 
        8.     /// throw new IllegalArgumentException("times=" + times + ", 发生的异常是IllegalArgumentException");
        9.     /// }
        10.     /// if (times == 2) { 
        11.     /// throw new RuntimeException("times=" + times + ", 发生的异常是RuntimeException");
        12.     /// }
        13.     if (times == 1) { 
        14.         throw new NumberFormatException("times=" + times + ", 发生的异常是IllegalArgumentException的子类");
        15.     }
        16.     if (times == 2) { 
        17.         throw new ArithmeticException("times=" + times + ", 发生的异常是RuntimeException的子类");
        18.     }
        19.     return "在第【" + times + "】次调用时, 调通了!";
        20. }
        22. /** * - 在尝试次数内， * 如果抛出的是exclude里面的异常(或其子类异常)，那么不再继续重试，直接抛出异常 * 如果抛出的是include里面的异常(或其子类异常)，那么仍然会继续重试 */
        23. @Retryable(include = { RuntimeException.class}, exclude = { IllegalArgumentException.class})
        24. public String methodTwoAlpha() { 
        25.     times++;
        26.     if (times == 1) { 
        27.         throw new ArithmeticException("times=" + times + ", 发生的异常是RuntimeException的子类");
        28.     }
        29.     if (times == 2) { 
        30.         throw new NumberFormatException("times=" + times + ", 发生的异常是IllegalArgumentException的子类");
        31.     }
        32.     return "在第【" + times + "】次调用时, 调通了!";
        33. }
        35. /** * - 在尝试次数内， * 如果抛出的是include范围外的异常(或其子类异常)，那么不再继续重试，直接抛出异常 * 如果抛出的是include里面的异常(或其子类异常)，那么仍然会继续重试 */
        36. @Retryable(include = { IllegalArgumentException.class})
        37. public String methodTwoBeta() { 
        38.     times++;
        39.     if (times == 1) { 
        40.         throw new NumberFormatException("times=" + times + ", 发生的异常是IllegalArgumentException的子类");
        41.     }
        42.     if (times == 2) { 
        43.         throw new ArithmeticException("times=" + times + ", 发生的异常是RuntimeException的子类");
        44.     }
        45.     return "在第【" + times + "】次调用时, 调通了!";
        46. }
      2. 测试方法：
        在这里插入图片描述
      3. 三个测试方法对应的输出：
        在这里插入图片描述
        在这里插入图片描述在这里插入图片描述

  • @Retryable的maxAttempts**：** maxAttempts用于指定最大尝试次数, 默认值为3。

    • 连本身那一次也会被算在内(若值为5, 那么最多重试4次， 算上本身那一次5次)。

    • 示例：

      1. 被调用的方法：

        1. private int times = 0;
        3. /** * maxAttempts指定最大尝试次数, 默认值为3. * 注:连本身那一次也会被算在内(若值为5, 那么最多重试4次， 算上本身那一次5次) */
        4. @Retryable(maxAttempts = 5)
        5. public String methodThere() { 
        6.     times++;
        7.     if (times < 5) { 
        8.         throw new RuntimeException("times=" + times + ", 发生的异常是RuntimeException");
        9.     }
        10.     return "在第【" + times + "】次调用时, 调通了!";
        11. }
      2. 测试方法：
        在这里插入图片描述
      3. 程序输出：
        在这里插入图片描述

  • @Retryable与@Recover搭配**：**

    • 相关要点一： 我们不妨称被@Retryable标记的方法为目标方法，称被@Recover标记的方法为处理方法。那么处理方法和目标方法必须同时满足：

      1. 处于同一个类下。
      2. 两者的参数类型需要匹配 或 处理方法的参数可以多一个异常接收类(这一异常接收类必须放在第一个参数的位置)。
        注：两者的参数类型匹配即可，形参名可以一样可以不一样。
      3. 返回值类型需要保持一致(或处理方法的返回值类型是目标方法的返回值类型的超类)。
    • 相关要点二： 目标方法在进行完毕retry后，如果仍然抛出异常, 那么会去定位处理方法, 走处理方法的逻辑，定位处理方法的原则是:在同一个类下，寻找和目标方法 具有相同参数类型(P.S.可能会再参数列表首位多一个异常类参数)、相同返回值类型的标记有Recover的方法。
      注：如果存在两个目标方法，他们的参数类型、返回值类型都一样，这时就需要主动指定对应的处理方法了，如:@Retryable(recover = “service1Recover”)。@Retryable注解的recover 属性，在spring-retry1.3.x版本才开始提供。
      注：如果是使用的1.3.x+版本的spring-retry，推荐直接使用@Retryable(recover = "recoverMethodName")指定同类当中的处理方法的方法名。

    • 示例：

      1. 被调用的方法：

        1. import org.springframework.retry.annotation.Recover;
        2. import org.springframework.retry.annotation.Retryable;
        3. import org.springframework.stereotype.Component;
        5. /** * 目标方法:被@Retryable标记的方法 * 处理方法:被@Recover标记的方法 * * 处理方法 和 目标方法 必须满足: * 1. 处于同一个类下 * 2. 两者的参数需要保持一致 或 处理方法的参数可以多一个异常接收类(这一异常接收类必须放在第一个参数的位置) * 注:保持一致指的是参数类型保持一致,形参名可以一样可以不一样 * 3. 返回值类型需要保持一致 (或处理方法的返回值类型是目标方法的返回值类型的超类 ) * * 目标方法在进行完毕retry后，如果仍然抛出异常, 那么会去定位处理方法, 走处理方法的逻辑，定位处理方法的原则是: * - 在同一个类下，寻找和目标方法 具有 * 相同参数类型(P.S.可能会再参数列表首位多一个异常类参数)、 * 相同返回值类型 * 的标记有Recover的方法 * - 如果存在两个目标方法，他们的参数类型、返回值类型都一样， * 这时就需要主动指定对应的处理方法了， * 如:@Retryable(recover = "service1Recover") * * @author JustryDeng * @date 2020/2/25 21:40:11 */
        6. @Component
        7. public class QwerRemoteCall { 
        9.     private int times = 0;
        11.     /// --------------------------------------------------------- @Recover基本测试
        13.     @Retryable
        14.     public String methodFour(Integer a, String b) { 
        15.         times++;
        16.         throw new RuntimeException("times=" + times + ", 发生的异常是RuntimeException");
        17.     }
        19.     @Recover
        20.     private String justryDeng(Throwable th, Integer a, String b) { 
        21.         return "a=" + a + ", b=" + b + "\t" + "异常类是:"
        22.                 + th.getClass().getName() + "， 异常信息是:" + th.getMessage();
        23.     }
  1.                 /// 如果在@Retryable中指明了异常, 那么在@Recover中可以明确的指明是哪一种异常
  2.                 /// @Retryable(RemoteAccessException.class)
  3.                 /// public void service() { 
  4.                 /// // ... do something
  5.                 /// }
  6.                 ///
  7.                 /// @Recover
  8.                 /// public void recover(RemoteAccessException e) { 
  9.                 /// // ... panic
  10.                 /// }
  14.                 /// --------------------------------------------------------- @Retryable指定对应的@Recover方法
  15.                 /// 特别注意: @Retryable注解的recover属性, 在spring-retry的较高版本中才得以支持,
  16.                 /// 在本人使用的1.2.5.RELEASE版本中还暂不支持
  18.                 /// @Retryable(recover = "service1Recover", value = RemoteAccessException.class)
  19.                 /// public void service1(String str1, String str2) { 
  20.                 /// // ... do something
  21.                 /// }
  22.                 ///
  23.                 /// @Retryable(recover = "service2Recover", value = RemoteAccessException.class)
  24.                 /// public void service2(String str1, String str2) { 
  25.                 /// // ... do something
  26.                 /// }
  27.                 ///
  28.                 /// @Recover
  29.                 /// public void service1Recover(RemoteAccessException e, String str1, String str2) { 
  30.                 /// // ... error handling making use of original args if required
  31.                 /// }
  32.                 ///
  33.                 /// @Recover
  34.                 /// public void service2Recover(RemoteAccessException e, String str1, String str2) { 
  35.                 /// // ... error handling making use of original args if required
  36.                 /// }
  38.             }
  39.     2.  测试方法：  
  40.         ![在这里插入图片描述][20200226235330439.png_pic_center]
  41.     3.  程序输出：  
  42.         ![在这里插入图片描述][20200226235350218.png_pic_center]

  • @Retryable的backoff**：** @Retryable注解的backoff属性，可用于指定重试时的退避策略。

    • 相关要点：

      1. @Retryable 或 @Retryable(backoff = @Backoff()), 那么默认延迟 1000ms
        后重试。
      2. @Backoff的delay属性: 延迟多久后,再进行重试。
      3. 如果不想延迟, 那么需要指定@Backoff的value和delay同时为0。
      4. delay与multiplier搭配使用，延迟时间 = delay * (multiplier ^ (n - 1))，其中n为第几次重试， n >= 1, 这里^为次方。
        注：第二次请求，才算第一次重试。

    • 示例：

      1. 被调用的方法：

        1. private int times = 0;
        3. DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("HH:mm:ss");
        5. /** * Backoff用于指定 重试时的退避策略 * - @Retryable 或 @Retryable(backoff = @Backoff()), 那么默认延迟 1000ms后重试 * 注:第一次请求时,是马上进行的,是不会延迟的 * * 效果如: * times=1, 时间是12:02:04 * times=2, 时间是12:02:05 * times=3, 时间是12:02:06 */
        6. @Retryable(backoff = @Backoff())
        7. public String methodFive() { 
        8.     times++;
        9.     System.err.println("times=" + times + ", 时间是" + dateTimeFormatter.format(LocalTime.now()));
        10.     throw new RuntimeException("times=" + times + ", 发生的异常是RuntimeException");
        11. }
        13. /** * - delay: 延迟多久后,再进行重试。 * 注:第一次请求时,是马上进行的,是不会延迟的 * * 效果如: * times=1, 时间是11:46:36 * times=2, 时间是11:46:41 * times=3, 时间是11:46:46 */
        14. @Retryable(backoff = @Backoff(delay = 5000))
        15. public String methodFiveAlpha() { 
        16.     times++;
        17.     System.err.println("times=" + times + ", 时间是" + dateTimeFormatter.format(LocalTime.now()));
        18.     throw new RuntimeException("times=" + times + ", 发生的异常是RuntimeException");
        19. }
        21. /** * 如果不想延迟, 那么需要指定value和delay同时为0 * 注:原因可详见javadoc 或 源码 * * 效果如: * times=1, 时间是12:05:44 * times=2, 时间是12:05:44 * times=3, 时间是12:05:44 */
        22. @Retryable(backoff = @Backoff(value = 0, delay = 0))
        23. public String methodFiveBeta() { 
        24.     times++;
        25.     System.err.println("times=" + times + ", 时间是" + dateTimeFormatter.format(LocalTime.now()));
        26.     throw new RuntimeException("times=" + times + ", 发生的异常是RuntimeException");
        27. }
        29. /** * - delay: 延迟多久后,再进行重试。 * - multiplier: 乘数因子 * * 延迟时间 = delay * (multiplier ^ (n - 1)) , 其中n为第几次重试， n >= 1, 这里 ^ 为次方 * * 注:第一次请求时,是马上进行的,是不会延迟的 * 注:第二次请求时对应第一次重试 * * 效果如: * times=1, 时间是12:09:14 * times=2, 时间是12:09:17 * times=3, 时间是12:09:23 * times=4, 时间是12:09:35 * times=5, 时间是12:09:59 * 可知，延迟时间越来越大，分别是: 3 6 12 24 */
        30. @Retryable(maxAttempts = 5, backoff = @Backoff(delay = 3000, multiplier = 2))
        31. public String methodFiveGamma() { 
        32.     times++;
        33.     System.err.println("times=" + times + ", 时间是" + dateTimeFormatter.format(LocalTime.now()));
        34.     throw new RuntimeException("times=" + times + ", 发生的异常是RuntimeException");
        35. }
      2. 测试方法：
        在这里插入图片描述
      3. 四个测试方法分别输出：
        在这里插入图片描述
        在这里插入图片描述
        在这里插入图片描述
        在这里插入图片描述

使用spring retry注解式时，避免多个AOP代理导致可能出现的问题：

  • 情景说明**：** 就像@Transactional与@CacheEvict标注在同一个方法上、@Transactional与synchronized标注在同一个方法上一样，在并发情况下，会出现问题(会出现什么问题、怎么解决出现的问题可详见《程序员成长笔记(第二部)》相关章节)。如果@Transactional和@Retryable同时标注在了同一个方法上，那是不是也会出问题呢，从原理分析，肯定是会出现问题的，如下面的错误示例。

  • 错误示例**：**

    • 某个service实现如图：
      在这里插入图片描述
    • 调用一次该方法前的表：
      在这里插入图片描述
    • 调用一次该方法后的表：
      在这里插入图片描述 这里只是拿事务AOP与重试AOP举的一个例子，重点是说，在多个AOP同时作用于同一个方法时，应该考虑各个AOP之间的执行顺序问题；更好的办法是尽量避免多个AOP作用于同一个切点。
  • 正确示例(避免方式)**：** 将重试机制那部分代码，单独放在一个类里面，避免多个AOP作用于同一个切点。
    在这里插入图片描述 这个时候，哪怕仍然通过@EnableTransactionManagement(order = Ordered.HIGHEST_PRECEDENCE)把事务的AOP优先级调到了最高，也不会有什么影响了，也不会出现上面错误示例中多条数据的问题了。
    注：避免方式较多(如主动控制各个AOP直接的执行顺序、避免多个AOP作用于同一个切点等)，推荐使用避免多个AOP作用于同一个切点。

Guava的Retry组件：

准备工作：在pom.xml中引入依赖。

  1. <!-- guava retry -->
  2. <dependency>
  3.     <groupId>com.github.rholder</groupId>
  4.     <artifactId>guava-retrying</artifactId>
  5.     <version>2.0.0</version>
  6. </dependency>

Guava Retry的使用：

  1.    比起Spring Retry的使用， Guava Retry的使用方式相对简单，这里仅给出一个简单的使用示例，更多细节可详见[https://github.com/rholder/guava-retrying][https_github.com_rholder_guava-retrying]。

简单使用示例：

  1. import com.github.rholder.retry.RetryException;
  2. import com.github.rholder.retry.Retryer;
  3. import com.github.rholder.retry.RetryerBuilder;
  4. import com.github.rholder.retry.StopStrategies;
  6. import java.io.IOException;
  7. import java.util.Arrays;
  8. import java.util.concurrent.Callable;
  9. import java.util.concurrent.ExecutionException;
  10. import java.util.concurrent.ThreadLocalRandom;
  11. import java.util.zip.DataFormatException;
  13. /** * Guava Retry简单使用示例 * * @author JustryDeng * @date 2020/2/25 21:40:11 */
  14. public class XyzRemoteCall { 
  16.     /** * guava retry组件 使用测试 * * 提示:泛型 对应 要返回的数据的类型。 */
  17.     public static void jd() { 
  18.         // 创建callable, 在call()方法里面编写相关业务逻辑
  19.         Callable<Object[]> callable = new Callable<Object[]>() { 
  20.             int times = 0;
  21.             @Override
  22.             public Object[] call() throws Exception { 
  23.                 // business logic
  24.                 times++;
  25.                 if (times == 1) { 
  26.                     throw new RuntimeException();
  27.                 }
  28.                 if (times ==  2) { 
  29.                     throw new Exception();
  30.                 }
  31.                 // 随机一个数[origin, bound)
  32.                 int randomNum = ThreadLocalRandom.current().nextInt(1, 5);
  33.                 if (randomNum == 1) { 
  34.                     throw new DataFormatException("call()抛出了检查异常DataFormatException");
  35.                 } else if (randomNum == 2) { 
  36.                     throw new IOException("call()抛出了检查异常IOException");
  37.                 } else if (randomNum == 3) { 
  38.                     throw new RuntimeException("call()抛出了运行时异常RuntimeException");
  39.                 }
  40.                 return new Object[]{ "邓沙利文", "亨得帅", "邓二洋", "JustryDeng"};
  41.             }
  42.         };
  44.         // 创建重试器
  45.         Retryer<Object[]> retryer = RetryerBuilder.<Object[]>newBuilder()
  46.                 /* * 指定什么条件下触发重试 * * 注:这里,只要callable中的call方法抛出的异常是Throwable或者 * 是Throwable的子类,那么这里都成立，都会进行重试。 */
  47.                 .retryIfExceptionOfType(Throwable.class)
  48.                 /// .retryIfException()
  49.                 /// .retryIfRuntimeException()
  50.                 /// .retryIfExceptionOfType(@Nonnull Class<? extends Throwable> exceptionClass)
  51.                 /// .retryIfException(@Nonnull Predicate<Throwable> exceptionPredicate)
  52.                 /// .retryIfResult(@Nonnull Predicate<V> resultPredicate)
  54.                 // 设置两次重试之间的阻塞策略(如: 设置线程sleep、设置自旋锁等等)
  55.                 ///.withBlockStrategy()
  56.                 // 设置监听器 (这个监听器可用于监听每次请求的结果信息， 并作相应的逻辑处理。 如: 统计、预警等等)
  57.                 ///.withRetryListener()
  58.                 // 设置延时策略, 每次重试前，都要延时一段时间，然后再发起请求。(第一次请求，是不会被延时的)
  59.                 ///.withWaitStrategy()
  60.                 // 设置停止重试的策略(如:这里设置的是三次请求后, 不再重试)
  61.                 .withStopStrategy(StopStrategies.stopAfterAttempt(3))
  62.                 .build();
  63.         try { 
  64.             Object[] result = retryer.call(callable);
  65.             System.err.println(Arrays.toString(result));
  66.         /* * call()方法抛出的异常会被封装到RetryException或ExecutionException中, 进行抛出 * 所以在这里，可以通过 e.getCause()获取到call()方法实际抛出的异常 */
  67.         } catch (RetryException|ExecutionException e) { 
  68.             System.err.println("call()方法抛出的异常, 实际是" + e.getCause());
  69.             e.printStackTrace();
  70.         }
  71.     }
  72. }

Spring Retry重试组件、Guava Retry重试组件简单梳理完毕 ！

^_^ 如有不当之处，欢迎指正

^_^ 参考连接
https://github.com/spring-projects/spring-retry

https://github.com/rholder/guava-retrying

^_^ 测试代码托管连接
https://github.com/JustryDeng/CommonRepository…

^_^ 本文已经被收录进《程序员成长笔记》 ，笔者JustryDeng

发表评论

表情：
评论列表 （有 0 条评论，672人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Spring Retry重试机制

    在调用第三方接口或者使用mq时，会出现网络抖动，连接超时等网络异常，所以需要重试。为了使处理更加健壮并且不太容易出现故障，后续的尝试操作，有时候会帮助失败的操作最后执行成功。例

    深藏阁楼爱情的钟深藏阁楼爱情的钟/ 0 赞/ 590 阅读