运维开发网

SpringRetry重试框架的具体使用

运维开发网 https://www.qedev.com 2021-07-26 10:45 出处:网络 作者: TianXinCoord
目录一、环境搭建二、RetryTemplate2.1 RetryTemplate2.2 RetryListener2.3 回退策略2.3.1 FixedBackOffPolicy2.3.2 ExponentialBackOffPolicy2.4 重试策略2.5 RetryCallback2.6 核心使用三、EnableRetry四、Retryab
目录
  • 一、环境搭建
  • 二、RetryTemplate

    • 2.1 RetryTemplate
    • 2.2 RetryListener
    • 2.3 回退策略

      • 2.3.1 FixedBackOffPolicy
      • 2.3.2 ExponentialBackOffPolicy
    • 2.4 重试策略
      • 2.5 RetryCallback
        • 2.6 核心使用
        • 三、EnableRetry
          • 四、Retryable

            spring retry主要实现了重试和熔断。

            不适合重试的场景:

            参数校验不合法、写操作等(要考虑写是否幂等)都不适合重试。

            适合重试的场景:

            远程调用超时、网络突然中断等可以重试。

            在spring retry中可以指定需要重试的异常类型,并设置每次重试的间隔以及如果重试失败是继续重试还是熔断(停止重试)。

            一、环境搭建

            加入SpringRetry依赖,SpringRetry使用AOP实现,所以也需要加入AOP包

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

            官方文档

            二、RetryTemplate

            2.1 RetryTemplate

            • RetryTemplate封装了Retry基本操作
              • org.springframework.retry.support.RetryTemplate
            • RetryTemplate中可以指定监听、回退策略、重试策略等
            • 只需要正常new RetryTemplate()即可使用

            2.2 RetryListener

            RetryListener指定了当执行过程中出现错误时的回调

            org.springframework.retry.RetryListener

            package org.springframework.retry;
            
            public interface RetryListener {
            
             /**
              * 任务开始执行时调用,只调用一次
              */
             <T, E extends Throwable> boolean open(RetryContext context, RetryCallback<T, E> callback);
            
             /**
              * 任务执行结束时(包含重试)调用,只调用一次
              */
             <T, E extends Throwable> void close(RetryContext context, RetryCallback<T, E> callback, Throwable throwable);
            
             /**
              * 出现错误时回调
              */
             <T, E extends Throwable> void onError(RetryContext context, RetryCallback<T, E> callback, Throwable throwable);
            }
            
            

            配置之后在RetryTemplate中指定

            2.3 回退策略

            2.3.1 FixedBackOffPolicy

            当出现错误时延迟多少时间继续调用

            FixedBackOffPolicy fixedBackOffPolicy = new FixedBackOffPolicy();
            fixedBackOffPolicy.setBackOffPeriod(1000L);
            retryTemplate.setBackOffPolicy(fixedBackOffPolicy);

            配置之后在RetryTemplate中指定

            2.3.2 ExponentialBackOffPolicy

            当出现错误时第一次按照指定延迟时间延迟后按照指数进行延迟

            // 指数回退(秒),第一次回退1s,第二次回退2s,第三次4秒,第四次8秒
            ExponentialBackOffPolicy exponentialBackOffPolicy = new ExponentialBackOffPolicy();
            exponentialBackOffPolicy.setInitialInterval(1000L);
            exponentialBackOffPolicy.setMultiplier(2);
            retryTemplate.setBackOffPolicy(exponentialBackOffPolicy);

            配置之后在RetryTemplate中指定

            2.4 重试策略

            重试策略主要指定出现错误时重试次数

            // 重试策略
            SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy();
            retryPolicy.setMaxAttempts(5);
            retryTemplate.setRetryPolicy(retryPolicy);
            
            

            配置之后在RetryTemplate中指定

            2.5 RetryCallback

            RetryCallback为retryTemplate.execute时执行的回调

            public final <T, E extends Throwable> T execute(RetryCallback<T, E> retryCallback) throws E
            
            

            SpringRetry重试框架的具体使用

            2.6 核心使用

            可以使用RetryTemplate完成简单使用

            配置retryTemplate

            • 指定回退策略为ExponentialBackOffPolicy
            • 指定重试策略为SimpleRetryPolicy
            • 指定监听器RetryListener
            import com.codecoord.util.PrintUtil;
            import org.springframework.context.annotation.Bean;
            import org.springframework.context.annotation.Configuration;
            import org.springframework.retry.RetryCallback;
            import org.springframework.retry.RetryContext;
            import org.springframework.retry.RetryListener;
            import org.springframework.retry.backoff.ExponentialBackOffPolicy;
            import org.springframework.retry.policy.SimpleRetryPolicy;
            import org.springframework.retry.support.RetryTemplate;
            
            @Configuration
            public class RetryTemplateConfig {
            
                /**
                 * 注入retryTemplate
                 */
                @Bean
                public RetryTemplate retryTemplate() {
                    RetryTemplate retryTemplate = new RetryTemplate();
            
                    /// 回退固定时间(秒)
                   /* FixedBackOffPolicy fixedBackOffPolicy = new FixedBackOffPolicy();
                    fixedBackOffPolicy.setBackOffPeriod(1000L);
                    retryTemplate.setBackOffPolicy(fixedBackOffPolicy);*/
            
                    // 指数回退(秒),第一次回退1s,第二次回退2s
                    ExponentialBackOffPolicy exponentialBackOffPolicy = new ExponentialBackOffPolicy();
                    exponentialBackOffPolicy.setInitialInterval(1000L);
                    exponentialBackOffPolicy.setMultiplier(2);
                    retryTemplate.setBackOffPolicy(exponentialBackOffPolicy);
            
                    // 重试策略
                    SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy();
                    retryPolicy.setMaxAttempts(5);
                    retryTemplate.setRetryPolicy(retryPolicy);
            
                    // 设置监听器,open和close分别在启动和结束时执行一次
                    RetryListener[] listeners = {
                            new RetryListener() {
                                @Override
                                public <T, E extends Throwable> boolean open(RetryContext context, RetryCallback<T, E> callback) {
                                    PrintUtil.print("open");
                                    return true;
                                }
                                @Override
                                public <T, E extends Throwable> void close(RetryContext context, RetryCallback<T, E> callback,
                                        Throwable throwable) {
                                    PrintUtil.print("close");
                                }
                                @Override
                                public <T, E extends Throwable> void onError(RetryContext context, RetryCallback<T, E> callback,
                                        Throwable throwable) {
                                    PrintUtil.print("onError");
                                }
                            }
                    };
                    retryTemplate.setListeners(listeners);
            
                    return retryTemplate;
                }
            }

            在controller中注入RetryTemplate使用,也可以是在service中

            @RestController
            public class SpringRetryController {
                @Resource
                private RetryTemplate retryTemplate;
                private static int count = 0;
            
                @RequestMapping("/retry")
                public Object retry() {
                    try {
                        count = 0;
                        retryTemplate.execute((RetryCallback<Void, RuntimeException>) context -> {
                            // 业务代码
                            // ....
                            // 模拟抛出异常
                            ++count;
                            throw new RuntimeException("抛出异常");
                        });
                    } catch (RuntimeException e) {
                        System.out.println("Exception");
                    }
            
                    return "retry = " + count;
                }
            }

            访问retry接口,然后观察日志输出

            18:27:20.648 - http-nio-8888-exec-1 - open

            18:27:20.649 - http-nio-8888-exec-1 - retryTemplate.execute执行

            18:27:20.649 - http-nio-8888-exec-1 - onError

            18:27:21.658 - http-nio-8888-exec-1 - retryTemplate.execute执行

            18:27:21.658 - http-nio-8888-exec-1 - onError

            18:27:23.670 - http-nio-8888-exec-1 - retryTemplate.execute执行

            18:27:23.670 - http-nio-8888-exec-1 - onError

            18:27:27.679 - http-nio-8888-exec-1 - retryTemplate.execute执行

            18:27:27.679 - http-nio-8888-exec-1 - onE编程客栈rror

            18:27:35.681 - http-nio-8888-exec-1 - retryTemplate.execute执行

            18:27:35.681 - http-nio-8888-exec-1 - onError

            18:27:35.681 - http-nio-8888-exec-1 - close

            三、EnableRetry

            @EnableRetry开启重试,在类上指定的时候方法将默认执行,重试三次

            定义service,开启@EnableRetry注解和指定@Retryable,重试可以参考后面一节

            import org.springframework.retry.annotation.Retryable;
            
            public interface RetryService {
            
                /**
                 * 重试方法调用
                 */
                @Retryable
                void retryServiceCall();
            }
            
            
            import org.springframework.retry.annotation.EnableRetry;
            import org.springframework.stereotype.Service;
            
            @EnableRetry
            @Service
            public class RetryServiceImpl implements RetryService {
            
                @Override
                public void retryServiceCall() {
                    PrintUtil.print("方法调用..");
                    throw new RuntimeException("手工异常");
                }
            }

            controller中注入service

            @RequestMapping("/retryAnnotation")
            public Object retryAnnotation() {
                retryService.retryServiceCall();
                return "retryAnnotation";
            }
            
            

            将会默认重试

            18:46:48.721 - http-nio-8888-exec-1 - 方法调用..

            18:46:49.724 - http-nio-8888-exec-1 - 方法调用..

            18:46:50.730 - http-nio-8888-exec-1 - 方法调用..

            java.lang.RuntimeException: 手工异常

            四、Retryable

            用于需要重试的方法上的注解

            有以下几个属性

            Retryable注解参数

            • value:指定发生的异常进行重试
            • include:和value一样,默认空,当exclude也为空时,所有异常都重试
            • exclude:指定异常不重试,默认空,当include也为空时,所有异常都重试
            • maxAttemps:重试次数,默认3
            • backoff:重试补偿机制,默认没有

            @Backoff  注解 重试补偿策略

            • 不设置参数时,默认使用FixedBackOffPolicy(指定等待时间),重试等待1000ms
            • 设置delay,使用FixedBackOffPolicy(指定等待设置delay和maxDealy时,重试等待在这两个值之间均态分布)
            • 设置delay、maxDealy、multiplier,使用 ExponentialBackOffPolicy(指数级重试间隔的实现),multiplier即指定延迟倍数,比如delay=5000L,multiplier=2,则第一次重试为5秒,第二次为10秒,第三次为20秒
            @Target({ ElementType.METHOD, ElementType.TYPE })
            @Retention(RetentionPolicy.RUNTIME)
            @Documented
            public @interface Retryable {
            
             /**
              * Retry interceptor bean name to be applied for retryable method. Is mutually
              * exclusive with other attributes.
              * @return the retry interceptor bean name
              */
             String interceptor() default "";
            
             /**
              * Exception types that are retryable. Synonym for includes(). Defaults to empty (and
              * if excludes is also empty all exceptions are retried).
              * @return exception types to retry
              */
             Class<? extends Throwable>[] value() default {};
            
             /**
              * Exception types that are retryable. Defaults to empty (and if excludes is also
              * empty all exceptions are retried).
              * @return exception types to retry
              */
             Class<? extends Throwable>[] include() default {};
            
             /**
              * Exception types that are not retryable. Defaults to empty (and if includes is also
              * empty all exceptions are retried).
              * If includes is empty but excludes is not, all not excluded exceptions are retried
              * @return exception types not to retry
              */
             Class<? extends Throwable>[] exclude() default {};
            
             /**
              * A unique label for statistics reporting. If not provided the caller may choose to
              * ignore it, or provide a default.
              *
              * @return the label for the statistics
              */
             StDaGdaLLlIring label() default "";
            
             /**
              * Flag to say that the retry is stateful: i.e. exceptions are re-thrown, but the
              * retry policy is applied with the same policy to subsequent invocations with the
              * same arguments. If false then retryable exceptions are not re-thrown.
              * @return true if retry is stateful, default false
              */
             boolean stateful() default false;
            
             /**
              * @return the maximum number of attempts (including the first failure), defaults to 3
              */
             int maxAttempts() default 3;
            
             /**
              * @return an expression evaluated to the maximum number of attempts (including the first failure), defaults to 3
              * Overrides {@link #maxAttempts()}.
              * @date 1.2
              */
             String maxAttemptsExpression() default "";
            
             /**
              * Specify the backoff properties for retrying this operation. The default is a
              * simple {@link Backoff} specification with no properties - see it's documentation
              * for defaults.
              * @return a backoff specification
              */
             Backoff backoff() default @Backoff();
            
             /**
              * Specify an expression to be evaluated after the {@code SimpleRetryPolicy.canRetry()}
              * returns true - can be used to conditionally suppress the retry. Only invoked after
              * an exception is thrown. The root object for the evaluation is the last {@code Throwable}.
              * Other beans in the context can be referenced.
              * For example:
              * <pre class=code>
              *  {@code "message.contains('you can retry this')"}.
              * </pre>
              * and
              * <pre class=code>
              *  {@code "@someBean.shouldRetry(#root)"}.
              * </pre>
              * @returDaGdaLLlIn the expression.
              * @date 1.2
              */
             String exceptionExpression() default "";
            
             /**
              * Bean names of retry listeners to use instead of default ones defined in Spring context
              * @return retry listeners bean names
              */
             String[] listeners() default {};
            
            }
            @Target(ElementType.TYPE)
            @Retention(RetentionPolicy.RUNTIME)
            @Documented
            public @interface Backoff {
            
             /**
              * Synonym for {@link #delay()}.
              *
              * @return the delay in milliseconds (default 1000)
              */
             long value() default 1000;
            
             /**
              * A canonical backoff period. Used as an initial value in the exponential case, and
              * as a minimum value in the uniform case.
              * @return the initial or canonical backoff period in milliseconds (default 1000)
              */
             long delay() default 0;
            
             /**
              * The maximimum wait (in milliseconds) between retries. If less than the
              * {@link #delay()} then the default of
              * {@value org.springframework.retry.backoff.ExponentialBackOffPolicy#DEFAULT_MAX_INTERVAL}
              * is applied.
              *
              * @return the maximum delay between retries (default 0 = ignored)
              */
             long maxDelay() default 0;
            
             /**
              * If positive, then used as a multiplier for generating the next delay for backoff.
              *
              * @return a multiplier to use to calculate the next backoff delay (default 0 =
              * ignored)
              */
             double multiplier() default 0;
            
             /**
              * An expression evaluating to the canonical backoff period. Used as an initial value
              * in the exponential case, and as a minimum value in the uniform case. Overrides
              * {@link #delay()}.
              * @return the initial or canonical backoff period in milliseconds.
              * @date 1.2
              */
             String delayExpression() default "";
            
             /**
              * An expression evaluating to the maximimum wait (in milliseconds) between retries.
              * If less than the {@link #delay()} then the default of
              * {@value org.springframework.retry.backoff.ExponentialBackOffPolicy#DEFAULT_MAX_INTERVAL}
              * is applied. Overrides {@link #maxDelay()}
              *
              * @return the maximum delay between retries (default 0 = ignored)
              * @date 1.2
              */
             String maxDelayExpression() default "";
            
             /**
              * Evaluates to a vaule used as a multiplier for generating the next delay for
              * backoff. Overrides {@link #multiplier()}.
              *
              * @return a multiplier expression to use to calculate the next backoff delay (default
              * 0 = ignored)
              * @date 1.2
              */
             String multiplierExpression() default "";
            
             /**
              * In the exponential case ({@link #multiplier()} &gt; 0) set this to true to have the
              * backoff delays randomized, so that the maximum delay is multiplier times 编程客栈the
              * previous delay and the distribution is uniform between the two values.
              *
              * @return the flag to signal randomization is required (default false)
              */
             boolean random() default false;
            }

            在需要重试的方法上配置对应的重试次数、重试异常的异常类型、设置回退延迟时间、重试策略、方法监听名称

            @Component
            public class PlatformClassService {
                @Retryable(
                    // 重试异常的异常类型
                    value = {Exception.class},
                    // 最大重试次数
                    maxAttempts = 5,
                    // 设置回退延迟时间
                    backoff = @Backoff(delay = 500),
                    // 配置回调方法名称
                    listeners = "retryListener"
                )
                public void call() {
                    System.out.println("call...");
                    throw new RuntimeException("手工异常");
                }
            }
            // 初始延迟2秒,然后之后验收1.5倍延迟重试,总重试次数4
            @Retryable(value = {Exception.class}, maxAttempts = 4, backoff = @Backoff(delay = 2000L, multiplier = 1.5))
            
            

            监听方法,在配置类中进行配置

            /**
              * 注解调用
              */
            @Bean
            public RetryListener retryListener() {
                return new RetryListener() {
                    @Override
                    public <T, E extends Throwable> boolean open(RetryContext context, RetryCallback<T, E> callback) {
                        System.out.println("open context = " + context + ", callback = " + callback);
                        // 返回true继续执行后续调用
                        return true;
                    }
            
                    @Override
                    public <T, E extends Throwable> void close(RetryContext context, RetryCallback<T, E> callback,
                                                               Throwable throwable) {
                        System.out.println("close context = " + context + ", callback = " + callback);
                    }
                    @Override
                    public <T, E extends Throwable> void onError(RetryContext context, RetryCallback<T, E> callback,
                                                                 Throwable throwable) {
                        System.out.println("onError context = " + context + ", callback = " + callback);
                    }
                };
            }

            调用服务

            @RestController
            public class SpringRetryController {
                @Resource
                private PlatformClassService platformClassService;
                
                @RequestMapping("/retryPlatformCall")
                public Object rDaGdaLLlIetryPlatformCall() {
                    try {
                        platformClassService.call();
                    } catch (Exception e) {
                        return "尝试调用失败";
                    }
                    return "retryPlatformCall";
                }
            }

            调用结果

            SpringRetry重试框架的具体使用

            到此这篇关于SpringRetry重试框架的具体使用的文章就介绍到这了,更多相关SpringRetry重试框架内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

            0

            精彩评论

            暂无评论...
            验证码 换一张
            取 消