retryAttempt);
23 |
24 | }
25 |
--------------------------------------------------------------------------------
/retry-api/src/main/java/com/poldroc/retry/api/support/stop/RetryStop.java:
--------------------------------------------------------------------------------
1 | package com.poldroc.retry.api.support.stop;
2 |
3 | import com.poldroc.retry.api.model.RetryAttempt;
4 | /**
5 | * 结束的条件
6 | * @author Poldroc
7 | * @since 2024/7/11
8 | */
9 |
10 | public interface RetryStop {
11 |
12 | /**
13 | * 停止执行重试
14 | * @param attempt 执行信息
15 | * @return 是否停止
16 | */
17 | boolean stop(final RetryAttempt attempt);
18 |
19 | }
20 |
--------------------------------------------------------------------------------
/retry-api/src/main/java/com/poldroc/retry/api/support/wait/RetryWait.java:
--------------------------------------------------------------------------------
1 | package com.poldroc.retry.api.support.wait;
2 |
3 | import com.poldroc.retry.api.context.RetryWaitContext;
4 | import com.poldroc.retry.api.model.WaitTime;
5 |
6 | import java.lang.annotation.Annotation;
7 |
8 | /**
9 | * 重试等待策略
10 | * 1. 所有的实现必须要有无参构造器，因为会基于反射处理类信息(newInstance)。
11 | * 2. 尽可能的保证为线程安全的，比如 stateless。
12 | * @author Poldroc
13 | * @since 2024/7/11
14 | */
15 |
16 | public interface RetryWait{
17 |
18 | /**
19 | * 计算等待时间
20 | * @param retryWaitContext 上下文信息
21 | * @return 等待时间的结果信息
22 | */
23 | WaitTime waitTime(final RetryWaitContext retryWaitContext);
24 |
25 | }
26 |
--------------------------------------------------------------------------------
/retry-common/pom.xml:
--------------------------------------------------------------------------------
1 |
2 |
5 | 4.0.0
6 |
7 | io.github.poldroc
8 | roc-retry
9 | 1.1
10 |
11 |
12 | retry-common
13 |
14 |
15 | 8
16 | 8
17 | UTF-8
18 |
19 |
20 |
21 |
--------------------------------------------------------------------------------
/retry-common/src/main/java/com/poldroc/retry/common/annotation/NotThreadSafe.java:
--------------------------------------------------------------------------------
1 | package com.poldroc.retry.common.annotation;
2 |
3 | import java.lang.annotation.*;
4 | /**
5 | * 线程不安全安全注解
6 | * @author Poldroc
7 | * @since 2024/7/11
8 | */
9 |
10 | @Documented
11 | @Inherited
12 | @Target({ElementType.TYPE, ElementType.METHOD})
13 | @Retention(RetentionPolicy.RUNTIME)
14 | public @interface NotThreadSafe {
15 | }
16 |
--------------------------------------------------------------------------------
/retry-common/src/main/java/com/poldroc/retry/common/annotation/ThreadSafe.java:
--------------------------------------------------------------------------------
1 | package com.poldroc.retry.common.annotation;
2 |
3 | import java.lang.annotation.*;
4 | /**
5 | * 线程安全注解
6 | * 放在类上，标识当前类为线程安全的。
7 | * 放在方法上，标识方法是线程安全的。
8 | *
9 | * 注意：目前此注解仅供内部使用，用来标识类是否线程安全。(表示作者的预期) 真正效果需要验证。
10 | *
11 | * 后期用途：可能会直接基于 class 进行反射创建，要求有些类需要显示指定这个注解。
12 | * @author Poldroc
13 | * @since 2024/7/11
14 | */
15 |
16 | @Documented
17 | @Inherited
18 | @Target({ElementType.TYPE, ElementType.METHOD})
19 | @Retention(RetentionPolicy.RUNTIME)
20 | public @interface ThreadSafe {
21 | }
22 |
--------------------------------------------------------------------------------
/retry-common/src/main/java/com/poldroc/retry/common/constant/enums/ProxyTypeEnum.java:
--------------------------------------------------------------------------------
1 | package com.poldroc.retry.common.constant.enums;
2 |
3 | public enum ProxyTypeEnum {
4 | NONE,
5 | DYNAMIC,
6 | CGLIB;
7 |
8 | private ProxyTypeEnum() {
9 | }
10 | }
11 |
--------------------------------------------------------------------------------
/retry-common/src/main/java/com/poldroc/retry/common/support/instance/Instance.java:
--------------------------------------------------------------------------------
1 | package com.poldroc.retry.common.support.instance;
2 |
3 | /**
4 | * 实例化对象的接口
5 | * 1. 使用此类的 class 必须有无参构造器
6 | * 2. 当前类出于测试阶段。
7 | * @author Poldroc
8 | * @since 2024/7/11
9 | */
10 |
11 | public interface Instance {
12 |
13 | /**
14 | * 获取对象的单例对象
15 | * 1. 需要保证对象的线程安全性。
16 | * 2. 只有在同一个分组返回的对象才会是单例，否则返回 newInstance()
17 | * @param tClass class 类型
18 | * @param groupName 分组名称
19 | * @param 泛型
20 | * @return 实例化对象
21 | */
22 | T singleton(final Class tClass,
23 | final String groupName);
24 |
25 | /**
26 | * 获取对象的单例对象
27 | * 1. 需要保证对象的线程安全性。
28 | * @param tClass class 类型
29 | * @param 泛型
30 | * @return 实例化对象
31 | */
32 | T singleton(final Class tClass);
33 |
34 | /**
35 | * 获取每个线程内唯一的实例化对象
36 | * 注意：可能会内存泄漏的场景。
37 | * (1) 只要这个线程对象被gc回收，就不会出现内存泄露，但在threadLocal设为null和线程结束这段时间不会被回收的，就发生了我们认为的内存泄露。
38 | * 最要命的是线程对象不被回收的情况，这就发生了真正意义上的内存泄露。比如使用线程池的时候，线程结束是不会销毁的，会再次使用的。就可能出现内存泄露。
39 | * 参考资料：https://www.cnblogs.com/onlywujun/p/3524675.html
40 | * @param tClass class 类型
41 | * @param 泛型
42 | * @return 实例化对象
43 | * @see java.lang.ref.WeakReference 弱引用
44 | */
45 | T threadLocal(final Class tClass);
46 |
47 | /**
48 | * 多例对象，每次都是全新的创建
49 | * @param tClass class 类型
50 | * @param 泛型
51 | * @return 实例化对象
52 | */
53 | T multiple(final Class tClass);
54 |
55 | /**
56 | * 线程安全对象
57 | * 1. 判断当前类是否拥有 {@link com.poldroc.retry.common.annotation.ThreadSafe} 注解，
58 | * 如果有，则直接创建单例对象。如果不是，则创建多例对象。
59 | * @param tClass class 类型
60 | * @param 泛型
61 | * @return 实例化对象
62 | */
63 | T threadSafe(final Class tClass);
64 |
65 | }
66 |
--------------------------------------------------------------------------------
/retry-common/src/main/java/com/poldroc/retry/common/support/instance/impl/InstanceFactory.java:
--------------------------------------------------------------------------------
1 | package com.poldroc.retry.common.support.instance.impl;
2 |
3 | import com.poldroc.retry.common.annotation.ThreadSafe;
4 | import com.poldroc.retry.common.support.instance.Instance;
5 | import com.poldroc.retry.common.util.ArgUtil;
6 |
7 | import java.util.Map;
8 | import java.util.concurrent.ConcurrentHashMap;
9 |
10 | /**
11 | * 实例化工厂类
12 | *
13 | * @author Poldroc
14 | * @since 2024/7/11
15 | */
16 | @ThreadSafe
17 | public class InstanceFactory implements Instance {
18 |
19 | private InstanceFactory() {
20 | }
21 |
22 | /**
23 | * 单例 map 对象
24 | * key 是 class 的全称
25 | */
26 | private final Map singletonMap = new ConcurrentHashMap<>();
27 |
28 | /**
29 | * 线程内的 map 对象
30 | */
31 | private ThreadLocal> mapThreadLocal = new ThreadLocal<>();
32 |
33 | /**
34 | * 静态内部类实现单例
35 | */
36 | private static class SingletonHolder {
37 | private static final InstanceFactory INSTANCE_FACTORY = new InstanceFactory();
38 | }
39 |
40 | /**
41 | * 获取单例对象
42 | *
43 | * @return 实例化对象
44 | */
45 | public static InstanceFactory getInstance() {
46 | return SingletonHolder.INSTANCE_FACTORY;
47 | }
48 |
49 | @Override
50 | public T singleton(Class tClass, String groupName) {
51 | return getSingleton(tClass, groupName, singletonMap);
52 | }
53 |
54 | @Override
55 | public T singleton(Class tClass) {
56 | this.notNull(tClass);
57 | return this.getSingleton(tClass, singletonMap);
58 | }
59 |
60 | @Override
61 | public T threadLocal(Class tClass) {
62 | this.notNull(tClass);
63 | Map map = mapThreadLocal.get();
64 | if (map == null) {
65 | map = new ConcurrentHashMap<>();
66 | }
67 | T instance = this.getSingleton(tClass, map);
68 | mapThreadLocal.set(map);
69 | return instance;
70 | }
71 |
72 | @Override
73 | public T multiple(Class tClass) {
74 | this.notNull(tClass);
75 | try {
76 | return tClass.newInstance();
77 | } catch (InstantiationException | IllegalAccessException e) {
78 | throw new RuntimeException("Create instance failed.", e);
79 | }
80 | }
81 |
82 | @Override
83 | public T threadSafe(Class tClass) {
84 | if (tClass.isAnnotationPresent(ThreadSafe.class)) {
85 | return this.singleton(tClass);
86 | }
87 | return this.multiple(tClass);
88 | }
89 |
90 | /**
91 | * 获取单例对象
92 | *
93 | * @param tClass class 类型
94 | * @param instanceMap 实例化对象 map
95 | * @return 单例对象
96 | */
97 | @SuppressWarnings("unchecked")
98 | private T getSingleton(final Class tClass, final Map instanceMap) {
99 | this.notNull(tClass);
100 |
101 | final String fullClassName = tClass.getName();
102 | T instance = (T) instanceMap.get(fullClassName);
103 | if (instance == null) {
104 | instance = this.multiple(tClass);
105 | instanceMap.put(fullClassName, instance);
106 | }
107 | return instance;
108 | }
109 |
110 | /**
111 | * 获取单例对象
112 | *
113 | * @param tClass 查询 tClass
114 | * @param group 分组信息
115 | * @param instanceMap 实例化对象 map
116 | * @return 单例对象
117 | */
118 | @SuppressWarnings("unchecked")
119 | private T getSingleton(final Class tClass,
120 | final String group, final Map instanceMap) {
121 | this.notNull(tClass);
122 | ArgUtil.notEmpty(group, "key");
123 |
124 | final String fullClassName = tClass.getName() + "-" + group;
125 | T instance = (T) instanceMap.get(fullClassName);
126 | if (instance == null) {
127 | instance = this.multiple(tClass);
128 | instanceMap.put(fullClassName, instance);
129 | }
130 | return instance;
131 | }
132 |
133 | /**
134 | * 断言参数不可为 null
135 | *
136 | * @param tClass class 信息
137 | */
138 | private void notNull(final Class tClass) {
139 | ArgUtil.notNull(tClass, "class");
140 | }
141 |
142 | }
143 |
--------------------------------------------------------------------------------
/retry-common/src/main/java/com/poldroc/retry/common/support/proxy/ProxyFactory.java:
--------------------------------------------------------------------------------
1 | package com.poldroc.retry.common.support.proxy;
2 |
3 | import com.poldroc.retry.common.constant.enums.ProxyTypeEnum;
4 |
5 | import java.lang.reflect.Proxy;
6 |
7 | public class ProxyFactory {
8 | private ProxyFactory() {
9 | }
10 |
11 | public static ProxyTypeEnum getProxyType(Object object) {
12 | if (object == null) {
13 | return ProxyTypeEnum.NONE;
14 | } else {
15 | Class clazz = object.getClass();
16 | return !clazz.isInterface() && !Proxy.isProxyClass(clazz) ? ProxyTypeEnum.CGLIB : ProxyTypeEnum.DYNAMIC;
17 | }
18 | }
19 | }
20 |
--------------------------------------------------------------------------------
/retry-common/src/main/java/com/poldroc/retry/common/util/ArgUtil.java:
--------------------------------------------------------------------------------
1 | package com.poldroc.retry.common.util;
2 |
3 | import java.util.ArrayList;
4 | import java.util.List;
5 |
6 | /**
7 | * 参数工具类
8 | *
9 | * @author Poldroc
10 | * @since 2024/7/11
11 | */
12 |
13 | public final class ArgUtil {
14 |
15 | private ArgUtil() {
16 | }
17 |
18 | /**
19 | * 断言不为空
20 | *
21 | * @param object 对象
22 | * @param name 对象名称
23 | */
24 | public static void notNull(Object object, String name) {
25 | if (null == object) {
26 | throw new IllegalArgumentException(name + " can not be null!");
27 | }
28 | }
29 |
30 | /**
31 | * 校验字符串非空
32 | *
33 | * @param string 待检查的字符串
34 | * @param name 字符串的名称
35 | */
36 | public static void notEmpty(String string, String name) {
37 | if (StringUtil.isEmpty(string)) {
38 | throw new IllegalArgumentException(name + " can not be null!");
39 | }
40 | }
41 |
42 | public static void notEmpty(Object[] array, String name) {
43 | if (array == null || array.length == 0) {
44 | throw new IllegalArgumentException(name + " excepted is not empty!");
45 | } else {
46 | Object[] var2 = array;
47 | int var3 = array.length;
48 |
49 | for (int var4 = 0; var4 < var3; ++var4) {
50 | Object object = var2[var4];
51 | notNull(object, name + " element ");
52 | }
53 | }
54 | }
55 |
56 | public static void notEmpty(List list, String name) {
57 | if (list == null || list.isEmpty()) {
58 | throw new IllegalArgumentException(name + " excepted is not empty!");
59 | } else {
60 | Object[] var2 = list.toArray();
61 | int var3 = var2.length;
62 |
63 | for (int var4 = 0; var4 < var3; ++var4) {
64 | Object object = var2[var4];
65 | notNull(object, name + " element ");
66 | }
67 | }
68 | }
69 |
70 |
71 | public static void positive(int number, String paramName) {
72 | if (number <= 0) {
73 | throw new IllegalArgumentException(paramName + " must be > 0!");
74 | }
75 | }
76 | }
77 |
--------------------------------------------------------------------------------
/retry-common/src/main/java/com/poldroc/retry/common/util/StringUtil.java:
--------------------------------------------------------------------------------
1 | package com.poldroc.retry.common.util;
2 |
3 | /**
4 | * 字符串工具类
5 | *
6 | * @author Poldroc
7 | * @since 2024/7/11
8 | */
9 |
10 | public final class StringUtil {
11 |
12 | private StringUtil() {
13 | }
14 |
15 |
16 | /**
17 | * 空字符串
18 | */
19 | public static final String EMPTY = "";
20 |
21 |
22 | /**
23 | * 判断字符串是否为空
24 | *
25 | * @param string 字符串
26 | * @return 是否为空
27 | */
28 | public static boolean isEmpty(String string) {
29 | return null == string || EMPTY.equals(string);
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/retry-core/pom.xml:
--------------------------------------------------------------------------------
1 |
2 |
5 | 4.0.0
6 |
7 | io.github.poldroc
8 | roc-retry
9 | 1.1
10 |
11 |
12 | retry-core
13 | The core module of roc-retry.
14 |
15 |
16 |
17 | 8
18 | 8
19 | UTF-8
20 |
21 |
22 |
23 |
24 | ${project.groupId}
25 | retry-api
26 |
27 |
28 | ${project.groupId}
29 | retry-common
30 |
31 |
32 |
33 |
34 |
--------------------------------------------------------------------------------
/retry-core/src/main/java/com/poldroc/retry/core/constant/RetryWaitConst.java:
--------------------------------------------------------------------------------
1 | package com.poldroc.retry.core.constant;
2 |
3 | /**
4 | * 重试等待时间常量
5 | *
6 | * @author Poldroc
7 | * @since 2024/7/11
8 | */
9 |
10 | public final class RetryWaitConst {
11 | private RetryWaitConst() {
12 | }
13 |
14 | /**
15 | * 默认基础值
16 | * 1s
17 | */
18 | public static final long DEFAULT_VALUE_MILLS = 1000L;
19 |
20 | /**
21 | * 最小等待时间
22 | */
23 | public static final long DEFAULT_MIN_MILLS = 0L;
24 |
25 | /**
26 | * 最大等待时间
27 | * 30min
28 | */
29 | public static final long DEFAULT_MAX_MILLS = 30 * 60 * 1000L;
30 |
31 | /**
32 | * 增加的毫秒数因数
33 | * 默认为 2S
34 | */
35 | public static final double INCREASE_MILLS_FACTOR = 2000;
36 |
37 | /**
38 | * 因数
39 | * 默认为黄金分割比
40 | */
41 | public static final double MULTIPLY_FACTOR = 1.618;
42 |
43 |
44 | }
45 |
--------------------------------------------------------------------------------
/retry-core/src/main/java/com/poldroc/retry/core/context/DefaultRetryContext.java:
--------------------------------------------------------------------------------
1 | package com.poldroc.retry.core.context;
2 |
3 | import com.poldroc.retry.api.context.RetryContext;
4 | import com.poldroc.retry.api.context.RetryWaitContext;
5 | import com.poldroc.retry.api.core.Retry;
6 | import com.poldroc.retry.api.support.block.RetryBlock;
7 | import com.poldroc.retry.api.support.condition.RetryCondition;
8 | import com.poldroc.retry.api.support.listen.RetryListen;
9 | import com.poldroc.retry.api.support.recover.Recover;
10 | import com.poldroc.retry.api.support.stop.RetryStop;
11 | import com.poldroc.retry.common.annotation.NotThreadSafe;
12 |
13 | import java.util.Collections;
14 | import java.util.List;
15 | import java.util.concurrent.Callable;
16 |
17 | /**
18 | * 默认重试执行上下文
19 | *
20 | * @author Poldroc
21 | * @since 2024/7/11
22 | */
23 |
24 | @NotThreadSafe
25 | public class DefaultRetryContext implements RetryContext {
26 |
27 | /**
28 | * 重试实现类
29 | */
30 | private Retry retry;
31 |
32 | /**
33 | * 重试生效条件
34 | */
35 | private RetryCondition condition;
36 |
37 | /**
38 | * 重试等待上下文
39 | */
40 | private List> waitContext;
41 |
42 | /**
43 | * 阻塞实现
44 | */
45 | private RetryBlock block;
46 |
47 | /**
48 | * 停止策略
49 | */
50 | private RetryStop stop;
51 |
52 | /**
53 | * 可执行的方法
54 | */
55 | private Callable callable;
56 |
57 | /**
58 | * 监听器
59 | */
60 | private RetryListen listen;
61 |
62 | /**
63 | * 恢复策略
64 | */
65 | private Recover recover;
66 |
67 | /**
68 | * 请求参数信息
69 | */
70 | private Object[] params;
71 |
72 |
73 | @Override
74 | public Retry retry() {
75 | return retry;
76 | }
77 |
78 | public DefaultRetryContext retry(Retry retry) {
79 | this.retry = retry;
80 | return this;
81 | }
82 |
83 | @Override
84 | public RetryCondition condition() {
85 | return condition;
86 | }
87 |
88 | public DefaultRetryContext condition(RetryCondition condition) {
89 | this.condition = condition;
90 | return this;
91 | }
92 |
93 | @Override
94 | public List> waitContext() {
95 | return waitContext;
96 | }
97 |
98 | public DefaultRetryContext waitContext(List> waitContext) {
99 | this.waitContext = waitContext;
100 | return this;
101 | }
102 |
103 | @Override
104 | public RetryBlock block() {
105 | return block;
106 | }
107 |
108 | public DefaultRetryContext block(RetryBlock block) {
109 | this.block = block;
110 | return this;
111 | }
112 |
113 | @Override
114 | public RetryStop stop() {
115 | return stop;
116 | }
117 |
118 | public DefaultRetryContext stop(RetryStop stop) {
119 | this.stop = stop;
120 | return this;
121 | }
122 |
123 | @Override
124 | public Callable callable() {
125 | return callable;
126 | }
127 |
128 | public DefaultRetryContext callable(Callable callable) {
129 | this.callable = callable;
130 | return this;
131 | }
132 |
133 | public DefaultRetryContext retry(Callable callable) {
134 | this.callable = callable;
135 | return this;
136 | }
137 |
138 | @Override
139 | public RetryListen listen() {
140 | return listen;
141 | }
142 |
143 | public DefaultRetryContext listen(RetryListen listen) {
144 | this.listen = listen;
145 | return this;
146 | }
147 |
148 | @Override
149 | public Recover recover() {
150 | return recover;
151 | }
152 |
153 | public DefaultRetryContext recover(Recover recover) {
154 | this.recover = recover;
155 | return this;
156 | }
157 |
158 | @Override
159 | public Object[] params() {
160 | return params;
161 | }
162 |
163 | @Override
164 | public DefaultRetryContext params(Object[] params) {
165 | this.params = params;
166 | return this;
167 | }
168 | }
169 |
--------------------------------------------------------------------------------
/retry-core/src/main/java/com/poldroc/retry/core/context/DefaultRetryWaitContext.java:
--------------------------------------------------------------------------------
1 | package com.poldroc.retry.core.context;
2 |
3 | import com.poldroc.retry.api.context.RetryWaitContext;
4 | import com.poldroc.retry.api.model.AttemptTime;
5 | import com.poldroc.retry.api.model.RetryAttempt;
6 | import com.poldroc.retry.api.support.wait.RetryWait;
7 |
8 | import java.util.Collections;
9 | import java.util.List;
10 |
11 | /**
12 | * 默认重试等待上下文
13 | *
14 | * @author Poldroc
15 | * @since 2024/7/11
16 | */
17 |
18 | public class DefaultRetryWaitContext implements RetryWaitContext {
19 |
20 | /**
21 | * 执行结果
22 | */
23 | private R result;
24 |
25 | /**
26 | * 尝试次数
27 | */
28 | private int attempt;
29 |
30 | /**
31 | * 尝试次数
32 | */
33 | private Throwable cause;
34 |
35 | /**
36 | * 消耗时间
37 | */
38 | private AttemptTime time;
39 |
40 | /**
41 | * 历史信息
42 | */
43 | private List> history;
44 |
45 | /**
46 | * 基础值
47 | */
48 | private long value;
49 |
50 | /**
51 | * 最小值
52 | */
53 | private long min;
54 |
55 | /**
56 | * 最大值
57 | */
58 | private long max;
59 |
60 | /**
61 | * 变化因子
62 | */
63 | private double factor;
64 |
65 | /**
66 | * 重试等待类
67 | */
68 | private Class retryWait;
69 |
70 | /**
71 | * 请求参数
72 | */
73 | private Object[] params;
74 |
75 |
76 | @Override
77 | public R result() {
78 | return result;
79 | }
80 |
81 | public DefaultRetryWaitContext result(R result) {
82 | this.result = result;
83 | return this;
84 | }
85 |
86 | @Override
87 | public int attempt() {
88 | return attempt;
89 | }
90 |
91 | public DefaultRetryWaitContext attempt(int attempt) {
92 | this.attempt = attempt;
93 | return this;
94 | }
95 |
96 | @Override
97 | public Throwable cause() {
98 | return cause;
99 | }
100 |
101 | public DefaultRetryWaitContext cause(Throwable cause) {
102 | this.cause = cause;
103 | return this;
104 | }
105 |
106 | @Override
107 | public AttemptTime time() {
108 | return time;
109 | }
110 |
111 | public DefaultRetryWaitContext time(AttemptTime time) {
112 | this.time = time;
113 | return this;
114 | }
115 |
116 | @Override
117 | public List> history() {
118 | return history;
119 | }
120 |
121 | public DefaultRetryWaitContext history(List> history) {
122 | this.history = history;
123 | return this;
124 | }
125 |
126 | @Override
127 | public long value() {
128 | return value;
129 | }
130 |
131 | public DefaultRetryWaitContext value(long value) {
132 | this.value = value;
133 | return this;
134 | }
135 |
136 | @Override
137 | public long min() {
138 | return min;
139 | }
140 |
141 | public DefaultRetryWaitContext min(long min) {
142 | this.min = min;
143 | return this;
144 | }
145 |
146 | @Override
147 | public long max() {
148 | return max;
149 | }
150 |
151 | public DefaultRetryWaitContext max(long max) {
152 | this.max = max;
153 | return this;
154 | }
155 |
156 | @Override
157 | public double factor() {
158 | return factor;
159 | }
160 |
161 | public DefaultRetryWaitContext factor(double factor) {
162 | this.factor = factor;
163 | return this;
164 | }
165 |
166 | @Override
167 | public Class retryWait() {
168 | return retryWait;
169 | }
170 |
171 | public DefaultRetryWaitContext retryWait(Class retryWait) {
172 | this.retryWait = retryWait;
173 | return this;
174 | }
175 |
176 | @Override
177 | public Object[] params() {
178 | return params;
179 | }
180 |
181 | public DefaultRetryWaitContext params(Object[] params) {
182 | this.params = params;
183 | return this;
184 | }
185 | }
186 |
--------------------------------------------------------------------------------
/retry-core/src/main/java/com/poldroc/retry/core/core/RetryWaiter.java:
--------------------------------------------------------------------------------
1 | package com.poldroc.retry.core.core;
2 |
3 | import com.poldroc.retry.api.context.RetryWaitContext;
4 | import com.poldroc.retry.api.support.wait.RetryWait;
5 | import com.poldroc.retry.common.annotation.NotThreadSafe;
6 | import com.poldroc.retry.core.constant.RetryWaitConst;
7 | import com.poldroc.retry.core.context.DefaultRetryWaitContext;
8 | import com.poldroc.retry.core.support.wait.ExponentialRetryWait;
9 | import com.poldroc.retry.core.support.wait.IncreaseRetryWait;
10 | import com.poldroc.retry.core.support.wait.NoRetryWait;
11 |
12 | /**
13 | * 重试等待类构造器
14 | *
15 | * @author Poldroc
16 | * @since 2024/7/11
17 | */
18 |
19 | @NotThreadSafe
20 | public class RetryWaiter {
21 |
22 | /**
23 | * 重试等待类的类型
24 | */
25 | private Class retryWait = NoRetryWait.class;
26 |
27 | /**
28 | * 默认的等待时间
29 | */
30 | private long value = RetryWaitConst.DEFAULT_VALUE_MILLS;
31 |
32 | /**
33 | * 最小值
34 | */
35 | private long min = RetryWaitConst.DEFAULT_MIN_MILLS;
36 |
37 | /**
38 | * 最大值
39 | */
40 | private long max = RetryWaitConst.DEFAULT_MAX_MILLS;
41 |
42 | /**
43 | * 变化因子
44 | *
45 | * 1. 如果是 {@link com.poldroc.retry.core.support.wait.ExponentialRetryWait} 则为 {@link com.poldroc.retry.core.constant.RetryWaitConst#MULTIPLY_FACTOR}
46 | *
47 | * 2. 如果是 {@link com.poldroc.retry.core.support.wait.IncreaseRetryWait} 则为 {@link com.poldroc.retry.core.constant.RetryWaitConst#INCREASE_MILLS_FACTOR}
48 | */
49 | private double factor = Double.MIN_VALUE;
50 |
51 | /**
52 | * 构造器私有化
53 | */
54 | private RetryWaiter() {
55 | }
56 |
57 | /**
58 | * 设置重试等待的对象类型
59 | * 并且设置默认的因子
60 | * @param retryWait 重试等待类
61 | * @param 泛型
62 | * @return 重试等待类
63 | */
64 | public static RetryWaiter retryWait(Class retryWait) {
65 | RetryWaiter retryWaiter = new RetryWaiter<>();
66 | retryWaiter.retryWait = retryWait;
67 | if (IncreaseRetryWait.class.equals(retryWait)) {
68 | retryWaiter.factor(RetryWaitConst.INCREASE_MILLS_FACTOR);
69 | }
70 | if (ExponentialRetryWait.class.equals(retryWait)) {
71 | retryWaiter.factor(RetryWaitConst.MULTIPLY_FACTOR);
72 | }
73 | return retryWaiter;
74 | }
75 |
76 | public Class retryWait() {
77 | return retryWait;
78 | }
79 |
80 | public long value() {
81 | return value;
82 | }
83 |
84 | public RetryWaiter value(long value) {
85 | this.value = value;
86 | return this;
87 | }
88 |
89 | public long min() {
90 | return min;
91 | }
92 |
93 | public RetryWaiter min(long min) {
94 | this.min = min;
95 | return this;
96 | }
97 |
98 | public long max() {
99 | return max;
100 | }
101 |
102 | public RetryWaiter max(long max) {
103 | this.max = max;
104 | return this;
105 | }
106 |
107 | public double factor() {
108 | return factor;
109 | }
110 |
111 | public RetryWaiter factor(double factor) {
112 | this.factor = factor;
113 | return this;
114 | }
115 |
116 | /**
117 | * 构建重试等待时间上下文
118 | */
119 | public RetryWaitContext context() {
120 | return new DefaultRetryWaitContext()
121 | .value(value)
122 | .min(min)
123 | .max(max)
124 | .factor(factor)
125 | .retryWait(retryWait);
126 | }
127 | }
128 |
--------------------------------------------------------------------------------
/retry-core/src/main/java/com/poldroc/retry/core/core/Retryer.java:
--------------------------------------------------------------------------------
1 | package com.poldroc.retry.core.core;
2 |
3 | import com.poldroc.retry.api.context.RetryContext;
4 | import com.poldroc.retry.api.context.RetryWaitContext;
5 | import com.poldroc.retry.api.core.Retry;
6 | import com.poldroc.retry.api.support.block.RetryBlock;
7 | import com.poldroc.retry.api.support.condition.RetryCondition;
8 | import com.poldroc.retry.api.support.listen.RetryListen;
9 | import com.poldroc.retry.api.support.recover.Recover;
10 | import com.poldroc.retry.api.support.stop.RetryStop;
11 | import com.poldroc.retry.common.annotation.NotThreadSafe;
12 | import com.poldroc.retry.common.util.ArgUtil;
13 | import com.poldroc.retry.core.context.DefaultRetryContext;
14 | import com.poldroc.retry.core.core.retry.DefaultRetry;
15 | import com.poldroc.retry.core.support.block.ThreadSleepRetryBlock;
16 | import com.poldroc.retry.core.support.condition.RetryConditions;
17 | import com.poldroc.retry.core.support.listen.NoRetryListen;
18 | import com.poldroc.retry.core.support.recover.NoRecover;
19 | import com.poldroc.retry.core.support.stop.MaxAttemptRetryStop;
20 | import com.poldroc.retry.core.support.wait.NoRetryWait;
21 |
22 | import java.util.Arrays;
23 | import java.util.Collections;
24 | import java.util.List;
25 | import java.util.concurrent.Callable;
26 |
27 | /**
28 | * 引导核心类
29 | *
30 | * @author Poldroc
31 | * @since 2024/7/13
32 | */
33 | @NotThreadSafe
34 | public class Retryer implements Retry {
35 |
36 | /**
37 | * 待执行的方法
38 | */
39 | private Callable callable;
40 |
41 | /**
42 | * 重试实现类
43 | * 1. 不推荐用户自定义，但是暴露出来。
44 | */
45 | private Retry retry = DefaultRetry.getInstance();
46 |
47 | /**
48 | * 执行重试的条件
49 | * 1. 默认在遇到异常的时候进行重试
50 | * 2. 支持多个条件，任意一个满足则满足。如果用户有更特殊的需求，应该自己定义。
51 | */
52 | private RetryCondition condition = RetryConditions.hasExceptionCause();
53 |
54 | /**
55 | * 阻塞的方式
56 | * 1. 默认采用线程沉睡的方式
57 | */
58 | private RetryBlock block = ThreadSleepRetryBlock.getInstance();
59 |
60 | /**
61 | * 重试停止的条件
62 | * 1. 默认最多重试 3 次
63 | */
64 | private RetryStop stop = new MaxAttemptRetryStop(3);
65 |
66 | /**
67 | * 监听器
68 | * 1. 默认不进行任何操作
69 | */
70 | private RetryListen listen = NoRetryListen.getInstance();
71 |
72 | /**
73 | * 恢复策略
74 | * 1. 默认不进行任何操作
75 | */
76 | private Recover recover = NoRecover.getInstance();
77 |
78 | /**
79 | * 重试等待上下文
80 | */
81 | private List> waitContexts = Collections.singletonList(RetryWaiter.retryWait(NoRetryWait.class).context());
82 |
83 |
84 | /**
85 | * 创建一个对象实例
86 | *
87 | * @param 泛型
88 | * @return 实例
89 | */
90 | public static Retryer newInstance() {
91 | return new Retryer<>();
92 | }
93 |
94 | /**
95 | * 1. 设置待处理的方法类
96 | * 2. 返回引导类 instance
97 | *
98 | * @param callable 待处理的方法
99 | * @return this
100 | */
101 | public Retryer callable(final Callable callable) {
102 | ArgUtil.notNull(callable, "callable");
103 |
104 | this.callable = callable;
105 | return this;
106 | }
107 |
108 |
109 | /**
110 | * 设置重试实现类
111 | *
112 | * @param retry 重试实现类
113 | * @return this
114 | */
115 | public Retryer retry(Retry retry) {
116 | this.retry = retry;
117 | return this;
118 | }
119 |
120 | /**
121 | * 重试生效条件
122 | *
123 | * @param condition 生效条件
124 | * @return this
125 | */
126 | public Retryer condition(RetryCondition condition) {
127 | ArgUtil.notNull(condition, "condition");
128 |
129 | this.condition = condition;
130 | return this;
131 | }
132 |
133 |
134 | /**
135 | * 重试等待上下文
136 | *
137 | * @param retryWaitContexts 重试等待上下文数组
138 | * @return 重试等待上下文
139 | */
140 | public Retryer retryWaitContext(RetryWaitContext... retryWaitContexts) {
141 | ArgUtil.notEmpty(retryWaitContexts, "retryWaitContexts");
142 | this.waitContexts = Arrays.asList(retryWaitContexts);
143 | return this;
144 | }
145 |
146 | public Retryer retryWaitContext(List> retryWaitContexts) {
147 | ArgUtil.notEmpty(retryWaitContexts, "retryWaitContexts");
148 | this.waitContexts = retryWaitContexts;
149 | return this;
150 | }
151 |
152 | /**
153 | * 最大尝试次数
154 | *
155 | * @param maxAttempt 最大尝试次数
156 | * @return this
157 | */
158 | public Retryer maxAttempt(final int maxAttempt) {
159 | ArgUtil.positive(maxAttempt, "maxAttempt");
160 |
161 | this.stop = new MaxAttemptRetryStop(maxAttempt);
162 | return this;
163 | }
164 |
165 | /**
166 | * 设置阻塞策略
167 | *
168 | * @param block 阻塞策略
169 | * @return this
170 | */
171 | private Retryer block(RetryBlock block) {
172 | ArgUtil.notNull(block, "block");
173 |
174 | this.block = block;
175 | return this;
176 | }
177 |
178 | /**
179 | * 设置停止策略
180 | *
181 | * @param stop 停止策略
182 | * @return this
183 | */
184 | private Retryer stop(RetryStop stop) {
185 | ArgUtil.notNull(stop, "stop");
186 |
187 | this.stop = stop;
188 | return this;
189 | }
190 |
191 | /**
192 | * 设置监听
193 | *
194 | * @param listen 监听
195 | * @return this
196 | */
197 | public Retryer listen(RetryListen listen) {
198 | ArgUtil.notNull(listen, "listen");
199 |
200 | this.listen = listen;
201 | return this;
202 | }
203 |
204 | /**
205 | * 设置恢复策略
206 | *
207 | * @param recover 恢复策略
208 | * @return this
209 | */
210 | public Retryer recover(Recover recover) {
211 | ArgUtil.notNull(recover, "recover");
212 |
213 | this.recover = recover;
214 | return this;
215 | }
216 |
217 |
218 | /**
219 | * 构建重试上下文
220 | *
221 | * @return 重试上下文
222 | */
223 | public RetryContext context() {
224 | // 初始化
225 | return new DefaultRetryContext()
226 | .callable(callable)
227 | .waitContext(waitContexts)
228 | .block(block)
229 | .stop(stop)
230 | .condition(condition)
231 | .listen(listen)
232 | .recover(recover)
233 | .retry(retry);
234 | }
235 |
236 |
237 | /**
238 | * 重试执行
239 | *
240 | * @return 执行结果
241 | */
242 | public R retryCall() {
243 | RetryContext context = context();
244 | return context().retry().retryCall(context);
245 | }
246 |
247 | /**
248 | * 重试执行
249 | *
250 | * @param context 执行上下文
251 | * @return 执行结果
252 | */
253 | @Override
254 | public R retryCall(RetryContext context) {
255 | return context.retry().retryCall(context);
256 | // return context().retry().retryCall(context);
257 | }
258 | }
259 |
--------------------------------------------------------------------------------
/retry-core/src/main/java/com/poldroc/retry/core/core/retry/DefaultRetry.java:
--------------------------------------------------------------------------------
1 | package com.poldroc.retry.core.core.retry;
2 |
3 | import com.poldroc.retry.api.context.RetryContext;
4 | import com.poldroc.retry.api.context.RetryWaitContext;
5 | import com.poldroc.retry.api.core.Retry;
6 | import com.poldroc.retry.api.exception.RetryException;
7 | import com.poldroc.retry.api.model.RetryAttempt;
8 | import com.poldroc.retry.api.model.WaitTime;
9 | import com.poldroc.retry.api.support.block.RetryBlock;
10 | import com.poldroc.retry.api.support.condition.RetryCondition;
11 | import com.poldroc.retry.api.support.listen.RetryListen;
12 | import com.poldroc.retry.api.support.recover.Recover;
13 | import com.poldroc.retry.api.support.stop.RetryStop;
14 | import com.poldroc.retry.api.support.wait.RetryWait;
15 | import com.poldroc.retry.common.annotation.ThreadSafe;
16 | import com.poldroc.retry.common.support.instance.impl.InstanceFactory;
17 | import com.poldroc.retry.core.context.DefaultRetryWaitContext;
18 | import com.poldroc.retry.core.model.DefaultAttemptTime;
19 | import com.poldroc.retry.core.model.DefaultRetryAttempt;
20 | import com.poldroc.retry.core.model.DefaultWaitTime;
21 |
22 | import java.lang.reflect.InvocationTargetException;
23 | import java.util.ArrayList;
24 | import java.util.Date;
25 | import java.util.List;
26 | import java.util.concurrent.Callable;
27 | import java.util.concurrent.TimeUnit;
28 |
29 | /**
30 | * 默认的重试实现
31 | *
32 | * @author Poldroc
33 | * @since 2024/7/11
34 | */
35 |
36 | @ThreadSafe
37 | public class DefaultRetry implements Retry {
38 |
39 | /**
40 | * 获取单例
41 | *
42 | * @return 单例
43 | */
44 | public static DefaultRetry getInstance() {
45 | return InstanceFactory.getInstance().singleton(DefaultRetry.class);
46 | }
47 |
48 | /**
49 | * 重试调用
50 | *
51 | * 1. 执行方法体
52 | * 2. 判断是否需要重试 -> 符合{@link RetryCondition} 重试条件 && 不符合{@link RetryStop} 重试停止条件
53 | * 3. 满足重试条件，并且不满足重试停止条件 -> 计算等待时间 -> 阻塞 -> 重试次数+1 -> 添加重试历史 -> 重新执行 -> 触发监听器
54 | * 4. 满足重试条件，但是满足重试停止条件 -> 触发恢复策略
55 | * 5. 最后一次重试还是有异常，直接抛出异常
56 | * 6. 返回最后一次尝试的结果
57 | *
58 | * @param context 执行上下文
59 | * @return
60 | */
61 | @Override
62 | public R retryCall(RetryContext context) {
63 | List> history = new ArrayList<>();
64 | int attempts = 1;
65 | final Callable callable = context.callable();
66 | RetryAttempt retryAttempt = execute(callable, attempts, history, context);
67 |
68 | final List> waitContextList = context.waitContext();
69 | final RetryCondition retryCondition = context.condition();
70 | final RetryStop retryStop = context.stop();
71 | final RetryBlock retryBlock = context.block();
72 | final RetryListen retryListen = context.listen();
73 |
74 | // 触发执行的 condition 并且 不触发 stop 策略 就进行重试
75 | while (retryCondition.condition(retryAttempt) && !retryStop.stop(retryAttempt)) {
76 | // 线程阻塞
77 | WaitTime waitTime = calcWaitTime(waitContextList, retryAttempt);
78 | retryBlock.block(waitTime);
79 | // 每一次执行会更新 executeResult
80 | attempts++;
81 | history.add(retryAttempt);
82 | retryAttempt = this.execute(callable, attempts, history, context);
83 |
84 | // 触发监听器
85 | retryListen.listen(retryAttempt);
86 | }
87 |
88 | // 仍然满足重试条件，但是满足重试停止条件
89 | if (retryCondition.condition(retryAttempt) && retryStop.stop(retryAttempt)) {
90 | // 触发恢复策略
91 | final Recover recover = context.recover();
92 | recover.recover(retryAttempt);
93 | }
94 |
95 | // 最后一次还是有异常，直接抛出异常
96 | final Throwable throwable = retryAttempt.cause();
97 | if (throwable != null) {
98 | // 1. 运行时异常，则直接抛出
99 | // 2. 非运行时异常，则包装成为 RetryException
100 | if (throwable instanceof RuntimeException) {
101 | throw (RuntimeException) throwable;
102 | }
103 | throw new RetryException(retryAttempt.cause());
104 | }
105 | // 返回最后一次尝试的结果
106 | return retryAttempt.result();
107 | }
108 |
109 | /**
110 | * 构建等待时间
111 | *
112 | * @param waitContextList 等待上下文列表
113 | * @param retryAttempt 重试信息
114 | * @return 等待时间毫秒
115 | */
116 | private WaitTime calcWaitTime(final List> waitContextList,
117 | final RetryAttempt retryAttempt) {
118 | long totalTimeMills = 0;
119 | for (RetryWaitContext context : waitContextList) {
120 | RetryWait retryWait = (RetryWait) InstanceFactory.getInstance().threadSafe(context.retryWait());
121 | final RetryWaitContext retryWaitContext = buildRetryWaitContext(context, retryAttempt);
122 | WaitTime waitTime = retryWait.waitTime(retryWaitContext);
123 | totalTimeMills += TimeUnit.MILLISECONDS.convert(waitTime.time(), waitTime.unit());
124 | }
125 | return new DefaultWaitTime(totalTimeMills);
126 | }
127 |
128 | private RetryWaitContext buildRetryWaitContext(RetryWaitContext waitContext, RetryAttempt retryAttempt) {
129 | DefaultRetryWaitContext context = (DefaultRetryWaitContext) waitContext;
130 | return context.attempt(retryAttempt.attempt())
131 | .cause(retryAttempt.cause())
132 | .result(retryAttempt.result())
133 | .time(retryAttempt.time())
134 | .history(retryAttempt.history())
135 | .params(retryAttempt.params());
136 |
137 | }
138 |
139 | private RetryAttempt execute(final Callable callable,
140 | final int attempts,
141 | final List> history,
142 | final RetryContext context) {
143 |
144 | Date startTime = new Date();
145 | Throwable throwable = null;
146 | R result = null;
147 | try {
148 | result = callable.call();
149 | } catch (Exception e) {
150 | throwable = getActualThrowable(e);
151 | }
152 | Date endTime = new Date();
153 | DefaultAttemptTime attemptTime = new DefaultAttemptTime()
154 | .startTime(startTime)
155 | .endTime(endTime)
156 | .costTimeInMills(endTime.getTime() - startTime.getTime());
157 | return new DefaultRetryAttempt
213 |
214 | ## 模块介绍
215 |
216 | ### retry-api
217 |
218 | * 接口定义模块
219 |
220 | * 参考Netty的接口设计，如果想实现自己的重试框架，可以引入尝试一下
221 |
222 | ### retry-core
223 |
224 | * 核心模块。是对retry-api模块的默认实现
225 | * 拥有`Retryer`引导类，支持用优雅的 **Fluent API** 写出声明式的重试代码
226 |
227 | ### retry-annotation
228 |
229 | * 注解实现模块
230 | * 基于动态代理或者CGLIB字节码实现的代理重试，不依赖spring，灵活使用
231 | * 允许自定义注解及其实现。用户可以模仿`com.poldroc.retry.annotation.annotation.Retry`，通过`@RetryAble()`包装自定义的`RetryAbleHandler`实现类来实现属于自己的重试注解
232 |
233 | ### retry-spring
234 |
235 | * 为Spring框架集成重试功能的模块，允许开发者在Spring应用中无缝使用声明式重试功能，它通过Spring AOP集成了重试机制
236 |
237 | * #### 主要组件
238 |
239 | 1. **`@EnableRetry` 注解**：
240 | 这是一个用于启用Spring重试功能的注解，类似于其他Spring功能的启用注解（如`@EnableCaching`）。它通过`@Import`将`RetryAopConfig`类注入到Spring的应用上下文中，从而启用AOP切面处理
241 | 2. **`RetryAop` 切面类**：
242 | `RetryAop`类负责拦截所有标注了`@Retry`注解的方法，并在方法执行失败时执行重试逻辑。该切面通过获取方法签名、参数等信息，调用重试处理器`RetryMethodHandler`进行实际的重试操作
243 | 3. **`RetryAopConfig` 配置类**：
244 | 这是一个Spring配置类，通过`@ComponentScan`自动扫描并注册spring模块中所有必要的组件（如RetryAop类），确保Spring可以正确管理这些组件
245 |
246 | ### retry-springboot-stater
247 |
248 | * 通过Spring Boot自动配置机制为项目提供开箱即用的重试功能
249 | * 该模板引入了`retry-spring` 模块，通过自动配置机制来使用`@EnableRetry` 注解，自动启用`retry-spring`模块中定义的重试功能。
250 |
251 |
252 |
253 | ## Support
254 |
255 | ### Condition
256 |
257 | 重试触发的条件，可以指定多个条件。默认为抛出异常。
258 |
259 | 基于[RetryCondition](https://github.com/Poldroc/roc-retry/blob/master/retry-api/src/main/java/com/poldroc/retry/api/support/condition/RetryCondition.java)接口，配合[stop](#Stop)使用，当符合condition并且不符合stop，则开始重试。
260 |
261 | `RetryCondition`接口定义如下：
262 |
263 | ```java
264 | public interface RetryCondition