基于Spring-AOP实现自定义分片工具详解

目录
  • 1.背景
  • 2.Spring-AOP
  • 3.功能实现
    • 3.1 MethodPartAndRetryer
    • 3.2 RetryUtil
    • 3.3 RetryAspectAop
  • 4.功能使用
    • 4.1 配置文件
    • 4.2 代码示例
  • 5.小结

1.背景

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

2.Spring-AOP

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

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

3.功能实现

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

3.1 MethodPartAndRetryer

源码

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MethodPartAndRetryer {
    /**
     * 失败重试次数
     * @return
     */
    int times() default 3;
    /**
     * 失败间隔执行时间 300毫秒
     * @return
     */
    long waitTime() default 300L;
    /**
     * 分片大小
     * @return
     */
    int parts() default 200;
}

@interface说明这个类是个注解。

@Target是这个注解的作用域

public enum ElementType {
    /** 类、接口(包括注释类型)或枚举声明   */
    TYPE,
    /** 字段声明(包括枚举常量) */
    FIELD,
    /** 方法声明 */
    METHOD,
    /** 正式的参数声明 */
    PARAMETER,
    /** 构造函数声明 */
    CONSTRUCTOR,
    /** 局部变量声明 */
    LOCAL_VARIABLE,
    /** 注释类型声明*/
    ANNOTATION_TYPE,
    /** 程序包声明 */
    PACKAGE,
    /**类型参数声明*/
    TYPE_PARAMETER,
    /**类型的使用*/
    TYPE_USE
}

@Retention注解的生命周期

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

times():接口调用失败时,重试的次数。

waitTime():接口调用失败是,间隔多长时间再次调用。

int parts():进行分片时,每个分片的大小。

3.2 RetryUtil

源码

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;
    }
}

说明

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

3.3 RetryAspectAop

源码:

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);
            //重试机制
            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("分片重试报错,类%s-方法%s",className,methodName),throwable);
                            throw new RuntimeException("分片重试出错");
                        }
                    }
                });
                if (null != tempResult) {
                    if (tempResult instanceof Boolean) {
                        if (!((Boolean) tempResult)) {
                            log.error(String.format("分片执行报错返回类型不能转化bolean,类%s-方法%s",className,methodName));
                            throw new RuntimeException("分片执行报错!");
                        }
                        result = tempResult;
                    } else if (tempResult instanceof List) {
                        if(result ==null){
                            result =Lists.newArrayList();
                        }
                        ((List) result).addAll((List) tempResult);
                    }else {
                        log.error(String.format("分片执行返回的类型不支持,类%s-方法%s",className,methodName));
                        throw new RuntimeException("不支持该返回类型");
                    }
                } else {
                    log.error(String.format("分片执行返回的结果为空,类%s-方法%s",className,methodName));
                    throw new RuntimeException("调用结果为空");
                }
            }
        } 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];
            //如果第一个参数是list 并且数量大于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);
        }
    }
}

说明:

getCurrentMethod:获取方法信息即要做分片的批量调用的接口。

isHandler1:判断是否要做分片处理,只有第一参数是list并且list 的值大于1时才做分片处理。

around:具体分片逻辑。

  • 获取要分片方法的参数。
  • 判断是否要做分片处理。
  • 获取方法。
  • 获取重试次数、重试间隔时间和分片大小。
  • 生成重试器。
  • 根据设置的分片大小,做分片处理。

调用批量接口并处理结果。

4.功能使用

4.1 配置文件

4.2 代码示例

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

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

5.小结

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

到此这篇关于基于SpringAOP实现自定义分片工具详解的文章就介绍到这了,更多相关SpringAOP自定义分片工具内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • springboot使用自定义注解实现aop切面日志

    平时我们在开发过程中,代码出现bug时为了更好的在服务器日志中寻找问题根源,会在接口的首尾打印日志,看下参数和返回值是否有问题.但是手动的logger.info() 去编写时工作量较大,这时我们可以使用AOP切面,为所有接口的首尾打印日志. 实现AOP切面日志一般有两种方式: 1.拦截所有接口controller,在首尾打印日志2.拦截指定注解的接口,为有该注解的接口首尾打印日志 我们尝试用自定义注解来实现AOP日志的打印,这样拥有更高的灵活性.废话不多说,我们开始 1. 导入切面需要的依赖包

  • Spring AOP实现复杂的日志记录操作(自定义注解)

    目录 Spring AOP复杂的日志记录(自定义注解) 第一步 第二步 第三步 第四步 多个注解可以合并成一个,包括自定义注解 比如说SpringMVC的注解 Spring AOP复杂的日志记录(自定义注解) 做项目中,业务逻辑要求只要对数据库数据进行改动的都需要记录日志(增删改),记录的内容有操作者.操作的表名及表名称.具体的操作,以及操作对应的数据. 首先想到的就是Spring 的AOP功能.可是经过一番了解过后,发现一般的日志记录,只能记录一些简单的操作,例如表名.表名称等记录不到. 于是

  • Spring AOP 实现自定义注解的示例

    自工作后,除了一些小项目配置事务使用过 AOP,真正自己写 AOP 机会很少,另一方面在工作后还没有写过自定义注解,一直很好奇注解是怎么实现他想要的功能的,刚好做项目的时候,经常有人日志打得不够全,经常出现问题了,查日志的才发现忘记打了,所以趁此机会,搜了一些资料,用 AOP + 自定义注解,实现请求拦截,自定义打日志,玩一下这两个东西,以下是自己完的一个小例子,也供需要的同学参考. 1. 注解如下: package cn.bridgeli.demo.annotation;   import j

  • Spring AOP 自定义注解的实现代码

    1.在Maven中加入以下以依赖: <!-- Spring AOP + AspectJ by shipengzhi --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-aop</artifactId> <version>3.0.6.RELEASE</version> </dependency> <

  • SpringBoot中利用AOP和拦截器实现自定义注解

    目录 前言 Spring实现自定义注解 1.引入相关依赖 2.相关类 Java实现自定义注解 通过Cglib实现 通过JDk动态代理实现 Cglib和JDK动态代理的区别 写在最后 前言 最近遇到了这样一个工作场景,需要写一批dubbo接口,再将dubbo接口注册到网关中,但是当dubbo接口异常的时候会给前端返回非常不友好的异常.所以就想要对异常进行统一捕获处理,但是对于这种service接口使用@ExceptionHandler注解进行异常捕获也是捕获不到的,应为他不是Controller的

  • Spring AOP执行先后顺序实例详解

    这篇文章主要介绍了Spring AOP执行先后顺序实例详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 众所周知,spring声明式事务是基于AOP实现的,那么,如果我们在同一个方法自定义多个AOP,我们如何指定他们的执行顺序呢? 网上很多答案都是指定order,order越小越是最先执行,这种也不能算是错,但有些片面. 配置AOP执行顺序的三种方式: 通过实现org.springframework.core.Ordered接口 @Compo

  • 基于Laravel-admin 后台的自定义页面用法详解

    Laravel-admin 这个后台很好用,几乎省去了html和js的困扰,让后台CURD变得优雅简洁. 这是一个自定义面的Demo 路由定义: $router->get('mails/send', 'MailController@send'); $router->post('mails/send', 'MailController@send'); 控制中写法: public function send(Content $content) { //添加请求 if (request()->

  • Spring AOP事务管理的示例详解

    目录 转账案例-环境搭建 步骤1:准备数据库表 步骤2:创建项目导入jar包 步骤3:根据表创建模型类 步骤4:创建Dao接口 步骤5:创建Service接口和实现类 步骤6:添加jdbc.properties文件 步骤7:创建JdbcConfig配置类 步骤8:创建MybatisConfig配置类 步骤9:创建SpringConfig配置类 步骤10:编写测试类 事务管理 转账案例-环境搭建 步骤1:准备数据库表 之前我们在整合Mybatis的时候已经创建了这个表,可以直接使用 create

  • spring aop的简单使用方法详解

    AOP:[动态代理] 指在程序运行期间动态的将某段代码切入到指定方法指定位置进行运行的编程方式: 1.导入aop模块:Spring AOP:(spring-aspects) 2.定义一个业务逻辑类(MathCalculator):在业务逻辑运行的时候将日志进行打印(方法之前.方法运行结束.方法出现异常,xxx) 3.定义一个日志切面类(LogAspects):切面类里面的方法需要动态感知MathCalculator.div运行到哪里然后执行: 通知方法: 前置通知(@Before):logSta

  • Spring Aop基本流程原理示例详解

    一.代理对象的创建过程: AbstractAutowireCapableBeanFactory#initializeBean protectedObjectinitializeBean(StringbeanName,Objectbean,@NullableRootBeanDefinitionmbd){ if(System.getSecurityManager()!=null){ AccessController.doPrivileged((PrivilegedAction<Object>)()

  • Spring AOP注解案例及基本原理详解

    切面:Aspect 切面=切入点+通知.在老的spring版本中通常用xml配置,现在通常是一个类带上@Aspect注解.切面负责将 横切逻辑(通知) 编织 到指定的连接点中. 目标对象:Target 将要被增强的对象. 连接点:JoinPoint 可以被拦截到的程序执行点,在spring中就是类中的方法. 切入点:PointCut 需要执行拦截的方法,也就是具体实施了横切逻辑的方法.切入点的规则在spring中通过AspectJ pointcut expression language来描述.

  • 基于 Spring Aop 环绕通知实现 Redis 缓存双删功能(示例代码)

    基于 spring aop 常规应用场景多是用于日志记录以及实现 redis 分布式锁,在 github 中也有项目是把它拿来当作缓存的异常捕捉.从而避免影响实际业务的开发:在某天,笔者有个业务开发是给某个服务模块增加 redis 缓存.增加缓存就会涉及 redis 删除.所以笔者就在思考是不是可以用环绕通知的方式来进行实现 代码实现 结构示意图: 自定义注解 RedisDelByDbUpdate @Repeatable 表示允许在同一个地方上使用相同的注解,没有该注解时贴相同注解会报错 @Ta

  • Spring框架实现AOP的两种方式详解

    目录 第一种AOP实现方式 AfterLog Log 配置文件 实例调用 定义接口 第二种AOP实现方式 第一种AOP实现方式 AfterLog package com.xxx.demo.service1; import org.junit.After; import org.springframework.aop.AfterReturningAdvice; import java.lang.reflect.Method; public class AfterLog implements Aft

  • Spring IOC和aop的原理及实例详解

    这篇文章主要介绍了Spring IOC和aop的原理及实例详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架.特点是面向接口编程,松耦合. 1:IOC(控制反转) 别名(DI:依赖注入) 首先来一段ioc的实现原来代码: public class ClassPathXmlApplicationContext implements BeanFactory { privat

  • spring boot微服务自定义starter原理详解

    这篇文章主要介绍了spring boot微服务自定义starter原理详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 使用spring boot开发微服务后,工程的数量大大增加(一定要按照领域来切,不要一个中间件客户端包一个),让各个jar从开发和运行时自包含成了一个重要的内容之一.spring boot starter就可以用来解决该问题(没事启动时别依赖于applicationContext.getBean获取bean进行处理,依赖关系

随机推荐

其他