前言

在日常工作中，隨著業(yè)務(wù)日漸龐大，不可避免的涉及到調(diào)用遠(yuǎn)程服務(wù)，但是遠(yuǎn)程服務(wù)的健壯性和網(wǎng)絡(luò)穩(wěn)定性都是不可控因素，因此，我們需要考慮合適的重試機(jī)制去處理這些問題，最基礎(chǔ)的方式就是手動重試，侵入業(yè)務(wù)代碼去處理，再高端一點(diǎn)的通過切面去處理，較為優(yōu)雅的實(shí)現(xiàn)重試，下面，介紹兩個(gè)重試框架，只需要配置好重啟策略及重試任務(wù)，即可使用。

重試任務(wù)

這里只是模擬傳參、相應(yīng)及異常，具體任務(wù)需對應(yīng)業(yè)務(wù)

package com.example.test.MessageRetry;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.RandomUtils;
import org.springframework.remoting.RemoteAccessException;

@Slf4j
public class RetryTask {
    /**
     * 重試方法
     * @param param
     * @return
     */
    public static boolean retryTask(String param){
        log.info("請求參數(shù)：{}",param);
        int i = RandomUtils.nextInt(0,15);
        log.info("隨機(jī)數(shù)：{}",i);
        if(i == 0){
            log.error("參數(shù)異常");
            throw new IllegalArgumentException("參數(shù)異常");
        }else if(i > 10){
            log.error("訪問異常");
            throw new RemoteAccessException("訪問異常");
        }else if(i % 2 == 0){
            log.info("成功");
            return true;
        }else{
            log.info("失敗");
            return false;
        }
    }
}

Spring-Retry

簡介

Spirng-Retry是Spring提供的一個(gè)重試框架，為spring程序提供聲明式重試支持，主要針對可能拋出異常的調(diào)用操作，進(jìn)行有策略的重試。可以通過代碼方式和注解方式實(shí)現(xiàn)，主要由重試執(zhí)行者和兩個(gè)策略構(gòu)成：

• RetryTemplet：重試執(zhí)行者，可以設(shè)置重試策略（設(shè)置重試上線、如何重試）和回退策略（立即重試還是等待一段時(shí)間后重試，默認(rèn)立即重試，如果需要配置等待一段時(shí)間后重試則需要指定回退策略），通過Execute提交執(zhí)行操作，只有在調(diào)用時(shí)拋出指定配置的異常，才會執(zhí)行重試
• 重試策略：

• 重試回退策略：

• 此外，還需要配置重試時(shí)間間隔、最大重試次數(shù)以及可重試異常

實(shí)現(xiàn)

代碼方式

RetryTemplate通過execute提交執(zhí)行操作，需要準(zhǔn)備RetryCallback和RecoveryCallback兩個(gè)類實(shí)例，前者對應(yīng)的就是重試回調(diào)邏輯實(shí)例，包裝正常的功能操作，RecoveryCallback實(shí)現(xiàn)的是整個(gè)執(zhí)行操作結(jié)束的恢復(fù)操作實(shí)例，只有在調(diào)用的時(shí)候拋出了異常，并且異常是在exceptionMap中配置的異常，才會執(zhí)行重試操作，否則就調(diào)用到excute方法的第二個(gè)執(zhí)行方法RecoveryCallback中

package com.example.test.MessageRetry;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.remoting.RemoteAccessException;
import org.springframework.retry.annotation.Backoff;
import org.springframework.retry.annotation.Recover;
import org.springframework.retry.annotation.Retryable;
import org.springframework.retry.backoff.FixedBackOffPolicy;
import org.springframework.retry.policy.SimpleRetryPolicy;
import org.springframework.retry.support.RetryTemplate;
import org.springframework.stereotype.Service;

import java.util.HashMap;
import java.util.Map;

@Service
@Slf4j
public class SpringRetryService {
    /**
     * 重試時(shí)間間隔ms，默認(rèn)1000ms
     */
    private long retryPeriodTime = 5000L;
    /**
     * 最大重試次數(shù)
     */
    private int maxRetryNum = 3;
    /**
     * 哪些結(jié)果和異常要重試，key表示異常類型，value表示是否需要重試
     */
    private Map<Class<? extends Throwable>,Boolean> retryMap = new HashMap<>();

    @Test
    public void test(){
        retryMap.put(IllegalArgumentException.class,true);
        retryMap.put(RemoteAccessException.class,true);

        //構(gòu)建重試模板
        RetryTemplate retryTemplate = new RetryTemplate();
        //設(shè)置重試回退操作策略，主要設(shè)置重試時(shí)間間隔
        FixedBackOffPolicy backOffPolicy = new FixedBackOffPolicy();
        backOffPolicy.setBackOffPeriod(retryPeriodTime);
        //設(shè)置重試策略，主要設(shè)置重試次數(shù)
        SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy(maxRetryNum,retryMap);

        retryTemplate.setRetryPolicy(retryPolicy);
        retryTemplate.setBackOffPolicy(backOffPolicy);

        Boolean execute = retryTemplate.execute(
                //RetryCallback
                retryContext -> {
                    boolean b = RetryTask.retryTask("aaa");
                    log.info("調(diào)用結(jié)果：{}",b);
                    return b;
                },
                retryContext -> {
                    //RecoveryCallback
                    log.info("到達(dá)最多嘗試次數(shù)");
                    return false;
                }
        );
        log.info("執(zhí)行結(jié)果：{}",execute);
    }
}

注解方式

上面我們說到Spring-Retry是Spring提供的，那么，它就支持依賴整合

<!--spring-retry-->
        <dependency>
            <groupId>org.springframework.retry</groupId>
            <artifactId>spring-retry</artifactId>
            <version>1.2.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.1</version>
        </dependency>

然后，在啟動類上添加開啟注解

//表示是否開啟重試，屬性proxyTargetClass，boolean類型，是否創(chuàng)建基于子類（CGLIB）的代理，而不是標(biāo)準(zhǔn)的基于接口的代理，默認(rèn)false
@EnableRetry

package com.example.test.MessageRetry;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.RandomUtils;
import org.springframework.remoting.RemoteAccessException;

@Slf4j
public class RetryTask {
    /**
     * 重試方法
     * @param param
     * @return
     */
    public static boolean retryTask(String param){
        log.info("請求參數(shù)：{}",param);
        int i = RandomUtils.nextInt(0,15);
        log.info("隨機(jī)數(shù)：{}",i);
        if(i >-1){
            log.error("參數(shù)異常");
            throw new IllegalArgumentException("參數(shù)異常");
//        }else if(i > 10){
//            log.error("訪問異常");
//            throw new RemoteAccessException("訪問異常");
//        }else if(i % 2 == 0){
//            log.info("成功");
//            return true;
        }else{
            log.info("失敗");
            return false;
        }
    }
}

/**
     * 重試調(diào)用方法
     * @param param
     * @return
     * @Retryable注解：
     *
     */
    @Retryable(value = {RemoteAccessException.class,IllegalArgumentException.class},maxAttempts = 3,backoff = @Backoff(delay = 5000L,multiplier = 2))
    public void call(String param){
        RetryTask.retryTask(param);
    }

    /**
     * 達(dá)到最大重試次數(shù)，或拋出了沒有指定的異常
     * @param e
     * @param param
     * @return
     */
    @Recover
    public void recover(Exception e,String param){
        log.error("達(dá)到最大重試次數(shù)！?。。?！");
    }

@Test
    public void retry(){
        springRetryService.call("aaa");
    }

• @Retryable注解說明

• @Backoff注解說明：設(shè)定重試倍數(shù)，每次重試時(shí)間是上次的n倍

• @Recover注解說明：當(dāng)重試到達(dá)指定次數(shù)時(shí)，將要回調(diào)的方法

• @Retryable和@Recover修飾的方法要在同一個(gè)類中,且被@Retryable和@Recover標(biāo)記的方法不能有返回值，這樣Recover方法才會生效。由于@Retryable注解是通過切面實(shí)現(xiàn)的，因此我們要避免@Retryable 注解的方法的調(diào)用方和被調(diào)用方處于同一個(gè)類中，因?yàn)檫@樣會使@Retryable 注解失效。
  
  我們可以看到，Spring-Retry只能針對指定異常重試，不能根據(jù)執(zhí)行結(jié)果返回值重試，整體使用也比較死板，下面，看下更加靈活的Guava-Retry。

Guava-Retry

簡介

Guava-Retry是谷歌的Guava庫的一個(gè)小擴(kuò)展，允許為任意函數(shù)調(diào)用創(chuàng)建可配置的重試策略，我們可以通過構(gòu)建重試實(shí)例RetryBuilder，來設(shè)置重試源、配置重試次數(shù)、重試超時(shí)時(shí)間、等待時(shí)間間隔等，實(shí)現(xiàn)優(yōu)雅的重試機(jī)制。

• 主要屬性

• 時(shí)間限制策略

• 重試策略（重試異常）

• 停止策略

• 等待策略

代碼

<!--guava-retryer-->
        <dependency>
            <groupId>com.github.rholder</groupId>
            <artifactId>guava-retrying</artifactId>
            <version>2.0.0</version>
        </dependency>

package com.example.test.MessageRetry;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.RandomUtils;
import org.springframework.remoting.RemoteAccessException;

@Slf4j
public class RetryTask {
    /**
     * 重試方法
     * @param param
     * @return
     */
    public static boolean retryTask(String param){
        log.info("請求參數(shù)：{}",param);
        int i = RandomUtils.nextInt(0,15);
        log.info("隨機(jī)數(shù)：{}",i);
        if(i < 3){
            log.error("參數(shù)異常");
            throw new IllegalArgumentException("參數(shù)異常");
        }else if(i > 10){
            log.error("訪問異常");
            throw new RemoteAccessException("訪問異常");
        }else if(i % 2 == 0){
            log.info("成功");
            return true;
        }else{
            log.info("失敗");
            return false;
        }
    }
}

package com.example.test.MessageRetry;

import com.github.rholder.retry.*;
import com.google.common.base.Predicates;
import lombok.extern.slf4j.Slf4j;
import org.springframework.remoting.RemoteAccessException;
import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;

@Service
@Slf4j
public class GuavaRetryService {
   
    public void guavaRetry(){
        //構(gòu)建重試實(shí)例RetryBuilder，可以設(shè)置重試源，可以配置重試次數(shù)、重試超時(shí)時(shí)間、等待時(shí)間間隔
        Retryer<Boolean>retryer = RetryerBuilder.<Boolean>newBuilder()
                //設(shè)置異常重試源
                .retryIfExceptionOfType(RemoteAccessException.class)
                .retryIfExceptionOfType(IllegalArgumentException.class)
                //設(shè)置根據(jù)結(jié)果重試  res->res==false  Predicates.containsPattern("_error$")
                .retryIfResult(Predicates.equalTo(false))
                //設(shè)置等待時(shí)間
                .withWaitStrategy(WaitStrategies.fixedWait(3, TimeUnit.SECONDS))
                //設(shè)置最大重試次數(shù)
                .withStopStrategy(StopStrategies.stopAfterAttempt(3))
                //設(shè)置重試監(jiān)聽，可用作重試時(shí)的額外動作
                .withRetryListener(new RetryListener() {
                    @Override
                    public <V> void onRetry(Attempt<V> attempt) {
                        log.error("第【{}】次調(diào)用失敗",attempt.getAttemptNumber());
                    }
                })
                //設(shè)置阻塞策略
                .withBlockStrategy(BlockStrategies.threadSleepStrategy())
                //設(shè)置時(shí)間限制
                .withAttemptTimeLimiter(AttemptTimeLimiters.noTimeLimit())
                .build();
        try{
            retryer.call(()->RetryTask.retryTask("aaa"));
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

可以看到，我們設(shè)置了重試三次，超過這個(gè)限制沒有執(zhí)行成功，拋出了重試異常，而且也可以根據(jù)我們的返回結(jié)果來判斷。

總結(jié)

Spring-Retry和Guava-Retry都是線程安全的重試框架，能夠保證并發(fā)業(yè)務(wù)下重試邏輯的正確性。兩者都很好的將正常方法和重試方法進(jìn)行了解耦，可以設(shè)置超時(shí)時(shí)間、重試次數(shù)、間隔時(shí)間、監(jiān)聽結(jié)果等，相比來說，Guava-Retry比Spring-Retry更加靈活，并且可以通過返回值來進(jìn)行重試，兩者都是非常好的重試框架，具體的選用看相關(guān)的業(yè)務(wù)場景即可。文章來源地址http://www.zghlxwxcb.cn/news/detail-640230.html

到了這里，關(guān)于重試框架入門：Spring-Retry&Guava-Retry的文章就介紹完了。如果您還想了解更多內(nèi)容，請?jiān)谟疑辖撬阉鱐OY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！