SpringRetry重试框架的具体使用

<!-- SpringRetry -->

< dependency >

    < groupId >org.springframework.retry</ groupId >

    < artifactId >spring-retry</ artifactId >

</ dependency >

< dependency >

    < groupId >org.springframework</ groupId >

    < artifactId >spring-aspects</ artifactId >

</ dependency >

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);

}

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, E extends Throwable> T execute(RetryCallback<T, E> 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 <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;

     }

}

@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;

     }

}

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<? extends Throwable>[] 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<? extends Throwable>[] 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<? extends Throwable>[] 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:

   * <pre class=code>

   *  {@code "message.contains('you can retry this')"}.

   * </pre>

   * and

   * <pre class=code>

   *  {@code "@someBean.shouldRetry(#root)"}.

   * </pre>

   * @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()} &gt; 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 <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" ;

     }

}