Spring Boot 整合——Spring retry有状态重试以及其注释和组件介绍

最新推荐文章于 2024-03-22 14:01:58 发布
最新推荐文章于 2024-03-22 14:01:58 发布
阅读量1.2k 收藏 2
点赞数
分类专栏： # Spring Boot常用组件 JAVA 文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-NC-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq330983778/article/details/112758737
版权

关于版本

依赖版本
springboot2.4.0
spring retry2.4.0

代码地址

因为每个例子涉及代码较多，且包含测试用例，如果都贴到文章中内容过多，所以只贴出了部分代码。全部的代码在这里：https://gitee.com/daifyutils/springboot-samples。

相关文章

Spring Boot 整合——Spring retry的基本使用

通过配置状态重试来使用CircuitBreaker带熔断功能的重试

无状态的重试

无状态重试，是在一个循环中执行完重试策略，即重试上下文保持在一个线程上下文中。

有状态的重试

有状态的重试时，上下文会保存在一个公共的缓存中。

  1. 注释中设置有状态的重试
@Retryable(stateful = true)
  1. JAVA中使用DefaultRetryState保存状态
    Object key = "retryState";
    boolean isForceRefresh = false;
    RetryState state = new DefaultRetryState(key, isForceRefresh);

带熔断功能的重试

使用CircuitBreaker我们可以实现熔断功能的重试。其需要设置三个参数

CircuitBreakerRetryPolicy retryPolicy =
        new CircuitBreakerRetryPolicy(new SimpleRetryPolicy(5));
// 此参数用来判断熔断器是否打开的超时时间
retryPolicy.setOpenTimeout(3000L);
// 此参数用来判断熔断器是否重置的超时时间
retryPolicy.setResetTimeout(9000L);

熔断逻辑的判断

其两个参数主要的应用是在判断熔断器电路是否打开的逻辑CircuitBreakerRetryPolicy的isOpen中

		public boolean isOpen() {
			long time = System.currentTimeMillis() - this.start;
			boolean retryable = this.policy.canRetry(this.context);
			if (!retryable) {// 如果不能重试
			    // 如果上次请求时间大于this.timeout 重置上下文
				if (time > this.timeout) {
					logger.trace("Closing");
					this.context = createDelegateContext(policy, getParent());
					this.start = System.currentTimeMillis();
					retryable = this.policy.canRetry(this.context);
				}
				else if (time < this.openWindow) {
				// 如果上次请求小于this.openWindow，则打开断路器
					if ((Boolean) getAttribute(CIRCUIT_OPEN) == false) {
						logger.trace("Opening circuit");
						setAttribute(CIRCUIT_OPEN, true);
					}
					this.start = System.currentTimeMillis();
					return true;
				}
			}
			else {// 可以进行重试
			// 如果距离上次请求时间大于openWindow则断路器闭合，重置上下文
				if (time > this.openWindow) {
					logger.trace("Resetting context");
					this.start = System.currentTimeMillis();
					this.context = createDelegateContext(policy, getParent());
				}
			}
			if (logger.isTraceEnabled()) {
				logger.trace("Open: " + !retryable);
			}
			setAttribute(CIRCUIT_OPEN, !retryable);
			return !retryable;
		}

上面的逻辑可以得到结论，总结下来。

this.timeout 为设置的 ResetTimeout (9000L)

this.openWindow 为设置的 OpenTimeout (3000L)

当this.policy.canRetry(this.context) == false重试失败。

  1. 如果两次请求时间大于ResetTimeout则重置上下文后，重新判断canRetry

  2. 如果两次请求时间小于OpenTimeout则打开断路器

当this.policy.canRetry(this.context) == true可以继续进行重试。

  1. 如果两次请求时间大于OpenTimeout则重置上下文

带熔断功能重试的例子

JAVA

    public void retryState(long sleepTime){
        RetryTemplate template = RetryTemplate.builder().retryOn(Exception.class).build();
        CircuitBreakerRetryPolicy retryPolicy =
                new CircuitBreakerRetryPolicy(new SimpleRetryPolicy(5));
        // 此参数用来判断熔断器是否打开的超时时间动
        retryPolicy.setOpenTimeout(2000L);
        // 此参数用来判断熔断器是否重置的超时时间
        retryPolicy.setResetTimeout(20000L);
        template.setRetryPolicy(retryPolicy);
        Object key = "retryState";
        boolean isForceRefresh = false;
        RetryState state = new DefaultRetryState(key, isForceRefresh);
        for (int i = 0; i < 20; i++) {
            try {
                String result = template.execute(new RetryCallback<String, RuntimeException>() {
                    @Override
                    public String doWithRetry(RetryContext context) throws RuntimeException {
                        log.info("重试次数:" + context.getRetryCount());
                        log.warn("业务执行失败！！！" + LocalTime.now());
                        try {
                            Thread.sleep(200L * 1);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        throw new RuntimeException("timeout");
                    }
                }, new RecoveryCallback<String>() {
                    @Override
                    public String recover(RetryContext context) throws Exception {
                        log.warn("业务执行recover！！！" + LocalTime.now());
                        return "default";
                    }
                },state);
                if (result.equals("default")) {
                    try {
                        log.info("请求被拒绝，休眠{}毫秒后再次请求。",sleepTime);
                        Thread.sleep(sleepTime);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            } catch (Exception e) {
                System.out.println(e);
            }
        }
    }

使用注解

    @CircuitBreaker(
            openTimeout = 3000L,
            resetTimeout = 7000L,
            maxAttempts = 5 // 最大重试次数
    )
    public String retryAnnotationState(){
        log.warn("业务执行失败！！！" + LocalTime.now());
        throw new RuntimeException("timeout");
    }

    @Recover
    public String recover() {
        log.info("请求被拒绝。");
        return "default";
    }

测试用例

以JAVA代码中的demo为测试例子

    /**
     * 有状态的重试，此时5次重试后熔断，重试时间小于openTimeout
     * @throws Exception
     */
    @Test
    public void baseRetry() throws Exception {
        retryStateService.retryState(1000L * 1);
    }

在熔断上下文被重置，然后使用小于OpenTimeout的频率发送请求，如此断路器会被持续打开，且上下文无法重置,请求会被持续性的熔断。

2021-01-17 21:43:43.711  INFO 17848 --- [           main] d.s.retry.service.RetryStateService      : 请求被拒绝，休眠1500毫秒后再次请求。
2021-01-17 21:43:45.211  WARN 17848 --- [           main] d.s.retry.service.RetryStateService      : 业务执行recover！！！21:43:45.211
2021-01-17 21:43:45.211  INFO 17848 --- [           main] d.s.retry.service.RetryStateService      : 请求被拒绝，休眠1500毫秒后再次请求。
2021-01-17 21:43:46.711  WARN 17848 --- [           main] d.s.retry.service.RetryStateService      : 业务执行recover！！！21:43:46.711
2021-01-17 21:43:46.711  INFO 17848 --- [           main] d.s.retry.service.RetryStateService      : 请求被拒绝，休眠1500毫秒后再次请求。
2021-01-17 21:43:48.212  WARN 17848 --- [           main] d.s.retry.service.RetryStateService      : 业务执行recover！！！21:43:48.212
2021-01-17 21:43:48.212  INFO 17848 --- [           main] d.s.retry.service.RetryStateService      : 请求被拒绝，休眠1500毫秒后再次请求。
2021-01-17 21:43:49.712  WARN 17848 --- [           main] d.s.retry.service.RetryStateService      : 业务执行recover！！！21:43:49.712
2021-01-17 21:43:49.712  INFO 17848 --- [           main] d.s.retry.service.RetryStateService      : 请求被拒绝，休眠1500毫秒后再次请求。
2021-01-17 21:43:51.212  WARN 17848 --- [           main] d.s.retry.service.RetryStateService      : 业务执行recover！！！21:43:51.212
2021-01-17 21:43:51.212  INFO 17848 --- [           main] d.s.retry.service.RetryStateService      : 请求被拒绝，休眠1500毫秒后再次请求。
2021-01-17 21:43:52.713  WARN 17848 --- [           main] d.s.retry.service.RetryStateService      : 业务执行recover！！！21:43:52.713
2021-01-17 21:43:52.713  INFO 17848 --- [           main] d.s.retry.service.RetryStateService      : 请求被拒绝，休眠1500毫秒后再次请求。

同样以JAVA中代码为测试例子

    /**
     * 有状态的重试，后熔断，重试总时间大于ResetTimeout
     * @throws Exception
     */
    @Test
    public void baseRetry2() throws Exception {
        retryStateService.retryState(2100L);
    }

在熔断上下文被重置，然后使用大于OpenTimeout的频率发送请求，则在时间到达ResetTimeout之后可以重新进行重试

2021-01-17 21:45:46.768  INFO 22244 --- [           main] d.s.retry.service.RetryStateService      : 重试次数:4
2021-01-17 21:45:46.768  WARN 22244 --- [           main] d.s.retry.service.RetryStateService      : 业务执行失败！！！21:45:46.768
java.lang.RuntimeException: timeout
2021-01-17 21:45:46.969  WARN 22244 --- [           main] d.s.retry.service.RetryStateService      : 业务执行recover！！！21:45:46.969
2021-01-17 21:45:46.969  INFO 22244 --- [           main] d.s.retry.service.RetryStateService      : 请求被拒绝，休眠2100毫秒后再次请求。
2021-01-17 21:45:49.070  WARN 22244 --- [           main] d.s.retry.service.RetryStateService      : 业务执行recover！！！21:45:49.070
2021-01-17 21:45:49.070  INFO 22244 --- [           main] d.s.retry.service.RetryStateService      : 请求被拒绝，休眠2100毫秒后再次请求。
2021-01-17 21:45:51.170  WARN 22244 --- [           main] d.s.retry.service.RetryStateService      : 业务执行recover！！！21:45:51.170
2021-01-17 21:45:51.170  INFO 22244 --- [           main] d.s.retry.service.RetryStateService      : 请求被拒绝，休眠2100毫秒后再次请求。
2021-01-17 21:45:53.271  WARN 22244 --- [           main] d.s.retry.service.RetryStateService      : 业务执行recover！！！21:45:53.271
2021-01-17 21:45:53.271  INFO 22244 --- [           main] d.s.retry.service.RetryStateService      : 请求被拒绝，休眠2100毫秒后再次请求。
2021-01-17 21:45:55.371  WARN 22244 --- [           main] d.s.retry.service.RetryStateService      : 业务执行recover！！！21:45:55.371
2021-01-17 21:45:55.371  INFO 22244 --- [           main] d.s.retry.service.RetryStateService      : 请求被拒绝，休眠2100毫秒后再次请求。
2021-01-17 21:45:57.471  WARN 22244 --- [           main] d.s.retry.service.RetryStateService      : 业务执行recover！！！21:45:57.471
2021-01-17 21:45:57.471  INFO 22244 --- [           main] d.s.retry.service.RetryStateService      : 请求被拒绝，休眠2100毫秒后再次请求。
2021-01-17 21:45:59.572  WARN 22244 --- [           main] d.s.retry.service.RetryStateService      : 业务执行recover！！！21:45:59.572
2021-01-17 21:45:59.572  INFO 22244 --- [           main] d.s.retry.service.RetryStateService      : 请求被拒绝，休眠2100毫秒后再次请求。
2021-01-17 21:46:01.672  WARN 22244 --- [           main] d.s.retry.service.RetryStateService      : 业务执行recover！！！21:46:01.672
2021-01-17 21:46:01.672  INFO 22244 --- [           main] d.s.retry.service.RetryStateService      : 请求被拒绝，休眠2100毫秒后再次请求。
2021-01-17 21:46:03.773  WARN 22244 --- [           main] d.s.retry.service.RetryStateService      : 业务执行recover！！！21:46:03.773
2021-01-17 21:46:03.773  INFO 22244 --- [           main] d.s.retry.service.RetryStateService      : 请求被拒绝，休眠2100毫秒后再次请求。
2021-01-17 21:46:05.873  WARN 22244 --- [           main] d.s.retry.service.RetryStateService      : 业务执行recover！！！21:46:05.873
2021-01-17 21:46:05.874  INFO 22244 --- [           main] d.s.retry.service.RetryStateService      : 请求被拒绝，休眠2100毫秒后再次请求。
2021-01-17 21:46:07.975  INFO 22244 --- [           main] d.s.retry.service.RetryStateService      : 重试次数:0
2021-01-17 21:46:07.975  WARN 22244 --- [           main] d.s.retry.service.RetryStateService      : 业务执行失败！！！21:46:07.975
java.lang.RuntimeException: timeout
2021-01-17 21:46:08.175  INFO 22244 --- [           main] d.s.retry.service.RetryStateService      : 重试次数:1
2021-01-17 21:46:08.175  WARN 22244 --- [           main] d.s.retry.service.RetryStateService      : 业务执行失败！！！21:46:08.175

使用注释和RetryTemplate的区别

这是一个没有解决的问题，有清楚怎么配置的同学可以告知下

使用RetryTemplate进行重试的时候，其会进行多次重试后达到最大重试次数后进入熔断时进入Recover方法。

而使用@CircuitBreaker进行熔断重试的时候，其进行多次重试时每次失败都会进入Recover方法然后熔断后才会只执行Recover方法。

重试注解介绍

用来定义重试策略的注解

@Target({ ElementType.METHOD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Retryable {

	// 设置兜底方法的方法名，默认为空获取当前类中Recover注解的方法
	String recover() default "";

	// 配置重试监听器bean名称
	String interceptor() default "";

	// 用来设置需要进行重试的异常
	Class<? extends Throwable>[] value() default {};

	// 等价于value一样是来确定需要进行重试的异常
	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 backoff() default @Backoff();

	// 根据异常调用不同处理逻辑的公式
	String exceptionExpression() default "";
	// 重试接听器
	String[] listeners() default {};

}

用来定义兜底方法的注解

@Target({ ElementType.METHOD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Import(RetryConfiguration.class)
@Documented
public @interface Recover {

}

用来在入口类中定义是否启动重试功能

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@EnableAspectJAutoProxy(proxyTargetClass = false)
@Import(RetryConfiguration.class)
@Documented
public @interface EnableRetry {

	// 当proxyTargetClass属性为true时，使用CGLIB代理。默认使用基于标准Java接口的代理
	boolean proxyTargetClass() default false;

}

提供熔断功能的重试

@Target({ ElementType.METHOD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Retryable(stateful = true)
public @interface CircuitBreaker {

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

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

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

	// 
	int maxAttempts() default 3;

	// 
	String maxAttemptsExpression() default "";

	// 
	String label() default "";

	// 配置重置熔断器重新闭合的超时时间
	long resetTimeout() default 20000;

	// 熔断器重新闭合的超时时间的文字公式
	String resetTimeoutExpression() default "";

	// 配置熔断器电路打开的超时时间
	long openTimeout() default 5000;

	// 熔断器电路打开的超时时间的文字公式
	String openTimeoutExpression() default "";

	// 
	String exceptionExpression() default "";

}

退避策略

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

	// 等同于delay，确定延迟时间
	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 "";

	// 在multiplier设置的情况下设置该值为true将使再重试延迟随机化，
	boolean random() default false;

}

重试JAVA代码介绍

重试策略

重试实现类说明
NeverRetryPolicy只允许调用RetryCallback一次，不允许重试
AlwaysRetryPolicy允许无限重试，直到成功，此方式逻辑不当会导致死循环
SimpleRetryPolicy固定次数重试策略，默认重试最大次数为3次，RetryTemplate默认使用的策略
TimeoutRetryPolicy超时时间重试策略，默认超时时间为1秒，在指定的超时时间内允许重试
ExceptionClassifierRetryPolicy设置不同异常的重试策略，类似组合重试策略，区别在于这里只区分不同异常的重试
CircuitBreakerRetryPolicy有熔断功能的重试策略
CompositeRetryPolicy组合重试策略，有两种组合方式，乐观组合重试策略是指只要有一个策略允许重试即可以，悲观组合重试策略是指只要有一个策略不允许重试即可以

NeverRetryPolicy

    /**
     * 只允许调用RetryCallback一次，不允许重试
     * @return
     */
    public static RetryPolicy getNeverRetryPolicy() {
        NeverRetryPolicy neverRetryPolicy = new NeverRetryPolicy();
        return neverRetryPolicy;
    }

AlwaysRetryPolicy

    /**
     * 允许无限重试，直到成功，此方式逻辑不当会导致死循环
     * @return
     */
    public static RetryPolicy getAlwaysRetryPolicy() {
        AlwaysRetryPolicy alwaysRetryPolicy = new AlwaysRetryPolicy();
        return alwaysRetryPolicy;
    }

SimpleRetryPolicy

    /**
     * 固定次数重试策略，默认重试最大次数为3次，RetryTemplate默认使用的策略
     * @return
     */
    public static RetryPolicy getSimpleRetryPolicy() {
        SimpleRetryPolicy simpleRetryPolicy = new SimpleRetryPolicy();
        simpleRetryPolicy.setMaxAttempts(5);
        return simpleRetryPolicy;
    }

TimeoutRetryPolicy

    /**
     * 超时时间重试策略，默认超时时间为1秒，在指定的超时时间内允许重试
     * @return
     */
    public static RetryPolicy getTimeoutRetryPolicy() {
        TimeoutRetryPolicy timeoutRetryPolicy = new TimeoutRetryPolicy();
        timeoutRetryPolicy.setTimeout(3000L);
        return timeoutRetryPolicy;
    }

ExceptionClassifierRetryPolicy

    /**
     * 设置不同异常的重试策略，类似组合重试策略，区别在于这里只区分不同异常的重试
     * @return
     */
    public static RetryPolicy getExceptionClassifierRetryPolicy() {
        ExceptionClassifierRetryPolicy exceptionClassifierRetryPolicy = new ExceptionClassifierRetryPolicy();
        Map map = new HashMap();
        map.put(RuntimeException.class,getNeverRetryPolicy());
        map.put(Exception.class,getSimpleRetryPolicy());
        exceptionClassifierRetryPolicy.setPolicyMap(map);
        return exceptionClassifierRetryPolicy;
    }

CircuitBreakerRetryPolicy

    /**
     * 有熔断功能的重试策略，需设置3个参数openTimeout、resetTimeout和delegate
     * @return
     */
    public static RetryPolicy getCircuitBreakerRetryPolicy() {
        CircuitBreakerRetryPolicy circuitBreakerRetryPolicy = new CircuitBreakerRetryPolicy(new SimpleRetryPolicy());
        circuitBreakerRetryPolicy.setOpenTimeout(5000);
        circuitBreakerRetryPolicy.setResetTimeout(20000);
        return circuitBreakerRetryPolicy;
    }

CompositeRetryPolicy

    /**
     * 组合重试策略，有两种组合方式，乐观组合重试策略是指只要有一个策略允许重试即可以，悲观组合重试策略是指只要有一个策略不允许重试即可以，但不管哪种组合方式，组合中的每一个策略都会执行
     * @return
     */
    public static RetryPolicy getCompositeRetryPolicy() {
        CompositeRetryPolicy compositeRetryPolicy = new CompositeRetryPolicy();
        // 设置是否乐观重试策略
        compositeRetryPolicy.setOptimistic(true);
        compositeRetryPolicy.setPolicies(new RetryPolicy[]{getSimpleRetryPolicy(),getTimeoutRetryPolicy()});
        return compositeRetryPolicy;

    }

退避策略

退避实现类说明
NoBackOffPolicy无退避算法策略，每次重试时立即重试
FixedBackOffPolicy固定时间的退避策略，需设置参数sleeper和backOffPeriod，sleeper指定等待策略，默认是Thread.sleep，即线程休眠，backOffPeriod指定休眠时间，默认1秒
UniformRandomBackOffPolicy随机时间退避策略，需设置sleeper、minBackOffPeriod和maxBackOffPeriod，该策略在[minBackOffPeriod,maxBackOffPeriod之间取一个随机休眠时间，minBackOffPeriod默认500毫秒，maxBackOffPeriod默认1500毫秒
ExponentialBackOffPolicy指数退避策略，需设置参数sleeper、initialInterval、maxInterval和multiplier，initialInterval指定初始休眠时间，默认100毫秒，maxInterval指定最大休眠时间，默认30秒，multiplier指定乘数，即下一次休眠时间为当前休眠时间*multiplier
ExponentialRandomBackOffPolicy随机指数退避策略，引入随机乘数可以实现随机乘数回退

NoBackOffPolicy

无退避算法策略，每次重试时立即重试

    /**
     * 无退避策略
     * @return
     */
    public static BackOffPolicy getNoBackOffPolicy() {
        return new NoBackOffPolicy();
    }

FixedBackOffPolicy

    /**
     * 设置固定退避策略
     * @return
     */
    public static BackOffPolicy getFixedBackOffPolicy() {
        FixedBackOffPolicy fixedBackOffPolicy = new FixedBackOffPolicy();
        // 设置固定的延迟时间
        fixedBackOffPolicy.setBackOffPeriod(2000L);
        return fixedBackOffPolicy;
    }

UniformRandomBackOffPolicy

    /**
     * 设置随机退避策略，设置其最小时间和最大时间
     * @return
     */
    public static BackOffPolicy getUniformRandomBackOffPolicy() {
        UniformRandomBackOffPolicy uniformRandomBackOffPolicy = new UniformRandomBackOffPolicy();
        // 设置最小延迟时间
        uniformRandomBackOffPolicy.setMinBackOffPeriod(500L);
        // 设置最大延迟时间
        uniformRandomBackOffPolicy.setMaxBackOffPeriod(2000L);
        return uniformRandomBackOffPolicy;
    }

ExponentialBackOffPolicy

    public static BackOffPolicy getExponentialBackOffPolicy() {
        ExponentialBackOffPolicy exponentialBackOffPolicy = new ExponentialBackOffPolicy();
        // 设置初始延迟时间
        exponentialBackOffPolicy.setInitialInterval(300L);
        // 设置最大延迟时间
        exponentialBackOffPolicy.setMaxInterval(4000L);
        // 设置两次延迟时间的倍数
        exponentialBackOffPolicy.setMultiplier(3);
        return new NoBackOffPolicy();
    }

ExponentialRandomBackOffPolicy

    /**
     * 指数退避策略
     * @return
     */
    public static BackOffPolicy getExponentialRandomBackOffPolicy() {
        ExponentialRandomBackOffPolicy exponentialRandomBackOffPolicy = new ExponentialRandomBackOffPolicy();
        // 设置初始延迟时间
        exponentialRandomBackOffPolicy.setInitialInterval(300L);
        // 设置最大延迟时间
        exponentialRandomBackOffPolicy.setMaxInterval(4000L);
        // 设置两次延迟时间的倍数
        exponentialRandomBackOffPolicy.setMultiplier(3);
        return new NoBackOffPolicy();
    }
大·风
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Spring（34）——Spring Retry介绍
Elim的博客
05-18 4311
Spring Retry介绍 Spring retry是Spring提供的一种重试机制的解决方案。它内部抽象了一个RetryOperations接口，其定义如下。 public interface RetryOperations { <T, E extends Throwable> T execute(RetryCallback<T, E> retryCallback...
spring Retry 相关介绍
jslzcydd的博客
06-11 808
什么时候用可以重试 远程调用失败的可以重试 参校失败不应该重试 只读操作可以重试 幂等写操作可以重试 非幂等写操作不能重试（重试可能导致脏写，或产生重复数据） 无状态(Stateless) 重试 无状态重试，是在一个循环中执行完重试策略，即重试上下文保持在一个线程上下文中，在一次调用中进行完整的重试策略判断。非常简单的情况，如远程调用某个查询方法时是最常见的无状态重试。 远程方法调用的时候不需要设置，因为远程方法调用是没有事务的。 有状态(Stateful) 重试 有状态重试
springboot重试组件
heroguo007的专栏
12-08 409
最近有一个业务需要有重试机制，感觉应该写一个能够重试的组件。   首先创建一个注解 /** * @Author GUOSHAOHUA093 * @Description 重试拦截 * @Date 9:14 2018/12/8 */ @Retention(RetentionPolicy.RUNTIME) public @interface IsTryAgain { int t...
Spring Retry
来啊 快活啊
03-11 621
RetryContext： RetryContextCache：一个类似于Map的数据结构，Stateful Retry Policies用其存储和查找RetryContext对象； RetryCallback：一个可以使用RetryOperations提供的方法被重试的操作的回调接口；将需要重试的业务操作用RetryCallback包裹一下，然后将RetryCallback传递给RetryOpe...
Spring-Retry重试机制
weixin_47996698的博客
01-04 996
Spring实现了一套重试机制，功能简单实用。Spring Retry是从Spring Batch独立出来的一个功能，已经广泛应用于Spring Batch,Spring Integration, Spring for Apache Hadoop等Spring项目。 本文将讲述如何使用Spring Retry及其实现原理。 重试，其实我们其实很多时候都需要的，为了保证容错性，可用性，一致性等。一般用来应对外部系统的一些不可预料的返回、异常等，特别是网络延迟，中断等情况。还有在现在流行的微服务治理框架中，通
Java实战：Spring Boot接口重试机制实现
oandy0的博客
02-27 1451
本文将详细介绍如何在Spring Boot应用程序中实现接口重试机制。我们将探讨重试机制的基本概念，以及如何使用Spring Boot和第三方库来实现接口的重试功能。
Spring boot使用spring retry重试机制的方法示例
08-25
主要介绍了Spring boot使用spring retry重试机制的方法示例，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
springboot基于spring-retry实现重试机制
03-15
本文将详细探讨如何在 Spring Boot 应用中基于 Spring Retry 实现重试机制，以及如何将其应用于支付回调和自定义重试场景。 首先，让我们了解 Spring Retry 的核心概念。Spring Retry 提供了一个 `@Retryable` 注解...
重试框架spring-retry以及guava-retry的使用
08-14
本文将深入探讨两个常用的重试框架：Spring Retry和Guava Retry，并通过一个名为`retry-starter`的Spring Boot项目实例，来解析它们的使用方式以及差异。 首先，我们来看Spring Retry。Spring Retry是Spring框架的...
Spring Boot集成 Spring Retry 实现容错重试机制教程配套源码
最新发布
06-13
该源码对应个人博客【Spring Boot集成 Spring Retry 实现容错重试机制】配套教程，地址：https://blog.csdn.net/lhmyy521125/article/details/139661753 小伙伴可以自行下载学习！不需要积分！不需要积分！不需要...
Spring Retry 和 Guava Retrying重试机制的使用详解
01-26
3. 选择与比较 Spring-Retry和Guava Retrying都是优秀的重试解决方案，它们各有优势。Spring-Retry更适合已经使用Spring框架的项目，因为它提供了声明式重试，集成简单，但在定制性上可能略逊于Guava Retrying。而...
Spring Boot-整合Retry框架重试机制
qq_37661970的博客
03-22 1081
Retry重试框架，支持AOP切入的方式使用，支持注解;重试次数，重试延迟、重试触发条件、重试的回调方法等功能来实现重试机制项目中我们可以通过两种不同的方式使用Spring Retry重试功能，一种是@Retryable注解的方式，另种是RetryTemplate方式。
重试组件 Spring Retry
markMe1024的博客
09-12 1063
spring-retry是spring社区的一个成员，它提供了一种对失败操作进行自动重试的能力，可以作为某些瞬时错误（例如短暂的网络抖动）的解决方案。作为spring生态的一部分，spring-retry自然地支持声明式（Declarative）方式使用。此外，它也支持命令式（Impertive）方式在代码里直接调用。
在SpringBoot中如何优雅实现接口请求重试？这里有8种解决方案！
芋艿V
02-16 1403
???? 这是一个或许对你有用的社群???? 一对一交流/面试小册/简历优化/求职解惑，欢迎加入「芋道快速开发平台」知识星球。下面是星球提供的部分资料：《项目实战（视频）》：从书中学，往事上“练”《互联网高频面试题》：面朝简历学习，春暖花开《架构 x 系统设计》：摧枯拉朽，掌控面试高频场景题《精进 Java 学习指南》：系统学习，互联网主流技术栈《必读 Java 源码专栏》：知其然，知其所以然????这是一个或许...
Spring Boot 整合——Spring retry的基本使用
大风的博客
01-17 3432
关于版本 依赖 版本 springboot 2.4.0 spring retry 2.4.0 代码地址 因为每个例子涉及代码较多，且包含测试用例，如果都贴到文章中内容过多，所以只贴出了部分代码。全部的代码在这里：https://gitee.com/daifyutils/springboot-samples。 Spring retry 之前在介绍Spring batch的提到过其重试功能之后被独立出了一个新的项目spring retry。通常来说我们可以使用retry来解决一些因为网络
重试框架Spring retry实践
热门推荐
rhwayfun专栏
09-03 4万+
spring retry是从spring batch独立出来的一个能功能，主要实现了重试和熔断。对于重试室友场景限制的，不是什么场景都适合重试，比如参数校验不合法、写操作等（要考虑写是否幂等）都不适合重试。远程调用超时、网络突然中断可以重试。在微服务治理框架中，通常都有自己的重试与超时配置，比如dubbo可以设置retries=1，timeout=500调用失败只重试1次，超过500ms调用仍未返回
利用Spring-Retry定制化你的RPC重试
一点点情趣
12-25 5971
假设A,B两个系统，当A->B的调用失败时，我们可以采取何种策略？以下是常见的策略： failfast，即快速失败像上层抛出远程调用异常failover，即A->B失败，选择集群其他机器A->Bn(1…N)failsafe，失败吞异常failback, 过一会再重试，比如网络抖动，等一小会在重试。 其中failback则是本文所要讨论的核心内容。有些rpc框架提供failback
Spring Retry 的使用和原理
a742172349的博客
05-18 6535
Spring Retry提供了自动重新调用失败的操作的功能。这在错误可能是暂时性的（例如瞬时网络故障）的情况下很有用。Spring Retry提供对流程和基于策略的行为的声明式控制，易于扩展和自定义。接下来，本文将带大家了解 Spring Retry 的使用方法和部分源码解析 引入spring-retry 相关包 使用spring-retry ，我们只需引入spring-retry 和 aop 的包即可，以 maven 为例： <dependency> <groupId>or
springboot集成spring retry实现重试机制
Jaemon
05-04 907
springboot集成spring retry实现重试机制
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

大·风

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值