基于Spring-AOP的自定义分片工具

作者：陈昌浩

1 背景

随着数据量的增长，发现系统在与其他系统交互时，批量接口会出现超时现象，发现原批量接口在实现时，没有做分片处理，当数据过大时或超过其他系统阈值时，就会出现错误。由于与其他系统交互比较多，一个一个接口做分片优化，改动量较大，所以考虑通过AOP解决此问题。

2 Spring-AOP

AOP （Aspect Orient Programming）,直译过来就是面向切面编程。AOP 是一种编程思想，是面向对象编程（OOP）的一种补充。面向对象编程将程序抽象成各个层次的对象，而面向切面编程是将程序抽象成各个切面。

Spring 中的 AOP 是通过动态代理实现的。 Spring AOP 不能拦截对对象字段的修改，也不支持构造器连接点,我们无法在 Bean 创建时应用通知。

3 功能实现

自定义分片处理分三个部分：自定义注解（MethodPartAndRetryer）、重试器（RetryUtil）、切面实现(RetryAspectAop)。

3.1 MethodPartAndRetryer

源码

1
2@Target(ElementType.METHOD)
3@Retention(RetentionPolicy.RUNTIME)
4@Documented
5public @interface MethodPartAndRetryer {
6/**
7* 失败重试次数
8* @return
9*/
10int times() default 3;
11/**
12* 失败间隔执行时间 300毫秒
13* @return
14*/
15long waitTime() default 300L;
16/**
17* 分片大小
18* @return
19*/
20int parts() default 200;
21}
22
23

@interface说明这个类是个注解。
@Target是这个注解的作用域

1 
2public enum ElementType {
3/** 类、接口(包括注释类型)或枚举声明 */
4TYPE,
5/** 字段声明(包括枚举常量) */
6FIELD,
7/** 方法声明 */
8METHOD,
9/** 正式的参数声明 */
10PARAMETER,
11/** 构造函数声明 */
12CONSTRUCTOR,
13/** 局部变量声明 */
14LOCAL_VARIABLE,
15/** 注释类型声明*/
16ANNOTATION_TYPE,
17/** 程序包声明 */
18PACKAGE,
19/**类型参数声明*/
20TYPE_PARAMETER,
21/**类型的使用*/
22TYPE_USE
23}
24
25

@Retention注解的生命周期

1public enum RetentionPolicy {
2/** 编译器处理完后不存储在class中*/
3SOURCE,
4/**注释将被编译器记录在类文件中，但不需要在运行时被VM保留。 这是默认值*/
5CLASS,
6/**编译器存储在class中，可以由虚拟机读取*/
7RUNTIME
8}
9
10

times()：接口调用失败时，重试的次数。
waitTime():接口调用失败是，间隔多长时间再次调用。
int parts()：进行分片时，每个分片的大小。

3.2 RetryUtil

源码

1public class RetryUtil<V> {
2
3public Retryer<V> getDefaultRetryer(int times,long waitTime) {
4Retryer<V> retryer = RetryerBuilder.<V>newBuilder()
5.retryIfException()
6.retryIfRuntimeException()
7.retryIfExceptionOfType(Exception.class)
8.withWaitStrategy(WaitStrategies.fixedWait(waitTime, TimeUnit.MILLISECONDS))
9.withStopStrategy(StopStrategies.stopAfterAttempt(times))
10.build();
11return retryer;
12}
13}
14
15

说明

RetryerBuilder：是用于配置和创建Retryer的构建器。
retryIfException：抛出runtime异常、checked异常时都会重试，但是抛出error不会重试。
retryIfRuntimeException：只会在抛runtime异常的时候才重试，checked异常和error都不重试。
retryIfExceptionOfType：允许我们只在发生特定异常的时候才重试。
withWaitStrategy:等待策略，每次请求间隔。
withStopStrategy:停止策略，重试多少次后停止。

3.3 RetryAspectAop

源码：

1public class RetryAspectAop {
2public Object around(final ProceedingJoinPoint point) throws Throwable {
3Object result = null;
4final Object[] args = point.getArgs();
5boolean isHandler1 = isHandler(args);
6if (isHandler1) {
7String className = point.getSignature().getDeclaringTypeName();
8String methodName = point.getSignature().getName();
9Object firstArg = args[0];
10List<Object> paramList = (List<Object>) firstArg;
11//获取方法信息
12Method method = getCurrentMethod(point);
13//获取注解信息
14MethodPartAndRetryer retryable = AnnotationUtils.getAnnotation(method, MethodPartAndRetryer.class);
15//重试机制
16Retryer<Object> retryer = new RetryUtil<Object>().getDefaultRetryer(retryable.times(),retryable.waitTime());
17//分片
18List<List<Object>> requestList = Lists.partition(paramList, retryable.parts());
19for (List<Object> partList : requestList) {
20args[0] = partList;
21Object tempResult = retryer.call(new Callable<Object>() {
22@Override
23public Object call() throws Exception {
24try {
25return point.proceed(args);
26} catch (Throwable throwable) {
27log.error(String.format("分片重试报错,类%s-方法%s",className,methodName),throwable);
28throw new RuntimeException("分片重试出错");
29}
30}
31});
32if (null != tempResult) {
33if (tempResult instanceof Boolean) {
34if (!((Boolean) tempResult)) {
35log.error(String.format("分片执行报错返回类型不能转化bolean,类%s-方法%s",className,methodName));
36throw new RuntimeException("分片执行报错!");
37}
38result = tempResult;
39} else if (tempResult instanceof List) {
40if(result ==null){
41result =Lists.newArrayList();
42}
43((List) result).addAll((List) tempResult);
44}else {
45log.error(String.format("分片执行返回的类型不支持,类%s-方法%s",className,methodName));
46throw new RuntimeException("不支持该返回类型");
47}
48} else {
49log.error(String.format("分片执行返回的结果为空,类%s-方法%s",className,methodName));
50throw new RuntimeException("调用结果为空");
51}
52}
53} else {
54result = point.proceed(args);
55}
56return result;
57}
58private boolean isHandler(Object[] args) {
59boolean isHandler = false;
60if (null != args && args.length > 0) {
61Object firstArg = args[0];
62//如果第一个参数是list 并且数量大于1
63if (firstArg!=null&&firstArg instanceof List &&((List) firstArg).size()>1) {
64isHandler = true;
65}
66}
67return isHandler;
68}
69private Method getCurrentMethod(ProceedingJoinPoint point) {
70try {
71Signature sig = point.getSignature();
72MethodSignature msig = (MethodSignature) sig;
73Object target = point.getTarget();
74return target.getClass().getMethod(msig.getName(), msig.getParameterTypes());
75} catch (NoSuchMethodException e) {
76throw new RuntimeException(e);
77}
78}
79}
80
81

说明：

getCurrentMethod：获取方法信息即要做分片的批量调用的接口。
isHandler1：判断是否要做分片处理，只有第一参数是list并且list 的值大于1时才做分片处理。
around：具体分片逻辑。

获取要分片方法的参数。
判断是否要做分片处理。
获取方法。
获取重试次数、重试间隔时间和分片大小。
生成重试器。
根据设置的分片大小，做分片处理。
调用批量接口并处理结果。

4 功能使用

4.1 配置文件

4.2 代码示例

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

只要在需要做分片的批量接口方法上，加上MethodPartAndRetryer注解就可以，重试次数、重试间隔时间和分片大小可以在注解时设置，也可以使用默认值。

5 小结

通过自定义分片工具，可以快速的对老代码进行分片处理，而且增加了重试机制，提高了程序的可用性，提高了对老代码的重构效率。