@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MethodPartAndRetryer {
    /**
     * 失敗重試次數(shù) 
     * @return
     */
    int times() default 3;
    /**
     * 失敗間隔執(zhí)行時(shí)間 300毫秒
     * @return
     */
    long waitTime() default 300L;
    /**
     * 分片大小     
     * @return
     */
    int parts() default 200;
}

public enum ElementType {
    /** 類、接口(包括注釋類型)或枚舉聲明   */
    TYPE,
    /** 字段聲明(包括枚舉常量) */
    FIELD,
    /** 方法聲明 */
    METHOD,
    /** 正式的參數(shù)聲明 */
    PARAMETER,
    /** 構(gòu)造函數(shù)聲明 */
    CONSTRUCTOR,
    /** 局部變量聲明 */
    LOCAL_VARIABLE,
    /** 注釋類型聲明*/
    ANNOTATION_TYPE,
    /** 程序包聲明 */
    PACKAGE,
    /**類型參數(shù)聲明*/
    TYPE_PARAMETER,
    /**類型的使用*/
    TYPE_USE
}

public enum RetentionPolicy {
    /** 編譯器處理完后不存儲在class中*/
    SOURCE,
    /**注釋將被編譯器記錄在類文件中，但不需要在運(yùn)行時(shí)被VM保留。 這是默認(rèn)值*/
    CLASS,
    /**編譯器存儲在class中，可以由虛擬機(jī)讀取*/
    RUNTIME
}

public class RetryUtil<V> {

???????    public Retryer<V> getDefaultRetryer(int times,long waitTime) {
        Retryer<V> retryer = RetryerBuilder.<V>newBuilder()
                .retryIfException()
                .retryIfRuntimeException()
                .retryIfExceptionOfType(Exception.class)
                .withWaitStrategy(WaitStrategies.fixedWait(waitTime, TimeUnit.MILLISECONDS))
                .withStopStrategy(StopStrategies.stopAfterAttempt(times))
                .build();
        return retryer;
    }
}

public class RetryAspectAop {
      public Object around(final ProceedingJoinPoint point) throws Throwable {
        Object result = null;
        final Object[] args = point.getArgs();
        boolean isHandler1 = isHandler(args);
        if (isHandler1) {
            String className = point.getSignature().getDeclaringTypeName();
            String methodName = point.getSignature().getName();
            Object firstArg = args[0];
            List<Object> paramList = (List<Object>) firstArg;
            //獲取方法信息
            Method method = getCurrentMethod(point);
            //獲取注解信息
            MethodPartAndRetryer retryable = AnnotationUtils.getAnnotation(method, MethodPartAndRetryer.class);
            //重試機(jī)制
            Retryer<Object> retryer = new RetryUtil<Object>().getDefaultRetryer(retryable.times(),retryable.waitTime());
            //分片
            List<List<Object>> requestList = Lists.partition(paramList, retryable.parts());
            for (List<Object> partList : requestList) {
                args[0] = partList;
                Object tempResult = retryer.call(new Callable<Object>() {
                    @Override
                    public Object call() throws Exception {
                        try {
                            return point.proceed(args);
                        } catch (Throwable throwable) {
                            log.error(String.format("分片重試報(bào)錯(cuò),類%s-方法%s",className,methodName),throwable);
                            throw new RuntimeException("分片重試出錯(cuò)");
                        }
                    }
                });
                if (null != tempResult) {
                    if (tempResult instanceof Boolean) {
                        if (!((Boolean) tempResult)) {
                            log.error(String.format("分片執(zhí)行報(bào)錯(cuò)返回類型不能轉(zhuǎn)化bolean,類%s-方法%s",className,methodName));
                            throw new RuntimeException("分片執(zhí)行報(bào)錯(cuò)!");
                        }
                        result = tempResult;
                    } else if (tempResult instanceof List) {
                        if(result ==null){
                            result =Lists.newArrayList();
                        }
                        ((List) result).addAll((List) tempResult);
                    }else {
                        log.error(String.format("分片執(zhí)行返回的類型不支持,類%s-方法%s",className,methodName));
                        throw new RuntimeException("不支持該返回類型");
                    }
                } else {
                    log.error(String.format("分片執(zhí)行返回的結(jié)果為空,類%s-方法%s",className,methodName));
                    throw new RuntimeException("調(diào)用結(jié)果為空");
                }
            }
        } else {
            result = point.proceed(args);
        }
        return result;
    }
    private boolean isHandler(Object[] args) {
        boolean isHandler = false;
        if (null != args && args.length > 0) {
            Object firstArg = args[0];
            //如果第一個(gè)參數(shù)是list 并且數(shù)量大于1
            if (firstArg!=null&&firstArg instanceof List &&((List) firstArg).size()>1) {
                isHandler = true;
            }
        }
        return isHandler;
    }
    private Method getCurrentMethod(ProceedingJoinPoint point) {
        try {
            Signature sig = point.getSignature();
            MethodSignature msig = (MethodSignature) sig;
            Object target = point.getTarget();
            return target.getClass().getMethod(msig.getName(), msig.getParameterTypes());
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        }
    }
}

@MethodPartAndRetryer(parts=100)
public Boolean writeBackOfGoodsSN(List<SerialDTO> listSerial,ObCheckWorker workerData)