Java函数调用重试的正确姿势

最新推荐文章于 2023-09-04 09:26:13 发布
最新推荐文章于 2023-09-04 09:26:13 发布
阅读量2.3k 收藏 3
点赞数 2
分类专栏： Java基础 通用方案
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w605283073/article/details/89038394
版权

1、引言

业务开发中很可能与回到重试的场景。

重试主要在调用失败时重试，尤其是发生dubbo相关异常，网络相关异常的时候。

下面对该功能简单作封装，然后给出一些相对用的多一些的开源代码地址。

 

核心功能
提供重试工具类，
支持传入操作、重试次数和延时时间。
支持定义不再重试的异常和条件。

主要应用场景
只要适用于对任务丢失要求不高的场景。
此工具类只适合单机版，因此任务的丢失要求高的场景建议用中间件，如缓存中间件redis或者消息中间件。

 主要场景如下：
- 乐观锁重试
- 上游业务保证重试的场景且没有其他好的重试机制
- 需要轮询直到得到想要的结果的场景
- 其他需要控制重试时间间隔的场景

 

2、简单封装

github地址 https://github.com/chujianyun/simple-retry4j

maven依赖

https://search.maven.org/search?q=a:simple-retry4j

 

可下载运行，可fork改进，欢迎提出宝贵意见，欢迎贡献代码。

 

封装重试策略

package com.github.chujianyun.simpleretry4j;

import lombok.Data;
import org.apache.commons.collections4.CollectionUtils;

import java.time.Duration;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.function.Predicate;

/**
 * 重试策略
 *
 * @author: 明明如月 liuwangyangedu@163.com
 * @date: 2019-04-05 10:06
 */
@Data
public class RetryPolicy {

    /**
     * 最大重试次数（如果不设置则默认不满足重试的异常或策略则无限重试）
     */
    private Integer maxRetries;

    /**
     * 延时时间
     */
    private Duration delayDuration;

    /**
     * 不需要重试的异常列表
     */
    private List<Class<? extends Exception>> abortExceptions;

    /**
     * 不需要重试的条件列表(满足其中一个则不重试,如果要传入泛型条件是返回值或者其父类类型)
     */
    private List<Predicate> abortConditions;


    public RetryPolicy(Builder builder) {

        this.maxRetries = builder.maxRetries;
        this.delayDuration = builder.delayDuration;

        List<Class<? extends Exception>> abortExceptions = builder.abortExceptions;
        if (CollectionUtils.isEmpty(abortExceptions)) {
            this.abortExceptions = new ArrayList<>();
        } else {
            this.abortExceptions = abortExceptions;
        }

        List<Predicate> abortConditions = builder.abortConditions;
        if (CollectionUtils.isEmpty(abortConditions)) {
            this.abortConditions = new ArrayList<>();
        } else {
            this.abortConditions = abortConditions;
        }
    }


    public static Builder builder() {
        return new Builder();
    }

    public static class Builder {

        private Integer maxRetries;

        private Duration delayDuration;

        private List<Class<? extends Exception>> abortExceptions = new ArrayList<>();

        private List<Predicate> abortConditions = new ArrayList<>();


        /**
         * 设置最大重试次数（如果不设置则默认不满足重试的异常或策略则无限重试）
         */
        public Builder maxRetries(Integer maxRetries) {
            if (maxRetries == null || maxRetries < 0) {
                throw new IllegalArgumentException("maxRetries must not be null or negative");
            }
            this.maxRetries = maxRetries;
            return this;
        }

        /**
         * 重试的时间间隔
         */
        public Builder delayDuration(Duration delayDuration) {
            if (delayDuration == null || delayDuration.isNegative()) {
                throw new IllegalArgumentException("delayDuration must not be null or negative");
            }

            this.delayDuration = delayDuration;
            return this;
        }

        /**
         * 重试的时间间隔
         */
        public Builder delayDuration(Integer time, TimeUnit timeUnit) {
            if (time == null || time < 0) {
                throw new IllegalArgumentException("time must not be null or negative");
            }
            if (timeUnit == null) {
                throw new IllegalArgumentException("timeUnit must not be null or negative");
            }
            this.delayDuration = Duration.ofMillis(timeUnit.toMillis(time));
            return this;
        }

        /**
         * 设置不重试的策略列表
         */
        public Builder abortConditions(List<Predicate> predicates) {
            if (CollectionUtils.isNotEmpty(predicates)) {
                predicates.forEach(this::abortCondition);
            }
            return this;
        }

        /**
         * 新增不重试的策略
         */
        public Builder abortCondition(Predicate predicate) {
            if (predicate != null) {
                this.abortConditions.add(predicate);
            }
            return this;
        }

        /**
         * 设置不重试的异常列表
         */
        public Builder abortExceptions(List<Class<? extends Exception>> abortExceptions) {
            if (CollectionUtils.isNotEmpty(abortExceptions)) {
                abortExceptions.forEach(this::abortException);
            }
            return this;
        }

        /**
         * 新增不重试的异常
         */
        public Builder abortException(Class<? extends Exception> exception) {
            if (exception != null) {
                this.abortExceptions.add(exception);
            }
            return this;
        }

        public RetryPolicy build() {
            return new RetryPolicy(this);
        }

    }

}

 

封装重试工具类

package com.github.chujianyun.simpleretry4j;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;

import java.time.Duration;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.function.Consumer;
import java.util.function.Predicate;

/**
 * 方法重试工具类
 *
 * @author: 明明如月 liuwangyangedu@163.com
 * @date: 2019-04-05 02:09
 */
@Slf4j
public class SimpleRetryUtil {

    /**
     * 无返回值的重试方法
     */
    public static <T> void executeWithRetry(Consumer<T> consumer, T data, RetryPolicy retryPolicy) throws Exception {
        executeWithRetry(null, consumer, data, retryPolicy);
    }

    /**
     * 带返回值的重试方法
     */
    public static <T> T executeWithRetry(Callable<T> callable, RetryPolicy retryPolicy) throws Exception {

        return executeWithRetry(callable, null, null, retryPolicy);
    }


    /**
     * 带重试和延时的操作执行
     *
     * @param callable    执行的操作
     * @param retryPolicy 重试策略
     * @return 返回值
     * @throws Exception 业务异常或者超过最大重试次数后的最后一次尝试抛出的异常
     */
    private static <T> T executeWithRetry(Callable<T> callable, Consumer<T> consumer, T data, RetryPolicy retryPolicy) throws Exception {

        // 最大重试次数
        Integer maxRetries = retryPolicy.getMaxRetries();

        if (maxRetries != null && maxRetries < 0) {
            throw new IllegalArgumentException("最大重试次数不能为负数");
        }

        int retryCount = 0;
        Duration delayDuration = retryPolicy.getDelayDuration();

        while (true) {
            try {

                // 不带返回值的
                if (consumer != null) {
                    consumer.accept(data);
                    return null;
                }

                //  带返回值的
                if (callable != null) {
                    T result = callable.call();

                    // 不设置终止条件或者设置了且满足则返回，否则还会重试
                    List<Predicate> abortConditions = retryPolicy.getAbortConditions();
                    /* ---------------- 不需要重试的返回值 -------------- */
                    if (isInCondition(result, abortConditions)) {
                        return result;
                    }

                    /* ---------------- 需要重试的返回值 -------------- */
                    boolean hasNextRetry = hasNextRetryAfterOperation(++retryCount, maxRetries, delayDuration);
                    if (!hasNextRetry) {
                        return result;
                    }
                }
            } catch (Exception e) {
                /* ---------------- 不需要重试的异常 -------------- */
                List<Class<? extends Exception>> abortExceptions = retryPolicy.getAbortExceptions();
                if (isInExceptions(e, abortExceptions)) {
                    throw e;
                }

                /* ---------------- 需要重试的异常 -------------- */
                boolean hasNextRetry = hasNextRetryAfterOperation(++retryCount, maxRetries, delayDuration);
                if (!hasNextRetry) {
                    throw e;
                }
            }
        }
    }

    /**
     * 判断运行之后是否还有下一次重试
     */
    private static boolean hasNextRetryAfterOperation(int retryCount, Integer maxRetries, Duration delayDuration) throws InterruptedException {
        // 有限次重试
        if (maxRetries != null) {
            if (retryCount > maxRetries) {
                return false;
            }
        }

        // 延时
        if (delayDuration != null && !delayDuration.isNegative()) {
            log.debug("延时{}毫秒", delayDuration.toMillis());
            Thread.sleep(delayDuration.toMillis());
        }
        log.debug("第{}次重试", retryCount);
        return true;
    }


    /**
     * 是否在异常列表中
     */
    private static boolean isInExceptions(Exception e, List<Class<? extends Exception>> abortExceptions) {
        if (CollectionUtils.isEmpty(abortExceptions)) {
            return false;
        }
        for (Class<? extends Exception> clazz : abortExceptions) {
            if (clazz.isAssignableFrom(e.getClass())) {
                return true;
            }
        }
        return false;
    }

    /**
     * 是否符合不需要终止的条件
     */
    private static <T> boolean isInCondition(T result, List<Predicate> abortConditions) {
        if (CollectionUtils.isEmpty(abortConditions)) {
            return true;
        }

        for (Predicate predicate : abortConditions) {
            if (predicate.test(result)) {
                return true;
            }
        }
        return false;
    }

}

 

遇到业务异常就没必要重试了，直接扔出去。

当遇到非业务异常是，未超出最大重试次数时，不断重试，如果设置了延时则延时后重试。

测试类

package com.github.chujianyun.simpleretry4j;

import com.github.chujianyun.simpleretry4j.exception.BusinessException;
import lombok.extern.slf4j.Slf4j;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.TestInstance;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.powermock.modules.junit4.PowerMockRunner;

import java.time.Duration;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;
import java.util.function.Consumer;

import static org.mockito.ArgumentMatchers.any;

/**
 * 重试测试
 *
 * @author: 明明如月 liuwangyangedu@163.com
 * @date: 2019-04-04 10:42
 */
@Slf4j
@RunWith(PowerMockRunner.class)
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
public class SimpleRetryUtilTest {

    @Mock
    private Callable<Integer> callable;

    @Mock
    private Consumer<List<Integer>> consumer;

    /**
     * 提供两种设置延时时间的方法
     */
    @Test
    public void delayDuration() {
        RetryPolicy retryPolicy1 = RetryPolicy.builder()
                .maxRetries(3)
                .delayDuration(Duration.ofMillis(5))
                .build();

        RetryPolicy retryPolicy2 = RetryPolicy.builder()
                .maxRetries(3)
                .delayDuration(5, TimeUnit.MILLISECONDS)
                .build();
        Assert.assertEquals(retryPolicy1.getDelayDuration(), retryPolicy2.getDelayDuration());
    }

    /**
     * 模拟异常重试
     */
    @Test(expected = Exception.class)
    public void executeWithRetry_Exception() throws Exception {
        RetryPolicy retryPolicy = RetryPolicy.builder()
                .maxRetries(3)
                .build();

        Mockito.doThrow(new Exception("test")).when(callable).call();

        SimpleRetryUtil.executeWithRetry(callable, retryPolicy);
    }

    /**
     * 模拟异常重试
     */
    @Test(expected = BusinessException.class)
    public void executeWithRetry_BusinessException() throws Exception {

        RetryPolicy retryPolicy = RetryPolicy.builder()
                .maxRetries(3)
                .delayDuration(Duration.ofMillis(100))
                .build();

        Mockito.doThrow(new BusinessException()).when(callable).call();

        SimpleRetryUtil.executeWithRetry(callable, retryPolicy);
    }

    /**
     * 模拟终止异常不重试
     */
    @Test(expected = IllegalArgumentException.class)
    public void executeWithAbortException() throws Exception {

        RetryPolicy retryPolicy = RetryPolicy.builder()
                .maxRetries(3)
                .delayDuration(Duration.ofMillis(100))
                .abortException(IllegalArgumentException.class)
                .abortException(BusinessException.class)
                .build();

            Mockito.doThrow(new IllegalArgumentException()).doReturn(1).when(callable).call();

            Integer result = SimpleRetryUtil.executeWithRetry(callable, retryPolicy);
            log.debug("最终返回值{}", result);
    }

    /**
     * 模拟不在终止异常触发重试
     */
    @Test
    public void executeWithAbortException2() throws Exception {

        RetryPolicy retryPolicy = RetryPolicy.builder()
                .maxRetries(3)
                .delayDuration(Duration.ofMillis(100))
                .abortException(BusinessException.class)
                .build();

        Mockito.doThrow(new NullPointerException()).doReturn(1).when(callable).call();

        Integer result = SimpleRetryUtil.executeWithRetry(callable, retryPolicy);
        log.debug("最终返回值{}", result);
    }

    /**
     * 满足条件的返回值不重试的设置
     */
    @Test
    public void executeWithAbortCondition() throws Exception {

        RetryPolicy retryPolicy = RetryPolicy.builder()
                .maxRetries(3)
                .delayDuration(Duration.ofMillis(100))
                .abortCondition(Objects::nonNull)
                .build();

        //前两次返回null 需要重试
        Mockito.doReturn(null).doReturn(null).doReturn(1).when(callable).call();

        Integer result = SimpleRetryUtil.executeWithRetry(callable, retryPolicy);
        log.debug("最终返回值{}", result);
    }

    /**
     * 测试无返回值的情况
     */
    @Test
    public void consumerTest() throws Exception {
        RetryPolicy retryPolicy = RetryPolicy.builder()
                .maxRetries(3)
                .delayDuration(Duration.ofMillis(100))
                .build();
        List<Integer> data = new ArrayList<>(4);
        data.add(1);
        data.add(2);
        data.add(3);
        data.add(4);

        Mockito.doThrow(new RuntimeException("测试")).doThrow(new RuntimeException("测试2")).doAnswer(invocationOnMock -> {
            Object param = invocationOnMock.getArgument(0);
            System.out.println("消费成功，列表个数" + ((List) param).size());
            return param;
        }).when(consumer).accept(any());

        SimpleRetryUtil.executeWithRetry(consumer, data, retryPolicy);
    }


}

日志配置

# 设置
log4j.rootLogger = debug,stdout

# 输出信息到控制抬
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target = System.out
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern = [%-5p] %d{yyyy-MM-dd HH:mm:ss,SSS} method:%l%n%m%n

pom文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.github.chujianyun</groupId>
    <artifactId>simple-retry4j</artifactId>
    <version>1.1.2</version>
    <packaging>jar</packaging>

    <name>simple-retry4j</name>
    <description>A Java method retry and batch execute open source lib.</description>
    <url>https://github.com/chujianyun/simple-retry4j/tree/master</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <junit-jupiter.version>5.3.1</junit-jupiter.version>

        <maven.compiler.target>1.8</maven.compiler.target>
        <maven.compiler.source>1.8</maven.compiler.source>
    </properties>

    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-api -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.26</version>
        </dependency>

        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.25</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.2</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.8.1</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-collections4 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-collections4</artifactId>
            <version>4.3</version>
        </dependency>

        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-engine</artifactId>
            <version>${junit-jupiter.version}</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.powermock</groupId>
            <artifactId>powermock-module-junit4</artifactId>
            <version>2.0.0</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.powermock</groupId>
            <artifactId>powermock-api-mockito2</artifactId>
            <version>2.0.0</version>
            <scope>test</scope>
        </dependency>

    </dependencies>


    <licenses>
        <license>
            <name>The Apache Software License, Version 2.0</name>
            <url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
            <distribution>repo</distribution>
        </license>
    </licenses>
    <developers>
        <developer>
            <name>liuwangyang</name>
            <email>liuwangyangedu@163.com</email>
            <organization>https://github.com/chujianyun</organization>
            <timezone>+8</timezone>
        </developer>
    </developers>
    <scm>
        <connection>scm:git:git@github.com:chujianyun/simple-retry4j.git</connection>
        <developerConnection>scm:git:git@github.com:chujianyun/simple-retry4j.git</developerConnection>
        <url>https://github.com/chujianyun/simple-retry4j/tree/master</url>
    </scm>

    <distributionManagement>
        <snapshotRepository>
            <id>ossrh</id>
            <url>https://oss.sonatype.org/content/repositories/snapshots</url>
        </snapshotRepository>
        <repository>
            <id>ossrh</id>
            <url>https://oss.sonatype.org/service/local/staging/deploy/maven2/</url>
        </repository>
    </distributionManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-source-plugin</artifactId>
                <version>2.2.1</version>
                <executions>
                    <execution>
                        <id>attach-sources</id>
                        <goals>
                            <goal>jar-no-fork</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-javadoc-plugin</artifactId>
                <version>2.9.1</version>
                <configuration>
                    <show>private</show>
                    <nohelp>true</nohelp>
                    <charset>UTF-8</charset>
                    <encoding>UTF-8</encoding>
                    <docencoding>UTF-8</docencoding>
                    <additionalparam>-Xdoclint:none</additionalparam>  <!-- TODO 临时解决不规范的javadoc生成报错,后面要规范化后把这行去掉 -->
                </configuration>
                <executions>
                    <execution>
                        <id>attach-javadocs</id>
                        <goals>
                            <goal>jar</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-gpg-plugin</artifactId>
                <version>1.5</version>
                <executions>
                    <execution>
                        <id>sign-artifacts</id>
                        <phase>verify</phase>
                        <goals>
                            <goal>sign</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.sonatype.plugins</groupId>
                <artifactId>nexus-staging-maven-plugin</artifactId>
                <version>1.6.7</version>
                <extensions>true</extensions>
                <configuration>
                    <serverId>ossrh</serverId>
                    <nexusUrl>https://oss.sonatype.org/</nexusUrl>
                    <autoReleaseAfterClose>true</autoReleaseAfterClose>
                </configuration>
            </plugin>
        </plugins>
    </build>


</project>

3、其他方案

 

https://github.com/rholder/guava-retrying

https://github.com/elennick/retry4j

 

明明如月学长
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java自定义函数调用方法解析
08-25
"Java自定义函数调用方法解析" Java语言中，自定义函数的调用方法是非常重要的概念，它对于Java开发者来说是必备的知识。本文将通过详细的示例代码，介绍Java自定义函数调用方法解析的主要内容，包括在主类中自定义...
java jni调用c函数实例分享(java调用c函数)
09-04
在Java程序中调用C或C++函数时，JNI起到了桥梁的作用，它提供了Java虚拟机（JVM）和本地代码之间的接口。下面将详细介绍如何使用JNI在Java程序中调用C函数的步骤。 首先，我们需要理解JNI的基本概念。JNI接口定义了...
Java编程Retry重试机制实例详解
08-28
主要介绍了Java编程Retry重试机制实例详解，分享了相关代码示例，小编觉得还是挺不错的，具有一定借鉴价值，需要的朋友可以参考下
java函数式编程实现--重试策略
broccoli2的博客
02-26 441
@FunctionInterFace interface SimpleFunc<T>{ T exec(); } public class RetryExecutor{ private static final Logger log = LOggerFactory.getLogger(RetryExecutor.class); private static final int ATTEMPTS = 20; private static final int SLEEP_UNIT =
Java实现几种简单的重试机制
Cowboy
11-03 1270
Java实现几种简单的重试机制 - 简书
Java 如何优雅的使用重试Retryer
Harry的博客
11-01 7321
好久没写过博客了，今天更新一下 给大家介绍一个重试的工具类 Guava-retrying 话不多说，直接上依赖 <!-- https://mvnrepository.com/artifact/com.github.rholder/guava-retrying --> <dependency> <groupId>com.github....
后端研究-面向Java函数调用路径的测试用例生成方法研究.pdf
06-25
后端研究-面向Java函数调用路径的测试用例生成方法研究 本研究论文主要探讨了面向Java函数调用路径的测试用例生成方法，以提高软件测试的效率。通过分析Java程序的特点，提出了带控制条件的函数调用路径生成算法，...
Java构造函数的相互调用代码示例
08-28
Java构造函数的相互调用代码示例 Java构造函数的相互调用代码示例是Java编程中的一个重要知识点。通过使用this关键字，可以在一个构造函数中调用另一个构造函数，以减少代码量。下面是相关的知识点： 1. 构造函数...
java调用python中的自定义函数函数
02-16
本文将深入探讨如何在Java中调用Python的自定义函数，特别是执行加法运算。我们将重点关注以下几个方面：Java与Python的互操作性、使用Apache的Jython库以及实际的代码示例。 首先，我们要理解Java与Python之间的互...
方法重试工具类
weixin_44081032的博客
08-08 158
工具类, java8的方法参数是可以传函数 @Component @Slf4j public class RetryHandler { @Autowired private RetryProperties retryProperties; public <T> T retry(Supplier<T> supplier){ return retry(supplier, retryProperties.getRe
java如何优雅的使用重试Retryer
good_boys的博客
04-22 476
给大家介绍一个重试的工具类 Guava-retrying <!-- https://mvnrepository.com/artifact/com.github.rholder/guava-retrying --> <dependency> <groupId>com.github.rholder</groupId> <artifactId>guava-retrying</artifactId> <versio
Datax之自定义重试工具类RetryUtil
恐龙弟旺仔的博客
11-11 1145
前言： 在日常的开发中，针对某个业务逻辑，我们经常会有执行失败后再重试一次的需求。重试根据异常的不同则会有不同的方案。当然重试也不是失败后立即重试，有可能是等待固定时间后重试，也有可能是指数级等待时间重试，重试N次后则最终判定失败，不再重试。 基于这种需求，阿里开源的datax工具中，也有相应的工具类，就是RetryUtil，笔者就来简单分析下这个util类。 1.datax之RetryUtil public final class RetryUtil { private stat.
java重复执行函数函数_性能 – Java – 重复的函数调用减少了执行时间
weixin_42255060的博客
03-02 215
我有以下代码public class BenchMark {public static void main(String args[]) {doLinear();doLinear();doLinear();doLinear();}private static void doParallel() {IntStream range = IntStream.range(1, 6).parallel();...
Java超大函数代码重构案例分析——使用反射、函数式接口Function、建造者模式Builder重构
daizuojian
03-04 446
这里存在的问题，eto这个方法名太随意，不能准确表达方法意思，同时由于entity字段较多，需要将其中29个字段转换，直接new对象，虽然很好理解，但是不够优雅，造成超大函数，进行了第一次重构。项目中某一个函数被代码检查工具扫出来137行，属于超大函数（大于50行的函数），经过两次重构达到自己认为的理想状态，使用到了反射，函数式接口，以及建造者模式来完成。下面案例介绍，涉及项目代码，部分简化，仅供给大家参考思想，如有更好的重构方法，欢迎留言。
开始Resilience4j-retry 异常重试模块的学习
最新发布
ywtech的博客
09-04 549
开始Resilience4j-retry模块的学习
DATAX如果数据库连接信息错误，设置，重试几次连接
吃素的哈士奇de博客
05-12 2468
DATAX如果数据库连接信息错误，设置，重试几次连接1.校验JDBCRUL的类DBUtil2. 方法内的方法RetryUtil.executeWithRetry 1.校验JDBCRUL的类DBUtil 方法：chooseJdbcUrl 下面展示一些 内联代码片。 // A code block var foo = 'bar'; public static String chooseJdbcUrl(final DataBaseType dataBaseType,
java优雅重试机制spring-retry
qq_34905631的博客
10-02 2680
使用JDK动态代理和CGLib动态代理（对目标类进行增强处理）加上spring的AOP（统一的切入调用拦截）加上反射机制（让公共逻辑更加的通用），通过AOP对方法调用进行拦截然后通过动态代理来生成代理对象给目标类的目标方法的调用的前后进行增强处理同时在加上try/catch处理调用目标方法，这种就可以写成一个公共的实现思路模型。/**log . info("监听到重试过程关闭了");log . info("监听到重试过程错误了");log . info("监听到重试过程开启了");
Java 中的 7 种重试机制，还有谁不会？！
m0_71777195的博客
08-08 897
从手动重试，到使用 Spring AOP 自己动手实现，再到站在巨人肩上使用特别优秀的开源实现 Spring Retry 和 Google guava-retrying，经过对各种重试实现方式的介绍，可以看到以上几种方式基本上已经满足大部分场景的需要：如果是基于 Spring 的项目，使用 Spring Retry 的注解方式已经可以解决大部分问题如果项目没有使用 Spring 相关框架，则适合使用 Google guava-retrying：自成体系，使用起来更加灵活强大。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

明明如月学长

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值