SpringRetry重试框架的具体使用-编程学习网

一、环境搭建

加入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

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 {

    
    @Bean
    public RetryTemplate retryTemplate() {
        RetryTemplate retryTemplate = new RetryTemplate();

        /// 回退固定时间(秒)
       

        // 指数回退(秒)，第一次回退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 - onError
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 {

 
 String interceptor() default "";

 
 Class<? extends Throwable>[] value() default {};

 
 Class<? extends Throwable>[] include() default {};

 
 Class<? extends Throwable>[] exclude() default {};

 
 String label() default "";

 
 boolean stateful() default false;

 
 int maxAttempts() default 3;

 
 String maxAttemptsExpression() default "";

 
 Backoff backoff() default @Backoff();

 
 String exceptionExpression() default "";

 
 String[] listeners() default {};

}


@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Backoff {

 
 long value() default 1000;

 
 long delay() default 0;

 
 long maxDelay() default 0;

 
 double multiplier() default 0;

 
 String delayExpression() default "";

 
 String maxDelayExpression() default "";

 
 String multiplierExpression() default "";

 
 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 retryPlatformCall() {
        try {
            platformClassService.call();
        } catch (Exception e) {
            return "尝试调用失败";
        }
        return "retryPlatformCall";
    }
}

调用结果

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

文章详情

SpringRetry重试框架的具体使用

目录

一、环境搭建

二、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

软考中级精品资料免费领

相关文章

猜你喜欢

SpringRetry重试框架的具体使用

SpringRetry重试框架的使用讲解

Java接口测试之日志框架Logback的具体使用

Golang远程调用框架RPC的具体使用

Spring Retry重试框架的使用讲解

Spring Retry重试框架如何使用

SpringBoot中使用Spring-Retry重试框架的实现

好用的PHP框架具体有哪些

微信小程序中使用vant框架的具体步骤

Spring Boot中怎么使用Spring Retry重试框架

Spring Boot中怎么使用Spring-Retry重试框架

go测试框架gomonkey的使用

Spring Boot中使用Spring Retry重试框架的操作方法

Android下Junit测试框架的使用

Java中XFire框架的具体用法有哪些？(Java中XFire框架的用法是什么)

微信小程序中使用vant框架的具体步骤是什么

Laravel框架中的响应类具体有哪些用途？

Dev-C++调试方法的具体使用

在 Spring 框架中 Java Action 的具体用法是怎样的？(Java Action在Spring框架中的用法)

Pytest自动化测试框架的使用