SpringRetry重试框架的具体使用

  org.springframework.retryspring-retry org.springframeworkspring-aspects

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

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

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

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

 public final  T execute(RetryCallback retryCallback) throws E 

 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  boolean open(RetryContext context, RetryCallback callback) { PrintUtil.print("open"); return true; } @Override public  void close(RetryContext context, RetryCallback callback, Throwable throwable) { PrintUtil.print("close"); } @Override public  void onError(RetryContext context, RetryCallback callback, Throwable throwable) { PrintUtil.print("onError"); } } }; retryTemplate.setListeners(listeners); return retryTemplate; } }

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

 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("手工异常"); } }

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

 @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[] 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[] 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[] 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 */ String 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: * 
 *  {@code "message.contains('you can retry this')"}. * 
 * and * 
 *  {@code "@someBean.shouldRetry(#root)"}. * 
 * @return 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()} > 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  boolean open(RetryContext context, RetryCallback callback) { System.out.println("open context = " + context + ", callback = " + callback); // 返回true继续执行后续调用 return true; } @Override public  void close(RetryContext context, RetryCallback callback, Throwable throwable) { System.out.println("close context = " + context + ", callback = " + callback); } @Override public  void onError(RetryContext context, RetryCallback 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"; } }