java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > Spring Retry重试

Spring Retry实现重试机制的示例详解

作者:我是小趴菜

这篇文章主要为大家详细介绍了Spring-Retry的用法以及实现原理是怎么样的,文中的示例代码讲解详细,具有一定的参考价值,需要的可以了解一下

大家好,我是小趴菜,在工作中,我们经常会碰到需要调用远程方法的业务,这时候,如果超时了,或者异常了,我们都会让其重试几次,达到一定的重试次数以后,就返回异常信息,今天我们就来了解下Spring-Retry的用法以及实现原理是怎么样的

Spring-Retry用法

因为Spring-Retry是基于Spring AOP机制实现的,所以需要引入AOP依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.2</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <artifactId>spring-retry</artifactId>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.retry</groupId>
            <artifactId>spring-retry</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
    </dependencies>
</project>

启动类

@RestController
//开启Spring-Retry重试机制
@EnableRetry
@SpringBootApplication
public class App {
    public static void main(String[] args) {
        SpringApplication.run(App.class,args);
    }
    @Resource
    private RetryService retryService;
    @GetMapping("/test")
    public String test(@RequestParam("code") Integer code) throws Exception{
        retryService.retry(code);
        return "ok";
    }
}
package com.coco.service.impl;
import com.coco.service.RetryService;
import org.springframework.retry.annotation.Backoff;
import org.springframework.retry.annotation.Recover;
import org.springframework.retry.annotation.Retryable;
import org.springframework.stereotype.Service;
import java.io.IOException;
@Service
public class RetryServiceImpl implements RetryService {
    /**
     * value:抛出指定异常才会重试
     * include:和value一样,默认为空,当exclude也为空时,默认所有异常
     * exclude:指定不处理的异常
     * maxAttempts:最大重试次数,默认3次
     * backoff:重试等待策略,
     * 默认使用@Backoff,@Backoff的value默认为1000L,我们设置为2000; 以毫秒为单位的延迟(默认 1000)
     * multiplier(指定延迟倍数)默认为0,表示固定暂停1秒后进行重试,如果把multiplier设置为1.5,则第一次重试为2秒,第二次为3秒,第三次为4.5秒。
     */
    @Retryable(value = RuntimeException.class,maxAttempts = 3,backoff = @Backoff(delay = 2000,multiplier = 1.5))
    @Override
    public void retry(int code) throws Exception {
        System.out.println("retry被调用了");
        if (code==0){
            throw new IOException("调用失败,重试");
        }
        System.out.println("调用成功");
    }
    /**
     * Spring-Retry还提供了@Recover注解,用于@Retryable重试失败后处理方法。
     * 如果不需要回调方法,可以直接不写回调方法,那么实现的效果是,重试次数完了后,如果还是没成功没符合业务判断,就抛出异常。
     * 可以看到传参里面写的是 Exception e,这个是作为回调的接头暗号(重试次数用完了,还是失败,我们抛出这个Exception e通知触发这个回调方法)。
     * 注意事项:
     * 方法的返回值必须与@Retryable方法一致
     * 方法的第一个参数,必须是Throwable类型的,建议是与@Retryable配置的异常一致,其他的参数,需要哪个参数,写进去就可以了(@Recover方法中有的)
     * 该回调方法与重试方法写在同一个实现类里面
     *
     * 由于是基于AOP实现,所以不支持类里自调用方法
     * 如果重试失败需要给@Recover注解的方法做后续处理,那这个重试的方法不能有返回值,只能是void
     * 方法内不能使用try catch,只能往外抛异常
     * @Recover注解来开启重试失败后调用的方法(注意,需跟重处理方法在同一个类中),此注解注释的方法参数一定要是@Retryable抛出的异常,否则无法识别,可以在该方法中进行日志处理。
     */
    @Recover
    public void recover(Exception e, int code){
        System.out.println("回调方法执行!!!!");
        //记日志到数据库 或者调用其余的方法
        System.out.println("异常信息:"+e.getMessage());
    }
}

启动项目,浏览器访问 http://localhost:8080/test?code=0 即可看到效果了

其实Spring-Retry的用法还是很简单的,接下来我们来分析下它的底层是如何实现的

Spring-Retry底层实现原理

其实当你要去查看一个框架的底层实现原理的时候,最难的就是找入口,你首先要找到该从哪里开始分析,这是最难。在这里我分享二个我看源码的小技巧

首先看注解,比如我们这里的启动类上的@EnableRetry

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@EnableAspectJAutoProxy(proxyTargetClass = false)
//注解里我们尤其要关注@Import注解,因为这是Spring将一个Bean注入到容器中的
@Import(RetryConfiguration.class)
@Documented
public @interface EnableRetry {
   /**
    * Indicate whether subclass-based (CGLIB) proxies are to be created as opposed to
    * standard Java interface-based proxies. The default is {@code false}.
    * @return whether to proxy or not to proxy the class
    */
   boolean proxyTargetClass() default false;
}

RetryConfiguration.class实现了InitializingBean接口,那么在这个类初始化之后就会调用afterPropertiesSet()方法

但是看了这个方法之后,我们也很难找到入口的地方,唯一能看到的就是构建AOP的切面和通知

@Override
public void afterPropertiesSet() throws Exception {
   this.retryContextCache = findBean(RetryContextCache.class);
   this.methodArgumentsKeyGenerator = findBean(MethodArgumentsKeyGenerator.class);
   this.newMethodArgumentsIdentifier = findBean(NewMethodArgumentsIdentifier.class);
   this.retryListeners = findBeans(RetryListener.class);
   this.sleeper = findBean(Sleeper.class);
   Set<Class<? extends Annotation>> retryableAnnotationTypes = new LinkedHashSet<Class<? extends Annotation>>(1);
   retryableAnnotationTypes.add(Retryable.class);
   //构建AOP切面和通知
   this.pointcut = buildPointcut(retryableAnnotationTypes);
   this.advice = buildAdvice();
   if (this.advice instanceof BeanFactoryAware) {
      ((BeanFactoryAware) this.advice).setBeanFactory(this.beanFactory);
   }
}

既然我们从注解不能找到入口,那么就从日志入手

看日志

通过日志我们可以看到 RetryOperationsInterceptor.invoke()这段方法,那么在执行重试的时候,肯定也调用这个方法,所以我们直接进入到这个类中,RetryOperationsInterceptor本质是一个拦截器,从类名我们可以推断出,这个拦截器就是拦截有@Retryable注解的方法

所以我们可以直接关注拦截器的核心方法invoke()

@Override
public Object invoke(final MethodInvocation invocation) throws Throwable {
   String name;
   if (StringUtils.hasText(this.label)) {
      name = this.label;
   }
   else {
      name = invocation.getMethod().toGenericString();
   }
   final String label = name;
   //初始化重试机制的回调函数,这里是重点,在重试执行我们的业务逻辑的时候,就会进入到
   //这里回调函数中,然后执行doWithRetry()方法,但是第一次只是初始化,并不会进入到这里面
   RetryCallback<Object, Throwable> retryCallback = new MethodInvocationRetryCallback<Object, Throwable>(
         invocation, label) {
      @Override
      public Object doWithRetry(RetryContext context) throws Exception {
         context.setAttribute(RetryContext.NAME, this.label);
         if (this.invocation instanceof ProxyMethodInvocation) {
            context.setAttribute("___proxy___", ((ProxyMethodInvocation) this.invocation).getProxy());
            try {
               return ((ProxyMethodInvocation) this.invocation).invocableClone().proceed();
            }
            catch (Exception e) {
               throw e;
            }
            catch (Error e) {
               throw e;
            }
            catch (Throwable e) {
               throw new IllegalStateException(e);
            }
         }
         else {
            throw new IllegalStateException(
                  "MethodInvocation of the wrong type detected - this should not happen with Spring AOP, "
                        + "so please raise an issue if you see this exception");
         }
      }
   };
   //还记得我们在自己RetryServiceImpl中实现了一个方法recover(),并且用@Recover标记
   //如果我们实现了这个方法,那么this.recoverer就不为空,就会进入到if分支里面去
   //最后调用this.retryOperations.execute()方法
   if (this.recoverer != null) {
      ItemRecovererCallback recoveryCallback = new ItemRecovererCallback(invocation.getArguments(),
            this.recoverer);
      try {
         Object recovered = this.retryOperations.execute(retryCallback, recoveryCallback);
         return recovered;
      }
      finally {
         RetryContext context = RetrySynchronizationManager.getContext();
         if (context != null) {
            context.removeAttribute("__proxy__");
         }
      }
   }
   //如果我们自己没有实现recover()方法,那么this.recoverer就等于null,就会直接进入到这里面来了
   return this.retryOperations.execute(retryCallback);
}
public final <T, E extends Throwable> T execute(RetryCallback<T, E> retryCallback,
      RecoveryCallback<T> recoveryCallback) throws E {
   //继续进入doExecute方法
   return doExecute(retryCallback, recoveryCallback, null);
}
protected <T, E extends Throwable> T doExecute(RetryCallback<T, E> retryCallback,
      RecoveryCallback<T> recoveryCallback, RetryState state) throws E, ExhaustedRetryException {
   //RetryPolicy这个对象包含二个属性
   //maxAttempts:也就是重试的最大次数,当达到这个次数之后就不会再次重试了
   //retryableClassifier:还记得我们加在方法上的@Retryable(value = RuntimeException.class,maxAttempts = 3,backoff = @Backoff(delay = 2000,multiplier = 1.5))
   //这里设置了一个异常类型,表示的是只有返回的是这个类型的异常才会进行重试
   //如果返回的是其它类型的异常就不会进行重试,所以retryableClassifier这个值就是保存注解
   //里面value设置的异常类型
   RetryPolicy retryPolicy = this.retryPolicy;
   BackOffPolicy backOffPolicy = this.backOffPolicy;
   //初始化我们当前线程重试的上下文
   //在上下文中有一个很重的属性count,初始化的时候这个值为0,后续重试一次,这个值就会加1
   RetryContext context = open(retryPolicy, state);
   //将上下文保存到ThreadLocal中,也是防止并发安全
   RetrySynchronizationManager.register(context);
   Throwable lastException = null;
   boolean exhausted = false;
   try {
      // 给客户一个机会来增强上下文。。。,这里不是重点
      boolean running = doOpenInterceptors(retryCallback, context);
      if (!running) {
         throw new TerminatedRetryException("Retry terminated abnormally by interceptor before first attempt");
      }
      BackOffContext backOffContext = null;
      Object resource = context.getAttribute("backOffContext");
      if (resource instanceof BackOffContext) {
         backOffContext = (BackOffContext) resource;
      }
      if (backOffContext == null) {
         backOffContext = backOffPolicy.start(context);
         if (backOffContext != null) {
            context.setAttribute("backOffContext", backOffContext);
         }
      }
     //核心方法
     //这里就是重试机制实现的核心实现,首先这里是一个while循环
     //我们看第一个方法canRetry(retryPolicy, context),意思就是是否可以重试
      while (canRetry(retryPolicy, context) && !context.isExhaustedOnly()) {
         try {
            lastException = null;
            //如果可以重试,就会执行doWithRetry()方法
            //在之前我们分析RetryOperationsInterceptor类中的invoke()方法的时候,在那里
            //已经实现了回调方法,所以此时就会进入到那个回调方法中
            return retryCallback.doWithRetry(context);
         }
         catch (Throwable e) {
            lastException = e;
            try {
               registerThrowable(retryPolicy, state, context, e);
            }
            catch (Exception ex) {
               throw new TerminatedRetryException("Could not register throwable", ex);
            }
            finally {
               doOnErrorInterceptors(retryCallback, context, e);
            }
            if (canRetry(retryPolicy, context) && !context.isExhaustedOnly()) {
               try {
                  backOffPolicy.backOff(backOffContext);
               }
               catch (BackOffInterruptedException ex) {
                  lastException = e;
                  throw ex;
               }
            }
            if (shouldRethrow(retryPolicy, context, state)) {
               if (this.logger.isDebugEnabled()) {
                  this.logger.debug("Rethrow in retry for policy: count=" + context.getRetryCount());
               }
               throw RetryTemplate.<E>wrapIfNecessary(e);
            }
         }
         if (state != null && context.hasAttribute(GLOBAL_STATE)) {
            break;
         }
      }
      exhausted = true;
      return handleRetryExhausted(recoveryCallback, context, state);
   }
   catch (Throwable e) {
      throw RetryTemplate.<E>wrapIfNecessary(e);
   }
   finally {
      //清除上下文信息
      close(retryPolicy, context, state, lastException == null || exhausted);
      doCloseInterceptors(retryCallback, context, lastException);
      //将ThreadLocal中的上下文信息清除1掉
      RetrySynchronizationManager.clear();
   }
}

在上述中我们发现有两个核心的方法,一个就是 canRetry(retryPolicy, context),还有一个就是retryCallback.doWithRetry(context);

protected boolean canRetry(RetryPolicy retryPolicy, RetryContext context) {
   //进入这个方法
   return retryPolicy.canRetry(context);
}

具体的实现类是SimpleRetryPolicy

public boolean canRetry(RetryContext context) {
   Throwable t = context.getLastThrowable();
   //retryForException(t):判断返回的异常是否跟我们注解设置的异常类型一致,
   //                      在分析RetryPolicy对象中有个属性就保存了我们注解设置的异常类型
   //context.getRetryCount() < getMaxAttempts():重试次数是否已经达到了我们设置的最大次数
   return (t == null || retryForException(t)) && context.getRetryCount() < getMaxAttempts();
}

如果返回的异常类型与我们设置的一样,并且重试次数还没有达到,那么就会进入到while循环中执行retryCallback.doWithRetry(context);方法

//这段代码就是RetryOperationsInterceptor拦截器中的invoke()方法,我把这段代码截取出来了
RetryCallback<Object, Throwable> retryCallback = new MethodInvocationRetryCallback<Object, Throwable>(invocation, name) {
    //执行这段方法
    public Object doWithRetry(RetryContext context) throws Exception {
        context.setAttribute("context.name", this.label);
        if (this.invocation instanceof ProxyMethodInvocation) {
            context.setAttribute("___proxy___", ((ProxyMethodInvocation)this.invocation).getProxy());
            try {
                // 这里就是执行我们自己的业务逻辑了,如果有异常就抛出,然后在重试机制的
                // while循环中捕获,继而判断异常是否符合并且重试次数是否达到,如果条件符合
                //就继续重试执行,如果不符合,就不会再重试了
                return ((ProxyMethodInvocation)this.invocation).invocableClone().proceed();
            } catch (Exception var3) {
                throw var3;
            } catch (Error var4) {
                throw var4;
            } catch (Throwable var5) {
                throw new IllegalStateException(var5);
            }
        } else {
            throw new IllegalStateException("MethodInvocation of the wrong type detected - this should not happen with Spring AOP, so please raise an issue if you see this exception");
        }
    }
};

所以在我们使用Spring-Retry的时候,设置的异常类型一定要一致,否则这个重试机制就不会生效了

以上就是Spring Retry实现重试机制的示例详解的详细内容,更多关于Spring Retry重试的资料请关注脚本之家其它相关文章!

您可能感兴趣的文章:
阅读全文