Retry 重试机制

public void commonRetry(Map<String, Object> dataMap) throws InterruptedException {
    Map<String, Object> paramMap = Maps.newHashMap();
    paramMap.put("tableName", "creativeTable");
    paramMap.put("ds", "20160220");
    paramMap.put("dataMap", dataMap);
    boolean result = false;
    try {
        result = uploadToOdps(paramMap);
        if (!result) {
            Thread.sleep(1000);
            uploadToOdps(paramMap);  //一次重试
        }
    } catch (Exception e) {
        Thread.sleep(1000);
        uploadToOdps(paramMap);//一次重试
    }
}

public void commonRetry(Map<String, Object> dataMap) throws InterruptedException {
    Map<String, Object> paramMap = Maps.newHashMap();
    paramMap.put("tableName", "creativeTable");
    paramMap.put("ds", "20160220");
    paramMap.put("dataMap", dataMap);
    boolean result = false;
    try {
        result = uploadToOdps(paramMap);
        if (!result) {
            reuploadToOdps(paramMap,1000L,10);//延迟多次重试
        }
    } catch (Exception e) {
        reuploadToOdps(paramMap,1000L,10);//延迟多次重试
    }
}

public void upload(final Map<String, Object> map) throws Exception {
    // 构建重试模板实例
    RetryTemplate retryTemplate = new RetryTemplate();
    // 设置重试策略, 主要设置重试次数
    SimpleRetryPolicy policy = new SimpleRetryPolicy(3, Collections.<Class<? extends Throwable>, Boolean> singletonMap(Exception.class, true));
    // 设置重试回退操作策略, 主要设置重试间隔时间
    FixedBackOffPolicy fixedBackOffPolicy = new FixedBackOffPolicy();
    fixedBackOffPolicy.setBackOffPeriod(100);
    retryTemplate.setRetryPolicy(policy);
    retryTemplate.setBackOffPolicy(fixedBackOffPolicy);
    // 通过RetryCallback 重试回调实例包装正常逻辑逻辑, 第一次执行和重试执行执行的都是这段逻辑
    final RetryCallback<Object, Exception> retryCallback = new RetryCallback<Object, Exception>() {
        //RetryContext 重试操作上下文约定, 统一spring-try包装 
        public Object doWithRetry(RetryContext context) throws Exception {
            System.out.println("do some thing");
            Exception e = uploadToOdps(map);
            System.out.println(context.getRetryCount());
            throw e;//这个点特别注意, 重试的根源通过Exception返回
        }
    };
    // 通过RecoveryCallback 重试流程正常结束或者达到重试上限后的退出恢复操作实例
    final RecoveryCallback<Object> recoveryCallback = new RecoveryCallback<Object>() {
        public Object recover(RetryContext context) throws Exception {
            System.out.println("do recory operation");
            return null;
        }
    };
    try {
        // 由retryTemplate 执行execute方法开始逻辑执行
        retryTemplate.execute(retryCallback, recoveryCallback);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

while(someCondition()) {
    try{
        doSth();
        break;    
    } catch(Throwable th) {
        modifyCondition();
        wait();
    }
}
if(stillFail) {
    doSthWhenStillFail();
}

public void uploadOdps(final Map<String, Object> map) {
    // RetryerBuilder 构建重试实例 retryer,可以设置重试源且可以支持多个重试源, 可以配置重试次数或重试超时时间, 以及可以配置等待时间间隔
    Retryer<Boolean> retryer = RetryerBuilder.<Boolean> newBuilder()
            .retryIfException().//设置异常重试源
            retryIfResult(new Predicate<Boolean>() {//设置自定义段元重试源, 
        @Override
        public boolean apply(Boolean state) {//特别注意: 这个apply返回true说明需要重试, 与操作逻辑的语义要区分
            return true;
        }
    })
    .withStopStrategy(StopStrategies.stopAfterAttempt(5))//设置重试5次, 同样可以设置重试超时时间
    .withWaitStrategy(WaitStrategies.fixedWait(100L, TimeUnit.MILLISECONDS)).build();//设置每次重试间隔

    try {
        //重试入口采用call方法, 用的是java.util.concurrent.Callable<V>的call方法,所以执行是线程安全的
        boolean result = retryer.call(new Callable<Boolean>() { 
            @Override
            public Boolean call() throws Exception {
                try {
                    //特别注意: 返回false说明无需重试, 返回true说明需要继续重试
                    return uploadToOdps(map);
                } catch (Exception e) {
                    throw new Exception(e);
                }
            }
        });

    } catch (ExecutionException e) {
    } catch (RetryException ex) {
    }
}