方法重试

方法重试工具类

• 使用了java8新特性-函数式编程Supplier<R>和Predicate<R>

import lombok.extern.slf4j.Slf4j;

import java.util.function.Predicate;
import java.util.function.Supplier;

/**
 * 重试工具类
 *
 * @author wangyuanze
 * @Date 2020/3/18 19:07
 * @since 1.2.2
 **/
@Slf4j
public class RetryUtil {

    /**
     * 默认的重试次数 60 次
     */
    private static final int DEFAULT_RETRY_COUNT = 60;

    /**
     * 默认的重试间隔时间, 1min
     */
    private static final long DEFAULT_INTERVAL_TIME = 60000L;

    /**
     * 返回值为null时方法重试，重试次数和时间间隔默认
     *
     * @param s 带有返回结果的函数
     * @return R
     * @author wangyuanze
     * @Date 2020/3/18 19:18
     * @since 1.2.2
     **/
    public static <R> R nullRetry(Supplier<R> s) {
        return nullRetry(DEFAULT_RETRY_COUNT, DEFAULT_INTERVAL_TIME, s);
    }

    /**
     * 返回值为null时 方法重试
     *
     * @param retryCount   重试次数
     * @param intervalTime 重试时间间隔 单位 ms
     * @param s            带有返回结果的函数
     * @return R
     * @author wangyuanze
     * @Date 2020/3/18 19:19
     * @since 1.2.2
     **/
    public static <R> R nullRetry(int retryCount, long intervalTime, Supplier<R> s) {
        return predictRetry(retryCount, intervalTime, s, r -> r == null);
    }

    /**
     * 根据断言结果为真时 方法重试 ,重试次数和时间间隔默认
     *
     * @param s         带有返回结果的函数
     * @param predicate 断言
     * @return R
     * @author wangyuanze
     * @Date 2020/3/18 20:23
     * @since 1.2.2
     **/
    public static <R> R predictRetry(Supplier<R> s, Predicate<R> predicate) {
        return predictRetry(DEFAULT_RETRY_COUNT, DEFAULT_INTERVAL_TIME, s, predicate);
    }

    /**
     * 根据断言结果为真时 方法重试
     *
     * @param retryCount   重试次数
     * @param intervalTime 重试间隔时间
     * @param s            带有返回结果的函数
     * @param predicate    断言
     * @return R
     * @author wangyuanze
     * @Date 2020/3/18 20:21
     * @since 1.2.2
     **/
    public static <R> R predictRetry(int retryCount, long intervalTime, Supplier<R> s, Predicate<R> predicate) {
        R r = null;
        // 断言不会发生异常
        Predicate exceptionP = t -> Boolean.FALSE;
        try {
            r = s.get();
        } catch (Exception e) {
            exceptionP = t -> Boolean.TRUE;
            log.error(LogFormatter.toLog(CommonErrorCode.ERROR, "tips"), "get result is error ", e);
        }
        // 自定义条件断言成立 或者 异常断言成立 则重试
        if (predicate.or(exceptionP).test(r) && retryCount > 0) {
            try {
                // 让线程休眠
                Thread.sleep(intervalTime);
            } catch (InterruptedException e) {
                log.error(LogFormatter.toLog(CommonErrorCode.ERROR, "tips"), "retry unit sleep interrupted ", e);
            }
            retryCount--;
            log.warn(LogFormatter.toLog(CommonErrorCode.ERROR, "tips", "retry count left"), "get result predict false then retry", retryCount + 1);
            // 线程睡醒后轮询重试
            return predictRetry(retryCount, intervalTime, s, predicate);
        }
        return r;
    }
}