• 一种退避序列实现

    1. 介绍功能和需求背景
    2. 介绍代码上下文，思路，方案。 
    3. 讲解代码，评委穿插提问。参会的其他同学有问题也可以提。 
    4. 评委对代码给建议和反馈

    写在前面

             你有一个苹果，我有一个苹果，交换一下我们还是只有一个苹果；你有一本书，我有一本书，交换一下我们就有两本书了。每个程序员都有自己的工具集和代码私库，如果大家一起贡献出来，我们就会有一套较完整的工具集，相信可以解决大部分问题。

             作为一个程序员，一个工科生，现实中的理想就是有一套趁手的完整的工具套件，家里有点什么事情，只要拿出我的工具套件就能自己轻松搞定。跟现实中一样，我们中间件团队也在默默的打造自己的软件工具套件，也希望更多的同学一起来打造这一套称心的软件工具套件。

    一、需求背景

    1.1 业务需求

    1.1.1 Nebulax流程实例保存失败重试和告警

    1. 流程执行完后会将流程实例调用http接口上报到星云服务端，若星云服务端不可用，不会发起重试，导致流程虽然执行完成，但是在控制台查看不到对应流程实例信息。
    2.  
    3. - 改造成上报失败按(指数退避算法)策略，在一段时间后重试，确保流程实例能够上传到服务端
    4. - 若上传失败，在尝试若干次后记录日志并发送告警给对应业务负责人

    1.1.2 模拟MetaQ失败退避算法

    网关应用原先依赖MetaQ,改造升级后内部的重试策略也是继承一致的重试策略，按固定级别(1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h)退避。

    1.1.3 延迟调度平台重试策略优化

    • 发送消息时设置重试策略，目前支持两种重试策略

    1、【普通模式】：默认模式，强烈建议用该模式，该模式间隔会逐步递增（5s，10s，30s，60s... 逐渐递增，总周期为7天，总共20次）。

    2、【表达式模式】：

    距离上次重试的时间间隔 = 首次重试间隔 + 已重试次数 * 重试时间间隔步长 * 首次重试间隔（秒）

    在表达式模式的策略下，最大重试、首次重试间隔和步长才会生效。注意普通模式下，以下参数不生效。

    ​

    • 调度限流重试策略

    1. 主动限流使用随机数，5~15分钟

    1. jobDetail.setRedoIntervalMode(RedoIntervalModeConstant.EXPRESSION);
    2. // 最大重试次数,默认99次 
    3. jobDetail.setFailRedoCountMax(10);
    4. // 首次重试间隔(秒)
    5. jobDetail.setFailFirstRedoInterval(5);
    6. // 重试时间间隔步长，如设置成0，则每次重试间隔相同，如设置成1，则间隔是5、10、15...
    7. jobDetail.setFailRedoIntervalStep(0);

    ​

    1.2 需求整理

    • 根据策略获取下一次重试间隔

    • 根据策略获取指定次数的重试间隔

    • 多种退避算法，如指数退避、固定步长、等差数列、自定义固定级别退避，以及不退避。

    • 可以设置最大重试间隔，如最大重试间隔不能超过1小时

    • 可以设置最大重试次数，如最大重试20次

    • 可以获取当前重试次数，即已经执行了几次

    • 可以获取从开始到当前流逝的全部时间

    • 可以获取从开始到指定次数流逝的全部时间

    • 标准化重试策略和接口，方便延迟调度平台使用

    ​

    ​

    二 方案调研

    2.1 Guava实现

    1. <dependency>
    2.     <groupId>com.github.rholder</groupId>
    3.     <artifactId>guava-retrying</artifactId>
    4.     <version>1.0.6</version>
    5. </dependency>

    详见: guava-retrying by rholder

    2.2 Spring实现

    1. <dependency> 
    2.       <groupId>org.springframework</groupId>  
    3.       <artifactId>spring-core</artifactId> 
    4.       <version>4.3.17.RELEASE<version>
    5. </dependency> 

    1. public interface BackOff {
    2.  
    3. 	/**
    4. 	 * Start a new back off execution.
    5. 	 * @return a fresh {@link BackOffExecution} ready to be used
    6. 	 */
    7. 	BackOffExecution start();
    8.  
    9. }
    1. package org.springframework.util.backoff;
    2.  
    3. /**
    4.  * Represent a particular back-off execution.
    5.  *
    6.  * 
      Implementations do not need to be thread safe.
    7.  *
    8.  * @author Stephane Nicoll
    9.  * @since 4.1
    10.  * @see BackOff
    11.  */
    12. public interface BackOffExecution {
    13.  
    14. 	/**
    15. 	 * Return value of {@link #nextBackOff()} that indicates that the operation
    16. 	 * should not be retried.
    17. 	 */
    18. 	long STOP = -1;
    19.  
    20. 	/**
    21. 	 * Return the number of milliseconds to wait before retrying the operation
    22. 	 * or {@link #STOP} ({@value #STOP}) to indicate that no further attempt
    23. 	 * should be made for the operation.
    24. 	 */
    25. 	long nextBackOff();
    26.  
    27. }

    三、我们的方案

    2.2.1 基于Spring实现扩展

    1. package com.xxx.commons.retry.backoff;
    2.  
    3. /**
    4.  * @created 2021-12-20 4:26 PM
    5.  * @description:
    6.  */
    7. public interface Backoff {
    8.  
    9.     /**
    10.      * 开始
    11.      *
    12.      * @return
    13.      */
    14.     BackoffExecution start();
    15.  
    16. }
    1. package com.xxx.commons.retry.backoff;
    2.  
    3. import java.util.concurrent.TimeUnit;
    4.  
    5. /**
    6.  * @created 2021-12-20 4:26 PM
    7.  * @description:
    8.  */
    9. public interface BackoffExecution {
    10.     /**
    11.      * 不再重试时返回的值
    12.      */
    13.     long STOP = -1;
    14.  
    15.     /**
    16.      * The default time unit
    17.      */
    18.     TimeUnit DEFAULT_TIME_UNIT = TimeUnit.MILLISECONDS;
    19.  
    20.     /**
    21.      * 下一次退避时间
    22.      *
    23.      * @return nextBackoff 下一次重试延迟时间(毫秒)，不再重试时返回{@link #STOP} ({@value #STOP})
    24.      */
    25.     long nextBackoff();
    26.  
    27.     /**
    28.      * 根据重试次数获取指定次数的退避时间
    29.      *
    30.      * @param attempt
    31.      * @return
    32.      */
    33.     long getBackoff(int attempt);
    34.  
    35.     /**
    36.      * 从开始到现在一共经过的时间
    37.      *
    38.      * @return
    39.      */
    40.     long getElapsedTime();
    41.  
    42.     /**
    43.      * 从开始到指定次数一共经过的时间
    44.      *
    45.      * @param attempt
    46.      * @return
    47.      */
    48.     long getElapsedTime(int attempt);
    49.  
    50.     /**
    51.      * 当前尝试次数
    52.      *
    53.      * @return currentAttempt
    54.      */
    55.     int currentAttempt();
    56.  
    57. }

    2.2.2 代码清单

    接口与类

    功能说明

    备注说明

    com.xxx.commons.retry.RetryService

    重试服务工具类

    com.xxx.commons.retry.backoff.Backoff

    退避算法定义接口

    com.xxx.commons.retry.backoff.BackoffExecution

    退避算法执行接口

    com.xxx.commons.retry.backoff.BackoffType

    退避算法类型接口

    com.xxx.commons.retry.backoff.BackoffTypeEnum

    退避算法类型枚举类

    com.xxx.commons.retry.backoff.CustomBackoff

    自定义序列退避算法实现

    com.xxx.commons.retry.backoff.ExponentialBackoff

    指数退避算法实现

    com.xxx.commons.retry.backoff.FixedBackoff

    固定步长退避算法实现

    com.xxx.commons.retry.backoff.GradualBackoff

    等差数列退避算法实现

    com.xxx.commons.retry.backoff.NoneBackoff

    不退避算法实现

    com.xxx.commons.retry.backoff.FibonacciBackoff

    裴波那契退避算法实现

    暂未实现

    1. package com.xxx.commons.retry.backoff;
    2.  
    3. /**
    4.  * @created 2021-12-31 3:24 PM
    5.  * @description:
    6.  */
    7. public interface BackoffType {
    8.  
    9.     /**
    10.      * 类型编码
    11.      *
    12.      * @return
    13.      */
    14.     int getCode();
    15.  
    16.     /**
    17.      * 类型名字
    18.      *
    19.      * @return
    20.      */
    21.     String getName();
    22.  
    23.     /**
    24.      * 类型说明
    25.      *
    26.      * @return
    27.      */
    28.     String getDesc();
    29. }
    1. package com.xxx.commons.retry.backoff;
    2.  
    3. /**
    4.  * 重试补偿步长类型
    5.  *
    6.  * @created 2021-12-20 4:29 PM
    7.  * @description:
    8.  */
    9. public enum BackoffTypeEnum implements BackoffType {
    10.     /**
    11.      * 无补偿
    12.      **/
    13.     NONE(0, "none", "无补偿"),
    14.  
    15.     /**
    16.      * 固定步长
    17.      **/
    18.     FIXED(1, "fixed", "固定步长"),
    19.  
    20.     /**
    21.      * 等差步长
    22.      */
    23.     GRADUAL(2, "gradual", "等差步长"),
    24.  
    25.     /**
    26.      * 指数退避
    27.      **/
    28.     EXPONENTIAL(3, "exponential", "指数退避"),
    29.  
    30.     /**
    31.      * 自定义步长
    32.      */
    33.     CUSTOM(4, "custom", "自定义步长"),
    34.  
    35.     ;
    36.  
    37.     private int code;
    38.     private String name;
    39.     private String desc;
    40.  
    41.     BackoffTypeEnum(int code, String name, String desc) {
    42.         this.code = code;
    43.         this.name = name;
    44.         this.desc = desc;
    45.     }
    46.  
    47.     public static BackoffTypeEnum typeOf(int code) {
    48.         for (BackoffTypeEnum type : BackoffTypeEnum.values()) {
    49.             if (type.code == code) {
    50.                 return type;
    51.             }
    52.         }
    53.         return null;
    54.     }
    55.  
    56.     @Override
    57.     public int getCode() {
    58.         return code;
    59.     }
    60.  
    61.     @Override
    62.     public String getName() {
    63.         return name;
    64.     }
    65.  
    66.     @Override
    67.     public String getDesc() {
    68.         return desc;
    69.     }
    70. }
    1. package com.xxx.commons.retry;
    2.  
    3. /**
    4.  * @created 2021-12-31 3:21 PM
    5.  * @description:
    6.  */
    7.  
    8. import com.xxx.commons.retry.backoff.*;
    9. import org.slf4j.Logger;
    10. import org.slf4j.LoggerFactory;
    11.  
    12. import java.util.ArrayList;
    13. import java.util.Collections;
    14. import java.util.List;
    15. import java.util.concurrent.*;
    16.  
    17. public class RetryService {
    18.  
    19.     static {
    20.         Runtime.getRuntime().addShutdownHook(RetryServiceShutdownHook.instance());
    21.     }
    22.  
    23.     /**
    24.      * 重试线程池大小
    25.      */
    26.     public static final int RETRY_CORE_POOL_SIZE = Integer.getInteger(
    27.             RetryConstants.DEFAULT_RETRY_SERVICE_SCHEDULED_THREAD_POOL_SIZE_KEY,
    28.             RetryConstants.DEFAULT_RETRY_SERVICE_SCHEDULED_THREAD_POOL_DEFAULT_SIZE);
    29.  
    30.     /**
    31.      * 重试服务线程池
    32.      */
    33.     final ScheduledExecutorService executor = new ScheduledThreadPoolExecutor(RETRY_CORE_POOL_SIZE);
    34.  
    35.     private static final RetryService instance = new RetryService();
    36.  
    37.     public static RetryService getInstance() {
    38.         return instance;
    39.     }
    40.  
    41.     private RetryService() {
    42.         RetryServiceShutdownHook.instance().addExecutor(executor);
    43.     }
    44.  
    45.     public ScheduledFuture retry(Callable callable, long delay) {
    46.         return executor.schedule(callable, delay, BackoffExecution.DEFAULT_TIME_UNIT);
    47.     }
    48.  
    49.     public ScheduledFuture retry(Runnable runnable, long delay) {
    50.         return executor.schedule(runnable, delay, BackoffExecution.DEFAULT_TIME_UNIT);
    51.     }
    52.  
    53.     public ScheduledFuture retry(Callable callable, long delay, TimeUnit unit) {
    54.         return executor.schedule(callable, delay, unit);
    55.     }
    56.  
    57.     public ScheduledFuture retry(Runnable runnable, long delay, TimeUnit unit) {
    58.         return executor.schedule(runnable, delay, unit);
    59.     }
    60.  
    61.     public interface RetryConstants {
    62.         String DEFAULT_RETRY_SERVICE_SCHEDULED_THREAD_POOL_SIZE_KEY = "default.retry.service.scheduled.thread.pool.size";
    63.         int DEFAULT_RETRY_SERVICE_SCHEDULED_THREAD_POOL_DEFAULT_SIZE = 8;
    64.     }
    65.  
    66.     static class RetryServiceShutdownHook extends Thread {
    67.  
    68.         private final Logger logger = LoggerFactory.getLogger(this.getClass());
    69.  
    70.         private List executors = Collections.synchronizedList(new ArrayList());
    71.         private final static RetryServiceShutdownHook instance = new RetryServiceShutdownHook();
    72.  
    73.         public static RetryServiceShutdownHook instance() {
    74.             return instance;
    75.         }
    76.  
    77.         private RetryServiceShutdownHook() {
    78.         }
    79.  
    80.         public RetryServiceShutdownHook addExecutor(ExecutorService executor) {
    81.             executors.add(executor);
    82.             return this;
    83.         }
    84.  
    85.         @Override
    86.         public void run() {
    87.             logger.info("retry service shutdown");
    88.  
    89.             for (int i = 0; i < executors.size(); i++) {
    90.                 ExecutorService executorService = executors.get(i);
    91.                 try {
    92.                     if (!executorService.isShutdown()) {
    93.                         executorService.shutdown();
    94.                     }
    95.                 } catch (Exception e) {
    96.                     logger.error("retry service shutdown executor service error", e.getMessage());
    97.                 }
    98.             }
    99.         }
    100.     }
    101.  
    102.  
    103. }

    1. package com.xxx.commons.retry.backoff;
    2.  
    3.  
    4. import com.xxx.commons.data.constant.CommonConstants;
    5.  
    6. import java.io.Serializable;
    7. import java.util.ArrayList;
    8. import java.util.HashMap;
    9. import java.util.List;
    10.  
    11. /**
    12.  * @created 2021-12-27 9:47 AM
    13.  * @description: 自定义序列退避算法实现
    14.  */
    15. public class CustomBackoff implements Backoff, Serializable {
    16.  
    17.     private static final long serialVersionUID = 5677908306014056187L;
    18.  
    19.     public static final String DEFAULT_SEPARATOR = CommonConstants.SPACE_SEPARATOR;
    20.     public static final String LEFT_BRACKET = "{";
    21.     public static final String RIGHT_BRACKET = "}";
    22.  
    23.     /**
    24.      * Constant value indicating an unlimited number of attempt.
    25.      */
    26.     public static final int UNLIMITED_ATTEMPTS = Integer.MAX_VALUE;
    27.  
    28.     /**
    29.      * 默认退避时间序列
    30.      * 示例1:1  2  3  10  10  10  30  60 120 180 600 1800 3600  3600  3600  3600  3600  3600
    31.      * 示例2:1s 2s 3s 10s 10s 10s 30s 1m 2m  3m  10m 30m  1h    1h    1h    1h    1h    1h
    32.      * 示例3:1  2  3  10{3}       30  60 120 180 600 1800 3600{6}
    33.      * 示例4:1s 2s 3s 10s{3}      30s 1m 2m  3m  10m 30m  1h{6}
    34.      */
    35.     public static final String DEFAULT_SEQUENCE = "1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h{64}";
    36.  
    37.  
    38.     /**
    39.      * 自定义退避序列
    40.      */
    41.     private String sequence = DEFAULT_SEQUENCE;
    42.  
    43.     /**
    44.      * 最大尝试次数
    45.      */
    46.     private int maxAttempt = UNLIMITED_ATTEMPTS;
    47.  
    48.     /**
    49.      * 自定义序列分隔符
    50.      */
    51.     private String separator = DEFAULT_SEPARATOR;
    52.  
    53.  
    54.     /**
    55.      * Create an instance with an sequence with DEFAULT.
    56.      */
    57.     public CustomBackoff() {
    58.     }
    59.  
    60.     /**
    61.      * Create an instance.
    62.      *
    63.      * @param sequence the origin sequence
    64.      */
    65.     public CustomBackoff(String sequence) {
    66.         this.sequence = sequence;
    67.     }
    68.  
    69.     public CustomBackoff(String sequence, String separator) {
    70.         this.sequence = sequence;
    71.         this.separator = separator;
    72.     }
    73.  
    74.     public CustomBackoff(int maxAttempt) {
    75.         this.maxAttempt = maxAttempt;
    76.     }
    77.  
    78.     public CustomBackoff(String sequence, int maxAttempt) {
    79.         this.sequence = sequence;
    80.         this.maxAttempt = maxAttempt;
    81.     }
    82.  
    83.     /**
    84.      * @param sequence   the origin sequence
    85.      * @param maxAttempt the maximum number of attempt
    86.      * @param separator  the sequence's separator
    87.      */
    88.     public CustomBackoff(String sequence, int maxAttempt, String separator) {
    89.         this.sequence = sequence;
    90.         this.maxAttempt = maxAttempt;
    91.         this.separator = separator;
    92.     }
    93.  
    94.     /**
    95.      * Set the maximum number of attempt in milliseconds.
    96.      */
    97.     public void setMaxAttempt(int maxAttempt) {
    98.         this.maxAttempt = maxAttempt;
    99.     }
    100.  
    101.     /**
    102.      * Return the maximum number of attempt in milliseconds.
    103.      */
    104.     public int getMaxAttempt() {
    105.         return maxAttempt;
    106.     }
    107.  
    108.     public String getSeparator() {
    109.         return separator;
    110.     }
    111.  
    112.     public void setSeparator(String separator) {
    113.         this.separator = separator;
    114.     }
    115.  
    116.     @Override
    117.     public BackoffExecution start() {
    118.         return new CustomBackoffExecution(this.sequence, this.maxAttempt, this.separator);
    119.     }
    120.  
    121.     public static class CustomBackoffExecution implements BackoffExecution, Serializable {
    122.  
    123.         private static final long serialVersionUID = 2991013977130023823L;
    124.  
    125.         /**
    126.          * 自定义退避序列
    127.          */
    128.         private String sequence;
    129.  
    130.         /**
    131.          * 最大尝试次数
    132.          */
    133.         private int maxAttempt;
    134.  
    135.         /**
    136.          * 自定义序列分隔符
    137.          */
    138.         private String separator;
    139.  
    140.         /**
    141.          * 解析后的退避时间间隔列表
    142.          */
    143.         private List intervals;
    144.  
    145.         private long currentElapsedTime = 0;
    146.  
    147.         private int currentAttempt = 0;
    148.  
    149.         public CustomBackoffExecution() {
    150.             this(DEFAULT_SEQUENCE, UNLIMITED_ATTEMPTS, DEFAULT_SEPARATOR);
    151.         }
    152.  
    153.         public CustomBackoffExecution(String sequence, int maxAttempt, String separator) {
    154.             this.sequence = sequence;
    155.             this.maxAttempt = maxAttempt;
    156.             this.separator = separator;
    157.             this.parse();
    158.         }
    159.  
    160.         private void parse() {
    161.             intervals = new ArrayList<>();
    162.  
    163.             HashMap timeUnitTable = new HashMap();
    164.             timeUnitTable.put("s", 1000L);
    165.             timeUnitTable.put("m", 1000L * 60);
    166.             timeUnitTable.put("h", 1000L * 60 * 60);
    167.             timeUnitTable.put("d", 1000L * 60 * 60 * 24);
    168.  
    169.             String[] fields = sequence.split(separator);
    170.             boolean completed = false;
    171.             for (String field : fields) {
    172.                 field = field.trim();
    173.                 int count = 1;
    174.                 long multiple = 1;
    175.                 int leftBracket = field.indexOf(CustomBackoff.LEFT_BRACKET);
    176.                 int rightBracket = field.indexOf(CustomBackoff.RIGHT_BRACKET);
    177.                 if (leftBracket > 0 && rightBracket > 0) {
    178.                     count = Integer.parseInt(field.substring(leftBracket + 1, rightBracket));
    179.                     field = field.substring(0, leftBracket);
    180.                 }
    181.                 Long unit = timeUnitTable.get(String.valueOf(field.charAt(field.length() - 1)));
    182.                 if (unit != null) {
    183.                     multiple = unit.longValue();
    184.                     field = field.substring(0, field.length() - 1);
    185.                 }
    186.                 long timeInMills = Long.parseLong(field) * multiple;
    187.                 for (int i = 0; i < count; i++) {
    188.                     if (this.intervals.size() < this.maxAttempt) {
    189.                         this.intervals.add(timeInMills);
    190.                     } else {
    191.                         completed = true;
    192.                     }
    193.                 }
    194.                 if (completed) {
    195.                     break;
    196.                 }
    197.             }
    198.             // if maxAttempt greater than intervals's size, then set intervals's size as maxAttempt
    199.             if (this.intervals.size() < this.maxAttempt) {
    200.                 this.maxAttempt = this.intervals.size();
    201.             }
    202.         }
    203.  
    204.         @Override
    205.         public int currentAttempt() {
    206.             return currentAttempt;
    207.         }
    208.  
    209.         @Override
    210.         public long getElapsedTime() {
    211.             return this.currentElapsedTime;
    212.         }
    213.  
    214.         @Override
    215.         public long nextBackoff() {
    216.  
    217.             if (currentAttempt >= maxAttempt) {
    218.                 return STOP;
    219.             }
    220.  
    221.             if (currentAttempt >= this.intervals.size()) {
    222.                 return STOP;
    223.             }
    224.  
    225.             long nextInterval = this.intervals.get(this.currentAttempt);
    226.             this.currentElapsedTime += nextInterval;
    227.             this.currentAttempt += 1;
    228.             return nextInterval;
    229.         }
    230.  
    231.         @Override
    232.         public void updateCurrentAttempt(int attempt) {
    233.             if (attempt < 0) {
    234.                 this.currentAttempt = 0;
    235.             } else if (attempt >= maxAttempt) {
    236.                 this.currentAttempt = maxAttempt;
    237.             } else {
    238.                 this.currentAttempt = attempt;
    239.             }
    240.             this.currentElapsedTime = this.getElapsedTime(this.currentAttempt);
    241.         }
    242.  
    243.         @Override
    244.         public long getBackoff(int attempt) {
    245.  
    246.             if (attempt <= 0) {
    247.                 return 0L;
    248.             }
    249.  
    250.             if (attempt - 1 >= maxAttempt) {
    251.                 return STOP;
    252.             }
    253.  
    254.             if (attempt > this.intervals.size()) {
    255.                 return STOP;
    256.             }
    257.  
    258.             return this.intervals.get(attempt - 1);
    259.         }
    260.  
    261.         @Override
    262.         public long getElapsedTime(int attempt) {
    263.             if (attempt >= maxAttempt) {
    264.                 attempt = maxAttempt;
    265.             }
    266.  
    267.             if (attempt >= this.intervals.size()) {
    268.                 attempt = this.intervals.size();
    269.             }
    270.             long elapsedTime = 0;
    271.             for (int i = 0; i < attempt; i++) {
    272.                 elapsedTime += this.intervals.get(i);
    273.             }
    274.  
    275.             return elapsedTime;
    276.         }
    277.  
    278.         public String getSequence() {
    279.             return sequence;
    280.         }
    281.  
    282.         public void setSequence(String sequence) {
    283.             this.sequence = sequence;
    284.         }
    285.  
    286.         @Override
    287.         public int getMaxAttempt() {
    288.             return maxAttempt;
    289.         }
    290.  
    291.         @Override
    292.         public void setMaxAttempt(int maxAttempt) {
    293.             this.maxAttempt = maxAttempt;
    294.         }
    295.  
    296.         public String getSeparator() {
    297.             return separator;
    298.         }
    299.  
    300.         public void setSeparator(String separator) {
    301.             this.separator = separator;
    302.         }
    303.  
    304.         public List getIntervals() {
    305.             return intervals;
    306.         }
    307.  
    308.         public void setIntervals(List intervals) {
    309.             this.intervals = intervals;
    310.         }
    311.  
    312.         public long getCurrentElapsedTime() {
    313.             return currentElapsedTime;
    314.         }
    315.  
    316.         public void setCurrentElapsedTime(long currentElapsedTime) {
    317.             this.currentElapsedTime = currentElapsedTime;
    318.         }
    319.  
    320.         public int getCurrentAttempt() {
    321.             return currentAttempt;
    322.         }
    323.  
    324.         public void setCurrentAttempt(int currentAttempt) {
    325.             this.currentAttempt = currentAttempt;
    326.         }
    327.  
    328.         @Override
    329.         public String toString() {
    330.             final StringBuilder sb = new StringBuilder("CustomBackoff{");
    331.             sb.append("intervals=").append(intervals);
    332.             String attemptValue = (maxAttempt == Integer.MAX_VALUE ?
    333.                     "unlimited" : String.valueOf(maxAttempt));
    334.             sb.append(", maxAttempt=").append(attemptValue);
    335.             sb.append(", currentElapsedTime=").append(currentElapsedTime);
    336.             sb.append(", currentAttempt=").append(this.currentAttempt);
    337.             sb.append('}');
    338.             return sb.toString();
    339.         }
    340.     }
    341.  
    342.     public static void main(String[] args) {
    343.         BackoffExecution backoffExecution = new CustomBackoff().start();
    344.         System.out.println(backoffExecution.getBackoff(1));
    345.         System.out.println(backoffExecution.getBackoff(2));
    346.         System.out.println(backoffExecution.getBackoff(3));
    347.         System.out.println(backoffExecution.getElapsedTime(1));
    348.         System.out.println(backoffExecution.getElapsedTime(2));
    349.         System.out.println(backoffExecution.getElapsedTime(3));
    350.     }
    351.  
    352. }

    ​

    1. package com.xxx.commons.retry.backoff;
    2.  
    3. import java.io.Serializable;
    4. import java.util.concurrent.TimeUnit;
    5.  
    6. /**
    7.  * @created 2021-12-20 4:31 PM
    8.  * @description:
    9.  */
    10. public class ExponentialBackoff implements Backoff, Serializable {
    11.  
    12.     private static final long serialVersionUID = -3955367506662250971L;
    13.  
    14.     /**
    15.      * The default initial interval.
    16.      */
    17.     public static final long DEFAULT_INITIAL_INTERVAL = 2000L;
    18.  
    19.     /**
    20.      * The default multiplier (increases the interval by 50%).
    21.      */
    22.     public static final double DEFAULT_MULTIPLIER = 2;
    23.  
    24.     /**
    25.      * The default maximum back off time.
    26.      */
    27.     public static final long DEFAULT_MAX_INTERVAL = 10 * 60 * 1000L;
    28.  
    29.     /**
    30.      * Constant value indicating an unlimited number of attempt.
    31.      */
    32.     public static final int UNLIMITED_ATTEMPTS = Integer.MAX_VALUE;
    33.  
    34.     private long initialInterval = DEFAULT_INITIAL_INTERVAL;
    35.  
    36.     private double multiplier = DEFAULT_MULTIPLIER;
    37.  
    38.     private long maxInterval = DEFAULT_MAX_INTERVAL;
    39.  
    40.     private int maxAttempt = UNLIMITED_ATTEMPTS;
    41.  
    42.     /**
    43.      * Create an instance with the default settings.
    44.      *
    45.      * @see #DEFAULT_INITIAL_INTERVAL
    46.      * @see #DEFAULT_MULTIPLIER
    47.      * @see #DEFAULT_MAX_INTERVAL
    48.      */
    49.     public ExponentialBackoff() {
    50.     }
    51.  
    52.     /**
    53.      * Create an instance.
    54.      *
    55.      * @param maxAttempt the maximum number of attempt
    56.      */
    57.     public ExponentialBackoff(int maxAttempt) {
    58.         this.maxAttempt = maxAttempt;
    59.     }
    60.  
    61.     /**
    62.      * Create an instance with the supplied settings.
    63.      *
    64.      * @param initialInterval the initial interval in milliseconds
    65.      */
    66.     public ExponentialBackoff(long initialInterval) {
    67.         this.initialInterval = initialInterval;
    68.         this.checkInterval(this.initialInterval, this.maxInterval);
    69.     }
    70.  
    71.     /**
    72.      * Create an instance with the supplied settings.
    73.      *
    74.      * @param initialInterval the initial interval
    75.      * @param timeUnit        the initial interval's time unit
    76.      * @param multiplier      the multiplier (should be greater than or equal to 1)
    77.      */
    78.     public ExponentialBackoff(long initialInterval, TimeUnit timeUnit, double multiplier) {
    79.         checkMultiplier(multiplier);
    80.         this.multiplier = multiplier;
    81.         this.initialInterval = BackoffExecution.DEFAULT_TIME_UNIT.convert(initialInterval, timeUnit);
    82.         this.checkInterval(this.initialInterval, this.maxInterval);
    83.     }
    84.  
    85.     public ExponentialBackoff(long initialInterval, long maxInterval, TimeUnit timeUnit, double multiplier) {
    86.         checkMultiplier(multiplier);
    87.         this.multiplier = multiplier;
    88.         this.initialInterval = BackoffExecution.DEFAULT_TIME_UNIT.convert(initialInterval, timeUnit);
    89.         this.maxInterval = BackoffExecution.DEFAULT_TIME_UNIT.convert(maxInterval, timeUnit);
    90.         this.checkInterval(this.initialInterval, this.maxInterval);
    91.     }
    92.  
    93.     /**
    94.      * The initial interval in milliseconds.
    95.      */
    96.     public void setInitialInterval(long initialInterval) {
    97.         this.initialInterval = initialInterval;
    98.         this.checkInterval(this.initialInterval, this.maxInterval);
    99.     }
    100.  
    101.     /**
    102.      * Return the initial interval in milliseconds.
    103.      */
    104.     public long getInitialInterval() {
    105.         return initialInterval;
    106.     }
    107.  
    108.     /**
    109.      * The value to multiply the current interval by for each retry attempt.
    110.      */
    111.     public void setMultiplier(double multiplier) {
    112.         checkMultiplier(multiplier);
    113.         this.multiplier = multiplier;
    114.     }
    115.  
    116.     /**
    117.      * Return the value to multiply the current interval by for each retry attempt.
    118.      */
    119.     public double getMultiplier() {
    120.         return multiplier;
    121.     }
    122.  
    123.     /**
    124.      * The maximum back off time.
    125.      */
    126.     public void setMaxInterval(long maxInterval) {
    127.         this.maxInterval = maxInterval;
    128.     }
    129.  
    130.     /**
    131.      * Return the maximum back off time.
    132.      */
    133.     public long getMaxInterval() {
    134.         return maxInterval;
    135.     }
    136.  
    137.     /**
    138.      * Set the maximum number of attempt in milliseconds.
    139.      */
    140.     public void setMaxAttempt(int maxAttempt) {
    141.         this.maxAttempt = maxAttempt;
    142.     }
    143.  
    144.     /**
    145.      * Return the maximum number of attempt in milliseconds.
    146.      */
    147.     public int getMaxAttempt() {
    148.         return maxAttempt;
    149.     }
    150.  
    151.     @Override
    152.     public BackoffExecution start() {
    153.         return new ExponentialBackoffExecution(initialInterval, maxInterval, multiplier, maxAttempt);
    154.     }
    155.  
    156.     private void checkMultiplier(double multiplier) {
    157.         if (multiplier < 1) {
    158.             throw new IllegalArgumentException("Invalid multiplier '" + multiplier + "'. Should be equal" +
    159.                     "or higher than 1. A multiplier of 1 is equivalent to a fixed interval");
    160.         }
    161.     }
    162.  
    163.     private void checkInterval(long initialInterval, long maxInterval) {
    164.         if (initialInterval <= 0) {
    165.             throw new IllegalArgumentException("Invalid initialInterval '" + initialInterval + "'. Should be higher" +
    166.                     " than 0. A initialInterval of 0 is equivalent to no interval");
    167.         }
    168.         if (maxInterval <= initialInterval * getMultiplier()) {
    169.             throw new IllegalArgumentException("Invalid maxInterval '" + maxInterval + "'. Should be higher" +
    170.                     " than initialInterval * multiplier. A maxInterval equal or less than initialInterval * multiplier " +
    171.                     "is equivalent to a fixed interval");
    172.         }
    173.     }
    174.  
    175.     public static class ExponentialBackoffExecution implements BackoffExecution, Serializable {
    176.  
    177.         private static final long serialVersionUID = 672748521748221970L;
    178.  
    179.         private long initialInterval;
    180.  
    181.         private double multiplier;
    182.  
    183.         private long maxInterval;
    184.  
    185.         private int maxAttempt;
    186.  
    187.         private long currentInterval = -1;
    188.  
    189.         private long currentElapsedTime = 0;
    190.  
    191.         private int currentAttempt = 0;
    192.  
    193.         public ExponentialBackoffExecution() {
    194.             this(DEFAULT_INITIAL_INTERVAL, DEFAULT_MAX_INTERVAL, DEFAULT_MULTIPLIER, UNLIMITED_ATTEMPTS);
    195.         }
    196.  
    197.         public ExponentialBackoffExecution(long initialInterval, long maxInterval, double multiplier, int maxAttempt) {
    198.             this.initialInterval = initialInterval;
    199.             this.maxInterval = maxInterval;
    200.             this.multiplier = multiplier;
    201.             this.maxAttempt = maxAttempt;
    202.         }
    203.  
    204.         @Override
    205.         public int currentAttempt() {
    206.             return currentAttempt;
    207.         }
    208.  
    209.         @Override
    210.         public long getElapsedTime() {
    211.             return this.currentElapsedTime;
    212.         }
    213.  
    214.         @Override
    215.         public long nextBackoff() {
    216.  
    217.             if (currentAttempt >= maxAttempt) {
    218.                 return STOP;
    219.             }
    220.  
    221.             long nextInterval = computeNextInterval();
    222.             this.currentElapsedTime += nextInterval;
    223.             this.currentAttempt += 1;
    224.             return nextInterval;
    225.         }
    226.  
    227.         private long computeNextInterval() {
    228.             long maxInterval = this.maxInterval;
    229.             if (this.currentInterval >= maxInterval) {
    230.                 return maxInterval;
    231.             } else if (this.currentInterval < 0) {
    232.                 this.currentInterval = this.initialInterval;
    233.             } else {
    234.                 this.currentInterval = multiplyInterval(this.currentInterval, maxInterval);
    235.             }
    236.             return this.currentInterval;
    237.         }
    238.  
    239.         private long multiplyInterval(long currentInterval, long maxInterval) {
    240.             long interval = currentInterval;
    241.             interval *= this.multiplier;
    242.             return (interval > maxInterval ? maxInterval : interval);
    243.         }
    244.  
    245.         @Override
    246.         public void updateCurrentAttempt(int attempt) {
    247.             if (attempt < 0) {
    248.                 this.currentAttempt = 0;
    249.             } else if (attempt >= maxAttempt) {
    250.                 this.currentAttempt = maxAttempt;
    251.             } else {
    252.                 this.currentAttempt = attempt;
    253.             }
    254.             this.currentElapsedTime = this.getElapsedTime(this.currentAttempt);
    255.         }
    256.  
    257.         @Override
    258.         public long getBackoff(int attempt) {
    259.             if (attempt <= 0) {
    260.                 return 0L;
    261.             }
    262.  
    263.             if (attempt - 1 >= maxAttempt) {
    264.                 return STOP;
    265.             }
    266.  
    267.             long interval = this.initialInterval;
    268.             long maxInterval = this.maxInterval;
    269.             for (long i = 1; i < attempt; i++) {
    270.                 interval = multiplyInterval(interval, maxInterval);
    271.                 if (interval >= maxInterval) {
    272.                     break;
    273.                 }
    274.             }
    275.             return interval;
    276.         }
    277.  
    278.         @Override
    279.         public long getElapsedTime(int attempt) {
    280.             if (attempt >= maxAttempt) {
    281.                 attempt = maxAttempt;
    282.             }
    283.             long interval = this.initialInterval;
    284.             long maxInterval = this.maxInterval;
    285.             long elapsedTime = 0;
    286.             if (attempt <= 0) {
    287.                 return elapsedTime;
    288.             } else {
    289.                 elapsedTime = interval;
    290.             }
    291.  
    292.             for (long i = 1; i < attempt; i++) {
    293.                 if (interval < maxInterval) {
    294.                     interval = multiplyInterval(interval, maxInterval);
    295.                 }
    296.                 elapsedTime += interval;
    297.             }
    298.             return elapsedTime;
    299.         }
    300.  
    301.         public long getInitialInterval() {
    302.             return initialInterval;
    303.         }
    304.  
    305.         public void setInitialInterval(long initialInterval) {
    306.             this.initialInterval = initialInterval;
    307.         }
    308.  
    309.         public double getMultiplier() {
    310.             return multiplier;
    311.         }
    312.  
    313.         public void setMultiplier(double multiplier) {
    314.             this.multiplier = multiplier;
    315.         }
    316.  
    317.         public long getMaxInterval() {
    318.             return maxInterval;
    319.         }
    320.  
    321.         public void setMaxInterval(long maxInterval) {
    322.             this.maxInterval = maxInterval;
    323.         }
    324.  
    325.         @Override
    326.         public int getMaxAttempt() {
    327.             return maxAttempt;
    328.         }
    329.         @Override
    330.         public void setMaxAttempt(int maxAttempt) {
    331.             this.maxAttempt = maxAttempt;
    332.         }
    333.  
    334.         public long getCurrentInterval() {
    335.             return currentInterval;
    336.         }
    337.  
    338.         public void setCurrentInterval(long currentInterval) {
    339.             this.currentInterval = currentInterval;
    340.         }
    341.  
    342.         public long getCurrentElapsedTime() {
    343.             return currentElapsedTime;
    344.         }
    345.  
    346.         public void setCurrentElapsedTime(long currentElapsedTime) {
    347.             this.currentElapsedTime = currentElapsedTime;
    348.         }
    349.  
    350.         public int getCurrentAttempt() {
    351.             return currentAttempt;
    352.         }
    353.  
    354.         public void setCurrentAttempt(int currentAttempt) {
    355.             this.currentAttempt = currentAttempt;
    356.         }
    357.  
    358.         @Override
    359.         public String toString() {
    360.             StringBuilder sb = new StringBuilder("ExponentialBackOff{");
    361.             sb.append("currentInterval=").append(this.currentInterval < 0 ? "n/a" : this.currentInterval + "ms");
    362.             sb.append(", multiplier=").append(this.multiplier);
    363.             sb.append('}');
    364.             return sb.toString();
    365.         }
    366.     }
    367.  
    368. }
    1. package com.xxx.commons.retry.backoff;
    2.  
    3. import java.io.Serializable;
    4. import java.util.concurrent.TimeUnit;
    5.  
    6. /**
    7.  * @created 2021-12-20 4:32 PM
    8.  * @description:
    9.  */
    10. public class FixedBackoff implements Backoff, Serializable {
    11.  
    12.     private static final long serialVersionUID = 2511140811757045231L;
    13.  
    14.     /**
    15.      * The default recovery interval: 5000 ms = 5 seconds.
    16.      */
    17.     public static final long DEFAULT_INTERVAL = 5000L;
    18.  
    19.     /**
    20.      * Constant value indicating an unlimited number of attempt.
    21.      */
    22.     public static final int UNLIMITED_ATTEMPTS = Integer.MAX_VALUE;
    23.  
    24.     private long interval = DEFAULT_INTERVAL;
    25.  
    26.     private int maxAttempt = UNLIMITED_ATTEMPTS;
    27.  
    28.  
    29.     /**
    30.      * Create an instance with an interval of {@value #DEFAULT_INTERVAL}
    31.      * ms and an unlimited number of attempt.
    32.      */
    33.     public FixedBackoff() {
    34.     }
    35.  
    36.  
    37.     /**
    38.      * Create an instance.
    39.      *
    40.      * @param maxAttempt the maximum number of attempt
    41.      */
    42.     public FixedBackoff(int maxAttempt) {
    43.         this.maxAttempt = maxAttempt;
    44.     }
    45.  
    46.     /**
    47.      * Create an instance.
    48.      *
    49.      * @param interval the interval between two attempt
    50.      * @param timeUnit the time unit of interval
    51.      */
    52.     public FixedBackoff(long interval, TimeUnit timeUnit) {
    53.         this.interval = BackoffExecution.DEFAULT_TIME_UNIT.convert(interval, timeUnit);
    54.         this.maxAttempt = maxAttempt;
    55.     }
    56.  
    57.     /**
    58.      * Create an instance.
    59.      *
    60.      * @param maxAttempt the maximum number of attempt
    61.      * @param interval   the interval between two attempt
    62.      */
    63.     public FixedBackoff(int maxAttempt, long interval) {
    64.         this.interval = interval;
    65.         this.maxAttempt = maxAttempt;
    66.     }
    67.  
    68.     /**
    69.      * Create an instance.
    70.      *
    71.      * @param maxAttempt the maximum number of attempt
    72.      * @param interval   the interval between two attempt
    73.      * @param timeUnit   the time unit of interval
    74.      */
    75.     public FixedBackoff(int maxAttempt, long interval, TimeUnit timeUnit) {
    76.         this.interval = BackoffExecution.DEFAULT_TIME_UNIT.convert(interval, timeUnit);
    77.         this.maxAttempt = maxAttempt;
    78.     }
    79.  
    80.     /**
    81.      * Set the interval between two attempt in milliseconds.
    82.      */
    83.     public void setInterval(long interval) {
    84.         this.interval = interval;
    85.     }
    86.  
    87.     /**
    88.      * Return the interval between two attempt in milliseconds.
    89.      */
    90.     public long getInterval() {
    91.         return interval;
    92.     }
    93.  
    94.     /**
    95.      * Set the maximum number of attempt in milliseconds.
    96.      */
    97.     public void setMaxAttempt(int maxAttempt) {
    98.         this.maxAttempt = maxAttempt;
    99.     }
    100.  
    101.     /**
    102.      * Return the maximum number of attempt in milliseconds.
    103.      */
    104.     public int getMaxAttempt() {
    105.         return maxAttempt;
    106.     }
    107.  
    108.  
    109.     @Override
    110.     public BackoffExecution start() {
    111.         return new FixedBackoffExecution(interval, maxAttempt);
    112.     }
    113.  
    114.  
    115.     public static class FixedBackoffExecution implements BackoffExecution, Serializable {
    116.  
    117.         private static final long serialVersionUID = 1656175761226107038L;
    118.  
    119.         private long interval;
    120.  
    121.         private int maxAttempt;
    122.  
    123.         private int currentAttempt = 0;
    124.         private long currentElapsedTime = 0;
    125.  
    126.         public FixedBackoffExecution() {
    127.             this(DEFAULT_INTERVAL, UNLIMITED_ATTEMPTS);
    128.         }
    129.  
    130.         public FixedBackoffExecution(long interval, int maxAttempt) {
    131.             this.interval = interval;
    132.             this.maxAttempt = maxAttempt;
    133.         }
    134.  
    135.         public long getInterval() {
    136.             return interval;
    137.         }
    138.  
    139.         public void setInterval(long interval) {
    140.             this.interval = interval;
    141.         }
    142.  
    143.         @Override
    144.         public int getMaxAttempt() {
    145.             return maxAttempt;
    146.         }
    147.         @Override
    148.         public void setMaxAttempt(int maxAttempt) {
    149.             this.maxAttempt = maxAttempt;
    150.         }
    151.  
    152.         public int getCurrentAttempt() {
    153.             return currentAttempt;
    154.         }
    155.  
    156.         public void setCurrentAttempt(int currentAttempt) {
    157.             this.currentAttempt = currentAttempt;
    158.         }
    159.  
    160.         public long getCurrentElapsedTime() {
    161.             return currentElapsedTime;
    162.         }
    163.  
    164.         public void setCurrentElapsedTime(long currentElapsedTime) {
    165.             this.currentElapsedTime = currentElapsedTime;
    166.         }
    167.  
    168.         @Override
    169.         public int currentAttempt() {
    170.             return currentAttempt;
    171.         }
    172.  
    173.         @Override
    174.         public long getElapsedTime() {
    175.             return this.currentElapsedTime;
    176.         }
    177.  
    178.         @Override
    179.         public long nextBackoff() {
    180.             if (this.currentAttempt < this.maxAttempt) {
    181.                 long nextInterval = this.interval;
    182.                 this.currentElapsedTime += nextInterval;
    183.                 this.currentAttempt++;
    184.                 return nextInterval;
    185.             } else {
    186.                 return STOP;
    187.             }
    188.         }
    189.  
    190.         @Override
    191.         public void updateCurrentAttempt(int attempt) {
    192.             if (attempt < 0) {
    193.                 this.currentAttempt = 0;
    194.             } else if (attempt >= maxAttempt) {
    195.                 this.currentAttempt = maxAttempt;
    196.             } else {
    197.                 this.currentAttempt = attempt;
    198.             }
    199.             this.currentElapsedTime = this.getElapsedTime(this.currentAttempt);
    200.         }
    201.  
    202.         @Override
    203.         public long getBackoff(int attempt) {
    204.             if (attempt <= 0) {
    205.                 return 0L;
    206.             }
    207.  
    208.             if (attempt - 1 >= maxAttempt) {
    209.                 return STOP;
    210.             }
    211.  
    212.             return this.interval;
    213.         }
    214.  
    215.         @Override
    216.         public long getElapsedTime(int attempt) {
    217.             return this.interval * attempt;
    218.         }
    219.  
    220.         @Override
    221.         public String toString() {
    222.             final StringBuilder sb = new StringBuilder("FixedBackoff{");
    223.             sb.append("interval=").append(this.interval);
    224.             String attemptValue = (this.maxAttempt == Integer.MAX_VALUE ?
    225.                     "unlimited" : String.valueOf(this.maxAttempt));
    226.             sb.append(", maxAttempt=").append(attemptValue);
    227.             sb.append(", currentAttempt=").append(this.currentAttempt);
    228.             sb.append('}');
    229.             return sb.toString();
    230.         }
    231.     }
    232.  
    233. }
    234.  
    1. package com.xxx.commons.retry.backoff;
    2.  
    3. import java.io.Serializable;
    4. import java.util.concurrent.TimeUnit;
    5.  
    6. import static com.xxx.commons.retry.backoff.BackoffExecution.DEFAULT_TIME_UNIT;
    7.  
    8.  
    9. /**
    10.  * @created 2021-12-20 4:33 PM
    11.  * @description:
    12.  */
    13. public class GradualBackoff implements Backoff, Serializable {
    14.  
    15.     private static final long serialVersionUID = -4082336395861849848L;
    16.  
    17.     /**
    18.      * The default initial interval.
    19.      */
    20.     public static final long DEFAULT_INITIAL_INTERVAL = 2000L;
    21.  
    22.     /**
    23.      * The default recovery interval: 3000 ms = 3 seconds.
    24.      */
    25.     public static final long DEFAULT_INTERVAL = 3000L;
    26.  
    27.     /**
    28.      * Constant value indicating an unlimited number of attempt.
    29.      */
    30.     public static final int UNLIMITED_ATTEMPTS = Integer.MAX_VALUE;
    31.  
    32.     private long initialInterval = DEFAULT_INITIAL_INTERVAL;
    33.  
    34.     private long interval = DEFAULT_INTERVAL;
    35.  
    36.     private int maxAttempt = UNLIMITED_ATTEMPTS;
    37.  
    38.  
    39.     /**
    40.      * Create an instance with an interval of {@value #DEFAULT_INTERVAL}
    41.      * ms and an unlimited number of attempt.
    42.      */
    43.     public GradualBackoff() {
    44.     }
    45.  
    46.  
    47.     /**
    48.      * Create an instance.
    49.      *
    50.      * @param maxAttempt the maximum number of attempt
    51.      */
    52.     public GradualBackoff(int maxAttempt) {
    53.         this.maxAttempt = maxAttempt;
    54.     }
    55.  
    56.     /**
    57.      * Create an instance.
    58.      *
    59.      * @param interval the interval between two attempt
    60.      * @param timeUnit the time unit of interval
    61.      */
    62.     public GradualBackoff(long initialInterval, long interval, TimeUnit timeUnit) {
    63.         this.initialInterval = DEFAULT_TIME_UNIT.convert(initialInterval, timeUnit);
    64.         this.interval = DEFAULT_TIME_UNIT.convert(interval, timeUnit);
    65.         this.maxAttempt = maxAttempt;
    66.     }
    67.  
    68.     /**
    69.      * Create an instance.
    70.      *
    71.      * @param maxAttempt the maximum number of attempt
    72.      * @param interval   the interval between two attempt
    73.      */
    74.     public GradualBackoff(int maxAttempt, long initialInterval, long interval) {
    75.         this.initialInterval = initialInterval;
    76.         this.interval = interval;
    77.         this.maxAttempt = maxAttempt;
    78.     }
    79.  
    80.     /**
    81.      * Create an instance.
    82.      *
    83.      * @param maxAttempt the maximum number of attempt
    84.      * @param interval   the interval between two attempt
    85.      * @param timeUnit   the time unit of interval
    86.      */
    87.     public GradualBackoff(int maxAttempt, long initialInterval, long interval, TimeUnit timeUnit) {
    88.         this.initialInterval = DEFAULT_TIME_UNIT.convert(initialInterval, timeUnit);
    89.         this.interval = DEFAULT_TIME_UNIT.convert(interval, timeUnit);
    90.         this.maxAttempt = maxAttempt;
    91.     }
    92.  
    93.     /**
    94.      * Return the interval of first attempt in milliseconds.
    95.      *
    96.      * @return
    97.      */
    98.     public long getInitialInterval() {
    99.         return initialInterval;
    100.     }
    101.  
    102.     /**
    103.      * Set the interval of first attempt in milliseconds.
    104.      */
    105.     public void setInitialInterval(long initialInterval) {
    106.         this.initialInterval = initialInterval;
    107.     }
    108.  
    109.     /**
    110.      * Set the interval between two attempt in milliseconds.
    111.      */
    112.     public void setInterval(long interval) {
    113.         this.interval = interval;
    114.     }
    115.  
    116.     /**
    117.      * Return the interval between two attempt in milliseconds.
    118.      */
    119.     public long getInterval() {
    120.         return interval;
    121.     }
    122.  
    123.     /**
    124.      * Set the maximum number of attempt in milliseconds.
    125.      */
    126.     public void setMaxAttempt(int maxAttempt) {
    127.         this.maxAttempt = maxAttempt;
    128.     }
    129.  
    130.     /**
    131.      * Return the maximum number of attempt in milliseconds.
    132.      */
    133.     public int getMaxAttempt() {
    134.         return maxAttempt;
    135.     }
    136.  
    137.     @Override
    138.     public BackoffExecution start() {
    139.         return new GradualBackoffExecution(initialInterval, interval, maxAttempt);
    140.     }
    141.  
    142.     public static class GradualBackoffExecution implements BackoffExecution, Serializable {
    143.  
    144.         private static final long serialVersionUID = 6691539566098442985L;
    145.  
    146.         private long initialInterval;
    147.  
    148.         private long interval;
    149.  
    150.         private int maxAttempt;
    151.  
    152.         private int currentAttempt = 0;
    153.         private long currentElapsedTime = 0;
    154.  
    155.         public GradualBackoffExecution() {
    156.             this(DEFAULT_INITIAL_INTERVAL, DEFAULT_INTERVAL, UNLIMITED_ATTEMPTS);
    157.         }
    158.  
    159.         public GradualBackoffExecution(long initialInterval, long interval, int maxAttempt) {
    160.             this.initialInterval = initialInterval;
    161.             this.interval = interval;
    162.             this.maxAttempt = maxAttempt;
    163.         }
    164.  
    165.         @Override
    166.         public int currentAttempt() {
    167.             return currentAttempt;
    168.         }
    169.  
    170.         @Override
    171.         public long getElapsedTime() {
    172.             return this.currentElapsedTime;
    173.         }
    174.  
    175.         @Override
    176.         public long nextBackoff() {
    177.             if (this.currentAttempt < this.maxAttempt) {
    178.                 long nextInterval = this.currentAttempt == 0 ? this.initialInterval : this.interval;
    179.                 this.currentElapsedTime += nextInterval;
    180.                 this.currentAttempt++;
    181.                 return nextInterval;
    182.             } else {
    183.                 return STOP;
    184.             }
    185.         }
    186.  
    187.         @Override
    188.         public void updateCurrentAttempt(int attempt) {
    189.             if (attempt < 0) {
    190.                 this.currentAttempt = 0;
    191.             } else if (attempt >= maxAttempt) {
    192.                 this.currentAttempt = maxAttempt;
    193.             } else {
    194.                 this.currentAttempt = attempt;
    195.             }
    196.             this.currentElapsedTime = this.getElapsedTime(this.currentAttempt);
    197.         }
    198.  
    199.         @Override
    200.         public long getBackoff(int attempt) {
    201.             if (attempt <= 0) {
    202.                 return 0L;
    203.             }
    204.  
    205.             if (attempt - 1 >= maxAttempt) {
    206.                 return STOP;
    207.             }
    208.  
    209.             return attempt == 1 ? this.initialInterval : this.interval;
    210.         }
    211.  
    212.         @Override
    213.         public long getElapsedTime(int attempt) {
    214.             return attempt == 1 ? this.initialInterval : this.initialInterval + this.interval * (attempt - 1);
    215.         }
    216.  
    217.         public long getInitialInterval() {
    218.             return initialInterval;
    219.         }
    220.  
    221.         public void setInitialInterval(long initialInterval) {
    222.             this.initialInterval = initialInterval;
    223.         }
    224.  
    225.         public long getInterval() {
    226.             return interval;
    227.         }
    228.  
    229.         public void setInterval(long interval) {
    230.             this.interval = interval;
    231.         }
    232.  
    233.         @Override
    234.         public int getMaxAttempt() {
    235.             return maxAttempt;
    236.         }
    237.         @Override
    238.         public void setMaxAttempt(int maxAttempt) {
    239.             this.maxAttempt = maxAttempt;
    240.         }
    241.  
    242.         public int getCurrentAttempt() {
    243.             return currentAttempt;
    244.         }
    245.  
    246.         public void setCurrentAttempt(int currentAttempt) {
    247.             this.currentAttempt = currentAttempt;
    248.         }
    249.  
    250.         public long getCurrentElapsedTime() {
    251.             return currentElapsedTime;
    252.         }
    253.  
    254.         public void setCurrentElapsedTime(long currentElapsedTime) {
    255.             this.currentElapsedTime = currentElapsedTime;
    256.         }
    257.  
    258.         @Override
    259.         public String toString() {
    260.             final StringBuilder sb = new StringBuilder("GradualBackoff{");
    261.             sb.append("initialInterval=").append(this.initialInterval);
    262.             sb.append("interval=").append(this.interval);
    263.             String attemptValue = (this.maxAttempt == Integer.MAX_VALUE ?
    264.                     "unlimited" : String.valueOf(this.maxAttempt));
    265.             sb.append(", maxAttempt=").append(attemptValue);
    266.             sb.append(", currentAttempt=").append(this.currentAttempt);
    267.             sb.append('}');
    268.             return sb.toString();
    269.         }
    270.     }
    271.  
    272. }
    273.  
    1. package com.xxx.commons.retry.backoff;
    2.  
    3. import java.io.Serializable;
    4.  
    5. /**
    6.  * @created 2021-12-20 4:34 PM
    7.  * @description:
    8.  */
    9. public class NoneBackoff implements Backoff, Serializable {
    10.  
    11.     private static final long serialVersionUID = 8227959838869099892L;
    12.  
    13.     /**
    14.      * The default recovery interval: 0 ms = 0 seconds.
    15.      */
    16.     public static final long DEFAULT_INTERVAL = 0L;
    17.  
    18.     /**
    19.      * Constant value indicating an unlimited number of attempt.
    20.      */
    21.     public static final int UNLIMITED_ATTEMPTS = Integer.MAX_VALUE;
    22.  
    23.     private long interval = DEFAULT_INTERVAL;
    24.  
    25.     private int maxAttempt = UNLIMITED_ATTEMPTS;
    26.  
    27.  
    28.     /**
    29.      * Create an instance with an interval of {@value #DEFAULT_INTERVAL}
    30.      * ms and an unlimited number of attempt.
    31.      */
    32.     public NoneBackoff() {
    33.     }
    34.  
    35.     /**
    36.      * Create an instance.
    37.      *
    38.      * @param maxAttempt the maximum number of attempt
    39.      */
    40.     public NoneBackoff(int maxAttempt) {
    41.         this.maxAttempt = maxAttempt;
    42.     }
    43.  
    44.     /**
    45.      * Return the interval between two attempt in milliseconds.
    46.      */
    47.     public long getInterval() {
    48.         return interval;
    49.     }
    50.  
    51.     /**
    52.      * Return the maximum number of attempt in milliseconds.
    53.      */
    54.     public int getMaxAttempt() {
    55.         return maxAttempt;
    56.     }
    57.  
    58.     /**
    59.      * Set the maximum number of attempt in milliseconds.
    60.      */
    61.     public void setMaxAttempt(int maxAttempt) {
    62.         this.maxAttempt = maxAttempt;
    63.     }
    64.  
    65.     @Override
    66.     public BackoffExecution start() {
    67.         return new NoneBackoffExecution(interval, maxAttempt);
    68.     }
    69.  
    70.  
    71.     public static class NoneBackoffExecution implements BackoffExecution, Serializable {
    72.  
    73.         private static final long serialVersionUID = 2453613900451888865L;
    74.  
    75.         private long interval;
    76.  
    77.         private int maxAttempt;
    78.  
    79.         private int currentAttempt = 0;
    80.         private long currentElapsedTime = 0;
    81.  
    82.         public NoneBackoffExecution() {
    83.             this(DEFAULT_INTERVAL, UNLIMITED_ATTEMPTS);
    84.         }
    85.  
    86.         public NoneBackoffExecution(long interval, int maxAttempt) {
    87.             this.interval = interval;
    88.             this.maxAttempt = maxAttempt;
    89.         }
    90.  
    91.         @Override
    92.         public int currentAttempt() {
    93.             return currentAttempt;
    94.         }
    95.  
    96.         @Override
    97.         public long getElapsedTime() {
    98.             return this.currentElapsedTime;
    99.         }
    100.  
    101.         @Override
    102.         public long nextBackoff() {
    103.             if (this.currentAttempt < this.maxAttempt) {
    104.                 long nextInterval = this.interval;
    105.                 this.currentElapsedTime += nextInterval;
    106.                 this.currentAttempt++;
    107.                 return nextInterval;
    108.             } else {
    109.                 return STOP;
    110.             }
    111.         }
    112.  
    113.         @Override
    114.         public void updateCurrentAttempt(int attempt) {
    115.             if (attempt < 0) {
    116.                 this.currentAttempt = 0;
    117.             } else if (attempt >= maxAttempt) {
    118.                 this.currentAttempt = maxAttempt;
    119.             } else {
    120.                 this.currentAttempt = attempt;
    121.             }
    122.             this.currentElapsedTime = this.getElapsedTime(this.currentAttempt);
    123.         }
    124.  
    125.         @Override
    126.         public long getBackoff(int attempt) {
    127.             if (attempt <= 0) {
    128.                 return 0L;
    129.             }
    130.  
    131.             if (attempt - 1 >= maxAttempt) {
    132.                 return STOP;
    133.             }
    134.  
    135.             return this.interval;
    136.         }
    137.  
    138.         @Override
    139.         public long getElapsedTime(int attempt) {
    140.             return this.interval * attempt;
    141.         }
    142.  
    143.         public long getInterval() {
    144.             return interval;
    145.         }
    146.  
    147.         public void setInterval(long interval) {
    148.             this.interval = interval;
    149.         }
    150.  
    151.         @Override
    152.         public int getMaxAttempt() {
    153.             return maxAttempt;
    154.         }
    155.         @Override
    156.         public void setMaxAttempt(int maxAttempt) {
    157.             this.maxAttempt = maxAttempt;
    158.         }
    159.  
    160.         public int getCurrentAttempt() {
    161.             return currentAttempt;
    162.         }
    163.  
    164.         public void setCurrentAttempt(int currentAttempt) {
    165.             this.currentAttempt = currentAttempt;
    166.         }
    167.  
    168.         public long getCurrentElapsedTime() {
    169.             return currentElapsedTime;
    170.         }
    171.  
    172.         public void setCurrentElapsedTime(long currentElapsedTime) {
    173.             this.currentElapsedTime = currentElapsedTime;
    174.         }
    175.  
    176.         @Override
    177.         public String toString() {
    178.             final StringBuilder sb = new StringBuilder("NoneBackoff{");
    179.             sb.append("interval=").append(this.interval);
    180.             sb.append(", maxAttempt=").append(this.maxAttempt);
    181.             sb.append('}');
    182.             return sb.toString();
    183.         }
    184.     }
    185. }
    186.

    2.2.3 业务使用示例

    网关使用示例:

    • 添加依赖

    1.     <!-- 公共模块 -->
    2.     <dependency>
    3.         <groupId>com.xxx.arch</groupId>
    4.         <artifactId>xxx-commons-recipes</artifactId>
    5.         <version>1.0.8</version> 
    6.         <!-- <version>${xxx.commons.version}</version> -->
    7.     </dependency>

    • 初始化

    1. @Configuration
    2. @AutoConfigureAfter(OnsConfig.class)
    3. public class LinkBean {
    4.     
    5.     public static final String MESSAGE_DELAY_LEVEL = "1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h";
    6.     
    7.     @Bean
    8.     public BackoffExecution backoffExecution() {
    9.         return new CustomBackoff(MESSAGE_DELAY_LEVEL, MAX_RETRY_COUNT).start();
    10.     }
    11.     
    12.     ...
    13. }

    • 具体使用

    1. @Slf4j
    2. public class RetryFilterFactory implements FilterFactory {
    3.     private Producer producer;
    4.     private BackoffExecution backoffExecution;
    5.  
    6.     public RetryFilterFactory(Producer producer, BackoffExecution backoffExecution) {
    7.         this.producer = producer;
    8.         this.backoffExecution = backoffExecution;
    9.     }
    10.  
    11.     @Override
    12.     public String name() {
    13.         return "retry";
    14.     }
    15.  
    16.     @Override
    17.     public Filter apply(Properties properties) {
    18.  
    19.         return (context, chain) -> {
    20.  
    21.             int retry = context.getRetryCount();
    22.             retry++;
    23.  
    24.             long retryTime = context.getAttributeOrDefault(LinkContext.FAILOVER_RETRY_TIME_ATTRIBUTE, 0L);
    25.             context.getAttributes().put(LinkContext.FAILOVER_RETRY_TIME_ATTRIBUTE,
    26.                 retryTime + backoffExecution.getBackoff(retry));
    27.  
    28.             try {
    29.                 producer.send(context);
    30.             } catch (Exception exp) {
    31.                 log.error("master send context: {}, error:", context, exp);
    32.                 throw new LinkIOException("send master mq error");
    33.             }
    34.             chain.filter(context);
    35.         };
    36.     }
    37. }

    四、未来展望

    希望大家一起来共建xxx-commons组件，也希望xxx-commons组件能够成为内部基础组件被广泛使用，提升系统和业务开发效率，并提升开发质量。

  • 相关阅读:
    Java寻找两个正序数组的中位数
    推挽输出和开漏输出-三极管-mos管
    [附源码]计算机毕业设计新冠疫苗接种预约系统Springboot程序
    利用编码特长，我赚取了每月1000美元的额外收入
    ByteBuffer杂记
    c/c++里 对 共用体 union 的内存分配
    matlab如何实现任意长序列所有排列方式
    吃鸡专家教你战无不胜，分享顶级干货！
    C专家编程 第1章 C：穿越时空的迷雾 1.4 K&R C
    PMP考试如何退考？手把手教你
  • 原文地址：https://blog.csdn.net/shallowgrave/article/details/133937678