java-retry實現

有這樣一個需求，當調用某個方法拋出異常，比如通過 HttpClient 調用遠程接口時由於網絡原因報 TimeOut 異常；或者所請求的接口返回類似於“處理中”這樣的信息，需要重復去查結果時，我們希望當前方法能夠在這種特定的情況下，重復執行，如果達到了我們的期望，則不重復執行。而且，我們希望能夠控制重試次數，不希望無限期執行下去。

Java 中有各種定時任務的實現，如 Spring 的 Schedule，Quartz 等，稍微想一下，顯然不符合我們的需求。遞歸倒是可以，但是有些問題，先看下遞歸的實現：

    private int retryTimes = 3;

    @Test
    public void upperMethod() {
        method("123", "456");
    }
    public void method(String param1, String param2) {
        System.out.println(param1 + param2);

        // 其他一些操作，但是沒有得到預期的返回結果，或者拋出異常
        boolean isException = true;
        if(isException && retryTimes > 0){
            retryTimes --;
            method(param1, param2);
        }
    }

method 方法是需要重復執行的，重復執行 3 次，加上第一次執行，一共 4 次。如果異常了，則在 catch 里面遞歸調用 method。如果返回“處理中”等情況，則進行判斷，是否需要遞歸調用。

這里的問題是定義了 retryTimes 這樣一個全局變量，不優雅，如果需要重復執行的方法較多，而且重復次數不一樣，則需定義多個全局變量。遞歸可以優化一下：

    @Test
    public void upperMethod() {
        method(3, "123", "456");
    }

    public void method(int retryTimes,String param1, String param2) {
        System.out.println(param1 + param2);

        // 其他一些操作，但是沒有得到預期的返回結果，或者拋出異常
        boolean isException = true;
        if(isException && retryTimes > 0){
            method(--retryTimes, param1, param2);
        }
    }

這里去掉了全局變量，但是 method 方法多了一個和自身邏輯無關的 retryTimes 變量，還不優雅。如果參數較多，還會顯得混亂。

下面做了一個還算優雅的方法：

    @Test
    public void mainMethod() {
        subMethod("123", "456");
    }

    public void subMethod(String param1, String param2) {
        System.out.println(param1 + param2);
        RetryUtil.setRetryTimes(3).retry(param1, param2);
    }

增加了一個 RetryUtil 的工具類，設置重試次數，然后傳入當前方法的參數，進行重復執行。這里的重點就是 RetryUtil 的實現：

public class RetryUtil {
    private static ThreadLocal<Integer> retryTimesInThread = new ThreadLocal<>();

    /**
     * 設置當前方法重試次數
     *
     * @param retryTimes
     * @return
     */
    public static RetryUtil setRetryTimes(Integer retryTimes) {
        if (retryTimesInThread.get() == null)
            retryTimesInThread.set(retryTimes);
        return new RetryUtil();
    }

    /**
     * 重試當前方法
     * <p>按順序傳入調用者方法的所有參數</p>
     *
     * @param args
     * @return
     */
    public Object retry(Object... args) {
        try {
            Integer retryTimes = retryTimesInThread.get();
            if (retryTimes <= 0) {
                retryTimesInThread.remove();
                return null;
            }
            retryTimesInThread.set(--retryTimes);
            String upperClassName = Thread.currentThread().getStackTrace()[2].getClassName();
            String upperMethodName = Thread.currentThread().getStackTrace()[2].getMethodName();

            Class clazz = Class.forName(upperClassName);
            Object targetObject = clazz.newInstance();
            Method targetMethod = null;
            for (Method method : clazz.getDeclaredMethods()) {
                if (method.getName().equals(upperMethodName)) {
                    targetMethod = method;
                    break;
                }
            }
            if (targetMethod == null)
                return null;
            targetMethod.setAccessible(true);
            return targetMethod.invoke(targetObject, args);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

為了防止多線程情況下出現並發問題，這里定義了一個 ThreadLocal 變量來存儲當前線程的重試次數。然后通過 setRetryTimes ，一個靜態方法來設置這個重試次數，並返回一個 RetryUtil 對象。

調用者通過返回的 RetryUtil 對象調用 retry 方法實現重試。retry 方法接收一個可變參數，因為調用者實際的參數不確定，這里要求按順序傳入調用者方法的所有參數。

接下來判斷 ThreadLocal 變量是否小於等於 0 ，如果是，則說明重復次數已達到，返回 null；如果不是，則讓 ThreadLocal 變量減一。接下來：

String upperClassName = Thread.currentThread().getStackTrace()[2].getClassName();
String upperMethodName = Thread.currentThread().getStackTrace()[2].getMethodName();

來獲取當前方法（retry）的上層方法名和上層類名。Thread.currentThread().getStackTrace() 得到線程的方法棧數組，數組的第二個元素 Thread.currentThread().getStackTrace() [1]  為當前方法棧，第三個元素 Thread.currentThread().getStackTrace() [2] 為上層方法棧，通過上層方法的棧幀得到上層方法的方法名和類名。

下面就是通過反射獲取該類的所有方法，循環判斷方法名是否等於所要重復執行的方法，如果是的話，執行該方法，參數就是傳入可變參數。

可能大家會說反射會耗時，但我認為對於上述這種需求的情況，重試次數也不會太多，因此性能可以接受。