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

最新推荐文章于 2024-08-17 16:20:53 发布
最新推荐文章于 2024-08-17 16:20:53 发布
阅读量2.8k 收藏 8
点赞数 1
分类专栏： Java知识大杂烩 文章标签： spring-retry guava-retry 重试机制 java重试组件 重试组件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/justry_deng/article/details/104527600
版权

个人看法： 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中引入依赖。

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

<!-- aop支持 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

  2. 第二步： 在某个配置类(如启动类)上，启用@EnableRetry。
    在这里插入图片描述

Spring Retry的编码式使用：

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

public Object retryCoding() throws Throwable {
    /*
     * spring-retry1.3.x版本开始提供建造者模式支持了，可
     * 详见https://github.com/spring-projects/spring-retry
     */
    RetryTemplate template = new RetryTemplate();

    // 设置重试策略
    SimpleRetryPolicy simpleRetryPolicy = new SimpleRetryPolicy();
    simpleRetryPolicy.setMaxAttempts(5);
    template.setRetryPolicy(simpleRetryPolicy);

    // 执行
    Object result = template.execute(
            new RetryCallback<Object, Throwable>() {
                @Override
                public Object doWithRetry(RetryContext context) throws Throwable {
                    // 第一次请求，不算重试， 所以第一次请求时，context.getRetryCount()值为0
                    throw new RuntimeException("第" + (context.getRetryCount() + 1) + "次调用失败!");
                }
            },
            new RecoveryCallback<Object>() {
                @Override
                public Object recover(RetryContext context) throws Exception {
                    Throwable lastThrowable = context.getLastThrowable();
                    return "走recover逻辑了! \t异常类是" + lastThrowable.getClass().getName()
                            + "\t异常信息是" + lastThrowable.getMessage();
                }
            });
    System.out.println(result);
    return result;
}

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

Spring Retry的注解式使用：

  • @Retryable默认项： 默认最多请求3次，默认重试时延迟1000ms再进行请求。
    • 注：重试两次, 加上本身那一次一起3次。
    • 注：默认在所有异常的情况下，都进行重试；若重试的这几次都没有成功，都出现了异常，那么最终抛出的是最后一次重试时出现的异常。
    • 示例：
      1. 被调用的方法：
        private int times = 0;

/**
 * - 默认最多请求3次(注: 重试两次, 加上本身那一次一起3次)
 *
 * - 默认在所有异常的情况下，都进行重试; 若重试的这几次都没有成功,都出现了异常,
 *   那么最终抛出的是最后一次重试时出现的异常
 */
@Retryable
public String methodOne() {
    times++;
    int i = ThreadLocalRandom.current().nextInt(10);
    if (i < 9) {
        if (times == 3) {
            throw new IllegalArgumentException("最后一次重试时, 发生了IllegalArgumentException异常");
        }
        throw new RuntimeException("times=" + times + ", 当前i的值为" + i);
    }
    return "在第【" + times + "】次调用时, 调通了!";
}
      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. 被调用的方法：
        private int times = 0;

/**
 * - 在尝试次数内，
 *      1. 如果抛出的是include里面的异常(或其子类异常)，那么仍然会继续重试
 *      2. 如果抛出的是include范围外的异常(或其子类异常)  或者 抛出的是
 *         exclude里面的异常(或其子类异常), 那么不再继续重试，直接抛出异常
 *
 *      注意: 若抛出的异常即是include里指定的异常的子类，又是exclude里指定的异常的子类,那么
 *            判断当前异常是按include走，还是按exclude走，需要根据【更短路径原则】。
 *            如本例所示, RuntimeException 是 IllegalArgumentException的超类，
 *                      IllegalArgumentException 又是 NumberFormatException的超类,
 *                      此时因为IllegalArgumentException离NumberFormatException“路径更短”,
 *                      所以抛出的NumberFormatException按照IllegalArgumentException算,走include。
 */
@Retryable(include = {IllegalArgumentException.class}, exclude = {RuntimeException.class})
public String methodTwo() {
    times++;
    /// if (times == 1) {
    ///     throw new IllegalArgumentException("times=" + times + ", 发生的异常是IllegalArgumentException");
    /// }
    /// if (times == 2) {
    ///     throw new RuntimeException("times=" + times + ", 发生的异常是RuntimeException");
    /// }
    if (times == 1) {
        throw new NumberFormatException("times=" + times + ", 发生的异常是IllegalArgumentException的子类");
    }
    if (times == 2) {
        throw new ArithmeticException("times=" + times + ", 发生的异常是RuntimeException的子类");
    }
    return "在第【" + times + "】次调用时, 调通了!";
}

/**
 * - 在尝试次数内，
 *      如果抛出的是exclude里面的异常(或其子类异常)，那么不再继续重试，直接抛出异常
 *      如果抛出的是include里面的异常(或其子类异常)，那么仍然会继续重试
 */
@Retryable(include = {RuntimeException.class}, exclude = {IllegalArgumentException.class})
public String methodTwoAlpha() {
    times++;
    if (times == 1) {
        throw new ArithmeticException("times=" + times + ", 发生的异常是RuntimeException的子类");
    }
    if (times == 2) {
        throw new NumberFormatException("times=" + times + ", 发生的异常是IllegalArgumentException的子类");
    }
    return "在第【" + times + "】次调用时, 调通了!";
}

/**
 * - 在尝试次数内，
 *      如果抛出的是include范围外的异常(或其子类异常)，那么不再继续重试，直接抛出异常
 *      如果抛出的是include里面的异常(或其子类异常)，那么仍然会继续重试
 */
@Retryable(include = {IllegalArgumentException.class})
public String methodTwoBeta() {
    times++;
    if (times == 1) {
        throw new NumberFormatException("times=" + times + ", 发生的异常是IllegalArgumentException的子类");
    }
    if (times == 2) {
        throw new ArithmeticException("times=" + times + ", 发生的异常是RuntimeException的子类");
    }
    return "在第【" + times + "】次调用时, 调通了!";
}
      2. 测试方法：
        在这里插入图片描述
      3. 三个测试方法对应的输出：
        在这里插入图片描述
        在这里插入图片描述在这里插入图片描述
  • @Retryable的maxAttempts： maxAttempts用于指定最大尝试次数, 默认值为3。
    • 连本身那一次也会被算在内(若值为5, 那么最多重试4次， 算上本身那一次5次)。
    • 示例：
      1. 被调用的方法：
        private int times = 0;

/**
 * maxAttempts指定最大尝试次数, 默认值为3.
 * 注:连本身那一次也会被算在内(若值为5, 那么最多重试4次， 算上本身那一次5次)
 */
@Retryable(maxAttempts = 5)
public String methodThere() {
    times++;
    if (times < 5) {
        throw new RuntimeException("times=" + times + ", 发生的异常是RuntimeException");
    }
    return "在第【" + times + "】次调用时, 调通了!";
}
      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. 被调用的方法：
        import org.springframework.retry.annotation.Recover;
import org.springframework.retry.annotation.Retryable;
import org.springframework.stereotype.Component;

/**
 * 目标方法:被@Retryable标记的方法
 * 处理方法:被@Recover标记的方法
 *
 * 处理方法 和 目标方法 必须满足:
 *    1. 处于同一个类下
 *    2. 两者的参数需要保持一致  或  处理方法的参数可以多一个异常接收类(这一异常接收类必须放在第一个参数的位置)
 *       注:保持一致指的是参数类型保持一致,形参名可以一样可以不一样
 *    3. 返回值类型需要保持一致 (或处理方法的返回值类型是目标方法的返回值类型的超类 )
 *
 * 目标方法在进行完毕retry后，如果仍然抛出异常, 那么会去定位处理方法, 走处理方法的逻辑，定位处理方法的原则是:
 * - 在同一个类下，寻找和目标方法 具有
 *      相同参数类型(P.S.可能会再参数列表首位多一个异常类参数)、
 *      相同返回值类型
 *      的标记有Recover的方法
 * - 如果存在两个目标方法，他们的参数类型、返回值类型都一样，
 *     这时就需要主动指定对应的处理方法了，
 *     如:@Retryable(recover = "service1Recover")
 *
 * @author JustryDeng
 * @date 2020/2/25 21:40:11
 */
@Component
public class QwerRemoteCall {

    private int times = 0;

    /// --------------------------------------------------------- @Recover基本测试

    @Retryable
    public String methodFour(Integer a, String b) {
        times++;
        throw new RuntimeException("times=" + times + ", 发生的异常是RuntimeException");
    }

    @Recover
    private String justryDeng(Throwable th, Integer a, String b) {
        return "a=" + a + ", b=" + b + "\t" + "异常类是:"
                + th.getClass().getName() + "， 异常信息是:" + th.getMessage();
    }


    ///  如果在@Retryable中指明了异常, 那么在@Recover中可以明确的指明是哪一种异常
    /// @Retryable(RemoteAccessException.class)
    /// public void service() {
    ///     // ... do something
    /// }
    ///
    /// @Recover
    /// public void recover(RemoteAccessException e) {
    ///     // ... panic
    /// }



    /// --------------------------------------------------------- @Retryable指定对应的@Recover方法
    /// 特别注意: @Retryable注解的recover属性, 在spring-retry的较高版本中才得以支持,
    ///          在本人使用的1.2.5.RELEASE版本中还暂不支持

    /// @Retryable(recover = "service1Recover", value = RemoteAccessException.class)
    /// public void service1(String str1, String str2) {
    ///     // ... do something
    /// }
    ///
    /// @Retryable(recover = "service2Recover", value = RemoteAccessException.class)
    /// public void service2(String str1, String str2) {
    ///     // ... do something
    /// }
    ///
    /// @Recover
    /// public void service1Recover(RemoteAccessException e, String str1, String str2) {
    ///     // ... error handling making use of original args if required
    /// }
    ///
    /// @Recover
    /// public void service2Recover(RemoteAccessException e, String str1, String str2) {
    ///     // ... error handling making use of original args if required
    /// }

}
      2. 测试方法：
        在这里插入图片描述
      3. 程序输出：
        在这里插入图片描述
  • @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. 被调用的方法：
        private int times = 0;

DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("HH:mm:ss");

/**
 * Backoff用于指定 重试时的退避策略
 * - @Retryable 或 @Retryable(backoff = @Backoff()), 那么默认延迟 1000ms后重试
 *   注:第一次请求时,是马上进行的,是不会延迟的
 *
 *    效果如:
 *       times=1, 时间是12:02:04
 *       times=2, 时间是12:02:05
 *       times=3, 时间是12:02:06
 */
@Retryable(backoff = @Backoff())
public String methodFive() {
    times++;
    System.err.println("times=" + times + ", 时间是" + dateTimeFormatter.format(LocalTime.now()));
    throw new RuntimeException("times=" + times + ", 发生的异常是RuntimeException");
}

/**
 * - delay: 延迟多久后,再进行重试。
 *   注:第一次请求时,是马上进行的,是不会延迟的
 *
 *    效果如:
 *       times=1, 时间是11:46:36
 *       times=2, 时间是11:46:41
 *       times=3, 时间是11:46:46
 */
@Retryable(backoff = @Backoff(delay = 5000))
public String methodFiveAlpha() {
    times++;
    System.err.println("times=" + times + ", 时间是" + dateTimeFormatter.format(LocalTime.now()));
    throw new RuntimeException("times=" + times + ", 发生的异常是RuntimeException");
}

/**
 * 如果不想延迟, 那么需要指定value和delay同时为0
 * 注:原因可详见javadoc 或 源码
 *
 *    效果如:
 *       times=1, 时间是12:05:44
 *       times=2, 时间是12:05:44
 *       times=3, 时间是12:05:44
 */
@Retryable(backoff = @Backoff(value = 0, delay = 0))
public String methodFiveBeta() {
    times++;
    System.err.println("times=" + times + ", 时间是" + dateTimeFormatter.format(LocalTime.now()));
    throw new RuntimeException("times=" + times + ", 发生的异常是RuntimeException");
}

/**
 * - 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
 */
@Retryable(maxAttempts = 5, backoff = @Backoff(delay = 3000, multiplier = 2))
public String methodFiveGamma() {
    times++;
    System.err.println("times=" + times + ", 时间是" + dateTimeFormatter.format(LocalTime.now()));
    throw new RuntimeException("times=" + times + ", 发生的异常是RuntimeException");
}
      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中引入依赖。

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

Guava Retry的使用：

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

简单使用示例：

import com.github.rholder.retry.RetryException;
import com.github.rholder.retry.Retryer;
import com.github.rholder.retry.RetryerBuilder;
import com.github.rholder.retry.StopStrategies;

import java.io.IOException;
import java.util.Arrays;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ThreadLocalRandom;
import java.util.zip.DataFormatException;

/**
 * Guava Retry简单使用示例
 *
 * @author JustryDeng
 * @date 2020/2/25 21:40:11
 */
public class XyzRemoteCall {

    /**
     * guava retry组件 使用测试
     *
     * 提示:泛型 对应 要返回的数据的类型。
     */
    public static void jd() {
        // 创建callable, 在call()方法里面编写相关业务逻辑
        Callable<Object[]> callable = new Callable<Object[]>() {
            int times = 0;
            @Override
            public Object[] call() throws Exception {
                // business logic
                times++;
                if (times == 1) {
                    throw new RuntimeException();
                }
                if (times ==  2) {
                    throw new Exception();
                }
                // 随机一个数[origin, bound)
                int randomNum = ThreadLocalRandom.current().nextInt(1, 5);
                if (randomNum == 1) {
                    throw new DataFormatException("call()抛出了检查异常DataFormatException");
                } else if (randomNum == 2) {
                    throw new IOException("call()抛出了检查异常IOException");
                } else if (randomNum == 3) {
                    throw new RuntimeException("call()抛出了运行时异常RuntimeException");
                }
                return new Object[]{"邓沙利文", "亨得帅", "邓二洋", "JustryDeng"};
            }
        };

        // 创建重试器
        Retryer<Object[]> retryer = RetryerBuilder.<Object[]>newBuilder()
                /*
                 * 指定什么条件下触发重试
                 *
                 * 注:这里,只要callable中的call方法抛出的异常是Throwable或者
                 *    是Throwable的子类,那么这里都成立，都会进行重试。
                 */
                .retryIfExceptionOfType(Throwable.class)
                /// .retryIfException()
                /// .retryIfRuntimeException()
                /// .retryIfExceptionOfType(@Nonnull Class<? extends Throwable> exceptionClass)
                /// .retryIfException(@Nonnull Predicate<Throwable> exceptionPredicate)
                /// .retryIfResult(@Nonnull Predicate<V> resultPredicate)

                // 设置两次重试之间的阻塞策略(如: 设置线程sleep、设置自旋锁等等)
                ///.withBlockStrategy()
                // 设置监听器 (这个监听器可用于监听每次请求的结果信息， 并作相应的逻辑处理。 如: 统计、预警等等)
                ///.withRetryListener()
                // 设置延时策略, 每次重试前，都要延时一段时间，然后再发起请求。(第一次请求，是不会被延时的)
                ///.withWaitStrategy()
                // 设置停止重试的策略(如:这里设置的是三次请求后, 不再重试)
                .withStopStrategy(StopStrategies.stopAfterAttempt(3))
                .build();
        try {
            Object[] result = retryer.call(callable);
            System.err.println(Arrays.toString(result));
        /*
         * call()方法抛出的异常会被封装到RetryException或ExecutionException中, 进行抛出
         * 所以在这里，可以通过 e.getCause()获取到call()方法实际抛出的异常
         */
        } catch (RetryException|ExecutionException e) {
            System.err.println("call()方法抛出的异常, 实际是" + e.getCause());
            e.printStackTrace();
        }
    }
}

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


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

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

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

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

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

justry_deng
关注
专栏目录
重试次数配置_SpringBoot系列（21）：基于Guava_Retrying机制实现重试功能
weixin_28720573的博客
01-05 546
对于“接口/方法 重试”，相信很多小伙伴都听说过，但是在实际项目中却很少真正去实践过，在本篇文章中，Debug将给各位小伙伴介绍一种“重试”机制的实现，即Guava_Retrying，相对于传统的Spring_Retrying或者动态代理实现的重试功能而言，本文要介绍的Guava_Retrying机制使用起来将更加容易、灵活性更强！老赵：“这个 接口/方法 调用又失败了，老李啊，你去写个重试功能吧...
如何在业务逻辑中引入重试机制：spring-Retry和Guava-Retry
Java Punk
08-02 623
Spring-Retry 和 Guava-Retry 工具都是线程安全的重试，能够支持并发业务场景的重试逻辑正确性,但是，明显感觉得到 Guava-Retry 在使用上更便捷，更灵活。
Spring-Retry 和 Guava-Retry
xinyuan的专栏
12-29 170
Spring-Retry 和 Guava-Retry
重试框架SpringRetry一篇搞定！！！
最新发布
m0_65450831的博客
08-17 773
本文将重试框架如何在项目中使用以及注意事项讲的一清二楚
Spring-retry重试组件
西魏陶渊明的博客
03-24 405
# 一、简介 Spring-retry 前面我们了解到了,Guava的重试组件,我们可以基于Guava的能力,来封装我们需要的能力来满足我们的业务。今天来分享Spring-Retry重试组件。当然Spring只是帮我们封装好了，如果你不想自定义 重试组件，那么我们可以直接使用Spring的能力来实现。 API 也是非常的简单，几个注解就可以搞定。 (opens new window) # 二、...
Springboot 使用 Guava 的重试Retry ，轻便灵活，linuxbsp开发面试
m0_64205765的博客
11-16 335
增长式等待秒数重试等 **4.**到达重试多少次数后停止； 不停止，一直重试； 一定时间内，一直重试，然后再停止； **5.**重试监听器，每次重试调用监听器里面的方法（可以多个，按照顺序调用） 下面我们来实战一下，写点代码熟悉一下： 1.pom.xml文件引入相关jar： <groupId>com.github.rholder</groupId> <artifactId>guava-retrying</artifactId> <ve
spring retry, guava retrying比较
qq_29664475的博客
11-08 350
spring retry, guava retrying比较
重试框架spring-retry以及guava-retry的使用
08-14
本文将深入探讨两个常用的重试框架：Spring Retry和Guava Retry，并通过一个名为`retry-starter`的Spring Boot项目实例，来解析它们的使用方式以及差异。 首先，我们来看Spring Retry。Spring Retry是Spring框架的...
Spring Retry 和 Guava Retrying重试机制的使用详解
03-18
Spring Retry 和 Guava Retrying 是两个常用且功能强大的重试库，它们为开发者提供了优雅且高效的重试解决方案。 首先，我们来详细了解Spring Retry。Spring Retry是Spring框架的一部分，它提供了一种声明式的重试...
springboot基于spring-retry实现重试机制
03-15
本文将详细探讨如何在 Spring Boot 应用中基于 Spring Retry 实现重试机制，以及如何将其应用于支付回调和自定义重试场景。 首先，让我们了解 Spring Retry 的核心概念。Spring Retry 提供了一个 `@Retryable` 注解...
Springboot-Guava retrying接口重试
孟孟的博客
10-10 939
一般在各种业务场景中，为了保持系统稳定，我们都会有相应的重试机制，某个接口某个数据库链接由于网络抖动或者其他因素导致响应失败。Guava-retrying或者分析过其源码你会发现,guava-retrying重试组件特别轻量级,核心类就那几个,并且使用简单设计优雅,但是它也存在缺点。
smart-retry:Smart Retry主要是用来进行任务重试的。和Guava Retry、Spring Retry相比，Smart Retry最大的特点是异步重试，支持持久化，系统重启之后可以继续重试
05-10
Smart Retry Smart Retry主要是用来进行方法重试的。和Guava Retry、Spring Retry相比，Smart Retry最大的特点是异步重试，支持持久化，系统重启之后可以继续重试。 背景 在微服务环境下，会根据不同的业务将拆分成不同的服务，比如会员服务、订单服务、商品服务等等，每个服务都会和其他服务进行交互，根据交互的结果来更新自己服务的数据。在交互的过程中，往往会因为网络原因、对方服务的中断或更新重启导致交互失败，在这种情况下，要保证各个服务数据的一致性就必须要进行重试。市面上开源的重试框架有很多，如Guava Retry、Spring Retry等都支持重试，但是他们都不支持任务的持久化，系统更新重启，重试任务就会丢失，这无法保证数据的一致性。传统的做法是写一个定时任务，定时补偿。但这样会增加工作量，增加很多冗余的代码。Smart Retry在这种背景下应
Guava-retry重试组件
西魏陶渊明的博客
03-24 431
# 一、简介 Guava-retry Guava 是一组来自 Google 的核心 Java 库，其中包括新的集合类型(例如 multimap 和 multiset)、不可变集合、图形库以及用于并发、I/O、散列、缓存、原语、字符串等的实用程序！它广泛用于 Google 内部的大多数 Java 项目，也被许多其他公司广泛使用。 API 非常的简单，我们可以非常轻松的使用，来封装成我们业务中自己的组...
springboot重试策略
留白
12-17 234
前言 在我们日常开发中...
重试利器之Guava Retrying
weixin_34268753的博客
02-28 614
目录 重试的使用场景 如何优雅地设计重试实现 guava-retrying基础用法 guava-retrying实现原理 guava-retrying高级用法 使用中遇到的问题 Guava版本冲突 动态调节重试策略 重试的使用场景 在很多业务场景中，为了排除系统中的各种不稳定因素，以及逻辑上的错误，并最大概率保证获得预期的结果，重试机制都是必不可少的。 尤其是调用远程服务，在高...
SpringBoot系列(21)：基于Guava_Retrying机制实现重试功能
qq_44601070的博客
11-10 278
摘要： 对于“接口/方法 重试”，相信很多小伙伴都听说过，但是在实际项目中却很少真正去实践过，在本篇文章中，Debug将给各位小伙伴介绍一种“重试”机制的实现，即Guava_Retrying，相对于传统的Spring_Retrying或者动态代理实现的重试功能而言，本文要介绍的Guava_Retrying机制使用起来将更加容易、灵活性更强！ 内容： 老赵：“这个 接口/方法 调用又失败了，老李啊，你去写个重试功能吧！”。 老李：“他娘的，这接口调用咋又不行了。。。行吧，老子立马给你撸一个重试功能”
重试框架入门：Spring-Retry&Guava-Retry
雅俗共赏的博客
08-09 1533
重试框架入门：Spring-Retry和Guava-Retry
重试机制（Guava Retry）和（spring-retry）、观察者模式、内部消费者生产者工具
点点的博客
02-03 1299
声明：详情请参考注释 一、重试机制（Guava Retry）和（spring-retry） import com.github.rholder.retry.*; import lombok.extern.slf4j.Slf4j; import org.springframework.remoting.RemoteAccessException; import org.springframework.retry.annotation.Backoff; import org.springframework.re
重试机制：Guava Retrying与spring-retry
yubin1285570923的博客
05-17 1427
一、重试的使用场景 在很多业务场景中，为了排除系统中的各种不稳定因素，以及逻辑上的错误，并最大概率保证获得预期的结果，重试机制都是必不可少的。尤其是调用远程服务，在高并发场景下，很可能因为服务器响应延迟或者网络原因，造成我们得不到想要的结果，或者根本得不到响应。这个时候，一个优雅的重试调用机制，可以让我们更大概率保证得到预期的响应。 ...
Spring-Retry与Guava Retrying：重试机制实战解析
本文主要介绍了在分布式系统中如何利用Spring Retry和Guava Retrying这两个库来实现重试机制，以增强系统的健壮性。这两种工具都提供了声明式的方法来处理因网络不稳定、服务不可用等问题导致的调用失败。 ### ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值