容错机制应用Spring-Retry

最新推荐文章于 2024-04-07 10:06:29 发布
最新推荐文章于 2024-04-07 10:06:29 发布
阅读量489 收藏 2
点赞数
分类专栏： spring
随意转载。
本文链接：https://blog.csdn.net/dengjili/article/details/114806516
版权

上文我们在学习容错机制理论中，我们发现其中有一种处理手段为failback故障自动恢复，Spring-Retry即为failback的实现中间件，下面我们就来开始学习Spring-Retry

基本框架例子

框架介绍
The following example shows how to use Spring Retry in its imperative style

  • RetryTemplate，重试模板，是进入spring-retry框架的整体流程入口
  • RetryCallback，该接口封装了业务代码，且failback后，会再次调用RetryCallback接口
  • RetryPolicy，重试策略，描述将以什么样的方式调用RetryCallback接口

使用Spring Retry例子

public class RetryTemplateDemo {
	
	/**  
	 * 业务代码
	 */
	private static String business() throws Exception {
		System.out.println("begin...");
		if (true) {
			throw new Exception();
		}
		System.out.println("end...");
		return "success";
	}
	
	public static void main(String[] args) throws Exception {
		RetryTemplate template = new RetryTemplate();
		SimpleRetryPolicy policy = new SimpleRetryPolicy(3);
		template.setRetryPolicy(policy);
		RetryCallback<String, Exception> retryCallback = (context) -> {
			return business();
		};
		String result = template.execute(retryCallback);
		System.out.println(result);
	}
}

测试结果

22:24:53.746 [main] DEBUG org.springframework.retry.support.RetryTemplate - Retry: count=0
begin...
22:24:53.751 [main] DEBUG org.springframework.retry.support.RetryTemplate - Checking for rethrow: count=1
22:24:53.751 [main] DEBUG org.springframework.retry.support.RetryTemplate - Retry: count=1
begin...
22:24:53.751 [main] DEBUG org.springframework.retry.support.RetryTemplate - Checking for rethrow: count=2
22:24:53.751 [main] DEBUG org.springframework.retry.support.RetryTemplate - Retry: count=2
begin...
22:24:53.751 [main] DEBUG org.springframework.retry.support.RetryTemplate - Checking for rethrow: count=3
22:24:53.751 [main] DEBUG org.springframework.retry.support.RetryTemplate - Retry failed last attempt: count=3
Exception in thread "main" java.lang.Exception
	at priv.dengjili.spring.retry.demo.test.RetryTemplateDemo5.business(RetryTemplateDemo5.java:44)
	at priv.dengjili.spring.retry.demo.test.RetryTemplateDemo5.lambda$0(RetryTemplateDemo5.java:33)
	at priv.dengjili.spring.retry.demo.test.RetryTemplateDemo5$$Lambda$1/1221555852.doWithRetry(Unknown Source)
	at org.springframework.retry.support.RetryTemplate.doExecute(RetryTemplate.java:329)
	at org.springframework.retry.support.RetryTemplate.execute(RetryTemplate.java:209)
	at priv.dengjili.spring.retry.demo.test.RetryTemplateDemo5.main(RetryTemplateDemo5.java:35)

通过结果我们可以看出，原业务代码会抛出异常，同时也设置了重试策略SimpleRetryPolicy，重试次数为3次，从测试结果我们可以看出，结果一致

RetryPolicy提供了其他策略实现：

  • NeverRetryPolicy：只允许调用RetryCallback一次，不允许重试；
  • AlwaysRetryPolicy：允许无限重试，直到成功，此方式逻辑不当会导致死循环；
  • SimpleRetryPolicy：固定次数重试策略，默认重试最大次数为3次，RetryTemplate默认使用的策略；
  • TimeoutRetryPolicy：超时时间重试策略，默认超时时间为1秒，在指定的超时时间内允许重试；
  • CircuitBreakerRetryPolicy：有熔断功能的重试策略，需设置3个参数openTimeout、resetTimeout和delegate；
  • CompositeRetryPolicy：组合重试策略，有两种组合方式，乐观组合重试策略是指只要有一个策略允许重试即可以，悲观组合重试策略是指只要有一个策略不允许重试即可以，但不管哪种组合方式，组合中的每一个策略都会执行。

详细使用例子参考官网：https://github.com/spring-projects/spring-retry

RecoveryCallback 恢复策略

在这里插入图片描述

  • RecoveryCallback ，当我们进行所有重试，依然失败后，提供一个恢复的补偿方法
public class RetryTemplateDemo {
	
	/**  
	 * 业务代码
	 */
	private static String business() throws Exception {
		System.out.println("begin...");
		if (true) {
			throw new Exception();
		}
		System.out.println("end...");
		return "success";
	}
	
	public static void main(String[] args) throws Exception {
		RetryTemplate template = new RetryTemplate();
		SimpleRetryPolicy policy = new SimpleRetryPolicy(3);
		template.setRetryPolicy(policy);
		RetryCallback<String, Exception> retryCallback = (context) -> {
			return business();
		};
		RecoveryCallback<String> recoveryCallback = (context) -> {
			return "default_sucesss";
		};
		String result = template.execute(retryCallback, recoveryCallback);
		System.out.println(result);
	}
}

测试结果

22:45:37.823 [main] DEBUG org.springframework.retry.support.RetryTemplate - Retry: count=0
begin...
22:45:37.826 [main] DEBUG org.springframework.retry.support.RetryTemplate - Checking for rethrow: count=1
22:45:37.826 [main] DEBUG org.springframework.retry.support.RetryTemplate - Retry: count=1
begin...
22:45:37.827 [main] DEBUG org.springframework.retry.support.RetryTemplate - Checking for rethrow: count=2
22:45:37.827 [main] DEBUG org.springframework.retry.support.RetryTemplate - Retry: count=2
begin...
22:45:37.827 [main] DEBUG org.springframework.retry.support.RetryTemplate - Checking for rethrow: count=3
22:45:37.827 [main] DEBUG org.springframework.retry.support.RetryTemplate - Retry failed last attempt: count=3
default_sucesss

通过结果我们可以看出，原业务代码会抛出异常，同时也设置了重试策略SimpleRetryPolicy，重试次数为3次，依然失败，最后执行RecoveryCallback接口方法，结果一致

有状态的重试

有没状态如何理解，HTTP是无状态的，即两次调用接口之间不存在任何关系或者影响，有状态意味着调用之间有影响。
比如是由于事务资源导致的失败，那么多次调用可能会出现数据问题，那么将不能够进行重试，立刻上报异常。Spring-Retry提供了RetryState对象，这里举例说明一下即可

public class RetryTemplateDemo5 {
	
	/**  
	 * 业务代码
	 */
	private static String business() throws Exception {
		System.out.println("begin...");
		if (true) {
			throw new Exception();
		}
		System.out.println("end...");
		return "success";
	}
	
	public static void main(String[] args) throws Exception {
		RetryTemplate template = new RetryTemplate();
		SimpleRetryPolicy policy = new SimpleRetryPolicy(3);
		template.setRetryPolicy(policy);
		RetryCallback<String, Exception> retryCallback = (context) -> {
			return business();
		};
		RecoveryCallback<String> recoveryCallback = (context) -> {
			return "default_sucesss";
		};
		RetryState state = new DefaultRetryState("unique call");
		String result = template.execute(retryCallback, recoveryCallback, state);
		System.out.println(result);
	}
}

测试结果

22:56:59.883 [main] DEBUG org.springframework.retry.support.RetryTemplate - Retry: count=0
begin...
22:56:59.887 [main] DEBUG org.springframework.retry.support.RetryTemplate - Checking for rethrow: count=1
22:56:59.887 [main] DEBUG org.springframework.retry.support.RetryTemplate - Rethrow in retry for policy: count=1
Exception in thread "main" java.lang.Exception
	at priv.dengjili.spring.retry.demo.test.RetryTemplateDemo5.business(RetryTemplateDemo5.java:30)
	at priv.dengjili.spring.retry.demo.test.RetryTemplateDemo5.lambda$0(RetryTemplateDemo5.java:41)
	at priv.dengjili.spring.retry.demo.test.RetryTemplateDemo5$$Lambda$1/2104457164.doWithRetry(Unknown Source)
	at org.springframework.retry.support.RetryTemplate.doExecute(RetryTemplate.java:329)
	at org.springframework.retry.support.RetryTemplate.execute(RetryTemplate.java:255)
	at priv.dengjili.spring.retry.demo.test.RetryTemplateDemo5.main(RetryTemplateDemo5.java:47)

测试与预期一致

RetryListener监听器

提供了三个监听的地方
在这里插入图片描述

public class RetryTemplateDemo5 {
	
	/**  
	 * 业务代码
	 */
	private static String business() throws Exception {
		System.out.println("begin...");
		if (true) {
			throw new Exception();
		}
		System.out.println("end...");
		return "success";
	}
	
	public static void main(String[] args) throws Exception {
		RetryTemplate template = new RetryTemplate();
		SimpleRetryPolicy policy = new SimpleRetryPolicy(3);
		template.setRetryPolicy(policy);
		RetryCallback<String, Exception> retryCallback = (context) -> {
			return business();
		};
		RecoveryCallback<String> recoveryCallback = (context) -> {
			return "default_sucesss";
		};
		RetryListener listener = new RetryListener() {
			@Override
			public <T, E extends Throwable> boolean open(RetryContext context, RetryCallback<T, E> callback) {
				System.out.println("open");
				// 必须返回true，不然结束了
				return true;
			}

			@Override
			public <T, E extends Throwable> void close(RetryContext context, RetryCallback<T, E> callback,
					Throwable throwable) {
				System.out.println("close");
			}

			@Override
			public <T, E extends Throwable> void onError(RetryContext context, RetryCallback<T, E> callback,
					Throwable throwable) {
				System.out.println("onError");
			}};
		// 可设置多个RetryListener
		template.setListeners(new RetryListener[] {listener});
		
		String result = template.execute(retryCallback, recoveryCallback);
		System.out.println(result);
	}
}

测试结果

open
23:08:58.601 [main] DEBUG org.springframework.retry.support.RetryTemplate - Retry: count=0
begin...
onError
23:08:58.605 [main] DEBUG org.springframework.retry.support.RetryTemplate - Checking for rethrow: count=1
23:08:58.606 [main] DEBUG org.springframework.retry.support.RetryTemplate - Retry: count=1
begin...
onError
23:08:58.606 [main] DEBUG org.springframework.retry.support.RetryTemplate - Checking for rethrow: count=2
23:08:58.606 [main] DEBUG org.springframework.retry.support.RetryTemplate - Retry: count=2
begin...
onError
23:08:58.606 [main] DEBUG org.springframework.retry.support.RetryTemplate - Checking for rethrow: count=3
23:08:58.606 [main] DEBUG org.springframework.retry.support.RetryTemplate - Retry failed last attempt: count=3
close
default_sucesss

测试与预期一致

其他说明

从1.3版开始，RetryTemplate的更简单配置也可以使用，如下所示:

RetryTemplate.builder()
      .maxAttempts(10)
      .exponentialBackoff(100, 2, 10000)
      .retryOn(IOException.class)
      .traversingCauses()
      .build();

RetryTemplate.builder()
      .fixedBackoff(10)
      .withinMillis(3000)
      .build();

RetryTemplate.builder()
      .infiniteRetry()
      .retryOn(IOException.class)
      .uniformRandomBackoff(1000, 3000)
      .build();

或者使用声明式编程，注解方式，如下所示:
eg1：

@Configuration
@EnableRetry
public class Application {

    @Bean
    public Service service() {
        return new Service();
    }

    @Bean public RetryListener retryListener1() {
        return new RetryListener() {...}
    }

    @Bean public RetryListener retryListener2() {
        return new RetryListener() {...}
    }

}

@Service
class Service {
    @Retryable(RemoteAccessException.class)
    public service() {
        // ... do something
    }
}

eg2：

@Service
class Service {
    @Retryable(maxAttempts=12, backoff=@Backoff(delay=100, maxDelay=500))
    public service() {
        // ... do something
    }
}

eg3：

@Service
class Service {
    @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
    }
}

源码导读

以上是我通过阅读Spring-Retry源码整理出来的，源代码目录https://github.com/spring-projects/spring-retry

核心代码入口：org.springframework.retry.support.RetryTemplate方法doExecute

参考

https://blog.csdn.net/u012731081/article/details/78892897

dengjili
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
重试框架spring-retry以及guava-retry的使用
08-14
压缩包包含着springboot项目retry，项目中演示了使用spring-retry传统的方式以及注解的方式使用重试的案例，也有guava-retry的使用案例，以及两者的区别
Spring Retry 指南
allway2的博客
04-29 601
由于我们没有在此处指定任何异常，因此将尝试重试所有异常。Spring 重试提供了自动重新调用失败操作的功能。这在错误可能是暂时性的（如暂时的网络故障）的情况下很有帮助。侦听器在重试时提供额外的回调。我们可以将它们用于不同重试中的各种横切关注点。以下参数按相同顺序从失败方法的参数列表中填充。（可选） 类型的第一个参数和相同的返回类型。要在应用程序中启用 Spring 重试，要使用重试处理运行代码，我们可以调用。回调在整个重试之前和之后出现，而。在本文中，我们了解了如何使用注释、在继续之前会暂停固定的时间段。
SpringBoot技术实践-SpringRetry重试框架(1)
最新发布
2401_84103135的博客
04-07 576
RetryTemplate中可以指定监听、回退策略、重试策略等只需要正常new RetryTemplate()即可使用/***//***//***/2.3 回退策略。
优雅实现重试功能选型分析
技术修行 乐于分享
11-08 2283
业务场景     应用中需要实现一个功能： 需要将数据上传到远程存储服务，同时在返回处理成功情况下做其他操作。这个功能不复杂，分为两个步骤：第一步调用远程的Rest服务逻辑包装给处理方法返回处理结果；第二步拿到第一步结果或者捕捉异常，如果出现错误或异常实现重试上传逻辑，否则继续逻辑操作。 解决方案演化      这个问题的技术点在于能够触发重试，以及重试情况下逻辑有效执行
常用的重试技术—如何优雅的重试（Spring-Retry）等
热门推荐
z69183787的专栏
06-21 1万+
背景 分布式环境下，重试是高可用技术中的一个部分，大家在调用RPC接口或者发送MQ时，针对可能会出现网络抖动请求超时情况采取一下重试操作，自己简单的编写重试大多不够优雅，而重试目前已有很多技术实现和框架支持，但也是有个有缺点，本文主要对其中进行整理，以求找到比较优雅的实现方案； 重试在功能设计上需要根据应用场景进行设计，读数据的接口比较适合重试的场景，写数据的接口就需要注意接口的幂等性了，还有就是重试次数如果太多的话会导致请求量加倍，给后端造成更大的压力，设置合理的重试机制是关键； 重试技术实现 本
使用Spring-retry 1.1.4完成重试功能
Revivedsun的专栏
11-29 8953
前言在实际项目中，经常需要在某种情况下对调用的方法进行重试，例如发生超时。而通过Spring-retry则能简化重试功能的实现，并实现更多样的重试操作。Spring-retry结构Spring-retry提供的RetryOperations接口，该接口提供了若干方法来执行重试操作。在Spring-retry 1.1.4 中该接口的定义如下。public interface RetryOperatio
详解重试框架Spring retry实践
06-14 620
spring retry是从spring batch独立出来的一个能功能，主要实现了重试和熔断。这篇文章主要介绍了详解重试框架Spring retry实践，具有一定的参考价值，感兴趣的小伙伴们可以参考一下 spring retry是从spring batch独立出来的一个能功能，主要实现了重试和熔断。对于重试是有场景限制的，不是什么场景都适合重试，比如参数校验不合法、写操作等（要考虑写是否幂等）都不适合重试。远程调用超时、网络突然中断可以重试。在微服务治理框架中，通常都有自己的重试与超时配置，比如dubb
springboot基于spring-retry实现重试机制
03-15
本文将详细探讨如何在 Spring Boot 应用中基于 Spring Retry 实现重试机制，以及如何将其应用于支付回调和自定义重试场景。 首先，让我们了解 Spring Retry 的核心概念。Spring Retry 提供了一个 `@Retryable` 注解...
spring-retry:使用spring-retry项目的例子
05-01
Spring重试是Spring框架的一个扩展模块，主要用于处理应用程序中的异常情况，通过自动重试机制提高系统的容错性和稳定性。在Java开发中，特别是在分布式系统、网络调用或数据库操作等可能出现临时性错误的情景下，...
spring-retry,.zip
10-13
Spring Retry作为Spring生态的一部分，为开发者提供了强大的重试机制，有效地增强了应用程序的容错性和可靠性。通过声明式的重试策略，开发者可以专注于业务逻辑，而不用过多关注异常处理的细节。掌握并合理运用...
spring-retry:spring 重试模板示例
05-29
Spring Retry 是一个由 Spring 社区开发的...通过深入理解和应用 Spring Retry，我们可以构建出更健壮、容错性更强的系统。在实际项目中，根据具体需求，可以对重试策略进行详细配置，以适应不同场景下的错误恢复机制。
retry-demo.rar
04-09
本项目"retry-demo.rar"是一个基于Spring Retry的工程示例，用于演示如何在调用失败时实现重试机制。 Spring Retry是一个轻量级的库，它为Java和Spring应用程序提供了简单的API来处理重试逻辑。核心概念包括： 1. ...
spring-retry使用以及源码
qq_25582465的博客
10-09 1705
1、介绍 spring retry是从spring batch独立出来的一个能功能，主要实现了重试和熔断，对于重试是有场景限制的，不是什么场景都适合重试， 比如参数校验不合法、写操作等（要考虑写是否幂等）都不适合重试。 比如外部 RPC 调用，或者数据入库等操作，如果一次操作失败，可以进行多次重试，提高调用成功的可能性。 2、框架介绍 3、概念类 1、BackOff： 补偿值，一般指失败后多久进行重试的延迟值。 2、Sleeper： 暂停应用的工具，通常用来应用补偿值。 3、BackOffPolicy：
不会就学，不懂就百度: JAVA-RETRY技术分享
qq_32871365的博客
05-30 197
业务场景： 对于重试有场景限制.参数校验是否合法，或者写操作等(要考虑写是否幂等) 都不适合重试。参数校验是否合法，本身就是一次运行，过或者不过。写操作是否幂等这本身也不建议你重复发送，增加系统负担。但是远程调用超时，网络突然中断这些就很适合重试，在微服务治理框架中，通常有注解的重试与超时配置。不过自己进行项目内重试可以采用Spring retry框架，是一个spring batch独立出来的功能，可以指定需要重试的异常类型，并且可以设置每次重试的间隔以及重试失败是继续重试还是熔断。(停止重试) 设计与实现
SpringRetry重试操作
做你想做的人，没有时间的限制，只要愿意，什么时候都可以start。
04-01 386
假设A,B两个系统，当A->B的调用失败时，我们可以采取何种策略？以下是常见的策略： failfast，即快速失败像上层抛出远程调用异常 failover，即A->B失败，选择集群其他机器A->Bn(1…N) failsafe，失败吞异常 failback, 过一会再重试，比如网络抖动，等一小会在重试。 其中failback则是本文所要讨论的核心内容。有些rpc框架提供failback策略，比如dubbo，但dubbo的failback仅仅只是设置重试次数，功能单一。更多的RPC框
spring Retry 相关介绍
jslzcydd的博客
06-11 766
什么时候用可以重试 远程调用失败的可以重试 参校失败不应该重试 只读操作可以重试 幂等写操作可以重试 非幂等写操作不能重试（重试可能导致脏写，或产生重复数据） 无状态(Stateless) 重试 无状态重试，是在一个循环中执行完重试策略，即重试上下文保持在一个线程上下文中，在一次调用中进行完整的重试策略判断。非常简单的情况，如远程调用某个查询方法时是最常见的无状态重试。 远程方法调用的时候不需要设置，因为远程方法调用是没有事务的。 有状态(Stateful) 重试 有状态重试
Spring-retry 重试机制
春风化雨
11-06 788
1、场景 批量给第三方回写数据，失败情况重发 2、示例一 package com.retry; import org.springframework.retry.RecoveryCallback; import org.springframework.retry.RetryCallback; import org.springframework.retry.RetryContext; i...
Spring Retry：RetryTemplate
weixin_38370441的博客
10-19 1031
文章目录参考概念总结实际demo 参考 核心学习文章： Spring（34）——Spring Retry介绍 简略版： 重试框架Spring retry实践、 很好的Spring学习专栏 概念总结 RetryOperations：Spring重试接口 RetryTemplate：RetryOperations的Spring默认实现 RetryPolicy：重试机制接口 SimpleRetryPolicy：RetryPolicy的Spring默认实现 核心学习文章中第一部分介绍了所有的policy以及使用实例
Spring-retry 使用指南
分享技术干货和灵感、推荐新书和好玩的项目、分享Java面试题
06-18 736
高分文章-Spring-retry 使用指南
[] - 2022-08-24 重试框架 Spring-Retry 和 Guava-Retry，你知道该怎么选吗？.pdf
12-11
如果你的应用程序不需要那么全面的Spring集成，或者希望保持代码更简洁，那么Guava-Retry可能是更好的选择。 在实际决策时，应根据项目的具体需求、团队的技术栈以及对可维护性的考量来决定。如果项目已深入使用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值