java接口防重提交如何处理

谁践踏了优雅 2024-03-17 16:03 42阅读 0赞

### 1.什么是接口防重？ ###

在一定的时间内多次请求同一接口，同一参数。由于请求是`健康请求`，会执行`正常的业务逻辑`，从而产生大量的废数据。

### 2.问题的产生及引发的问题 ###

举一个最简单的例子：日常开发中crud在业务系统中普遍存在，在服务端没有做任何处理，客户端没有做`节流、防抖`等限流操作时，同一秒一个用户点了两次新增按钮，导致数据库中存在同样两条数据，其结果可想而知，同理修改、删除同样的道理；查询本身具有`幂等性`，但是在同一秒钟同样的操作，查询多次和一次，有区别吗？区别大了去了，不谈用户体验如何，光是`网络开销、流量占用、带给服务器的压力`等等，生产中一点小的问题，如何不及时处理，可能会引发灾难性bug。

### 3.处理方法 ###

*  第一种：前台在请求接口的时候，传递一个唯一值，然后在对应接口判断该唯一值，在一定的时间内是否被消费过
 *  第二种：采用`Spring AOP`理念，实现请求的切割，在请求执行到某个方法或某层时候，开始拦截进行，获取该请求的参数，用户信息，请求地址，存入redis中并放置过期时间，进行防重（推荐使用）

### 4.谈谈以下两种处理方法的利弊 ###

*  第一种：局限性太高，前台必须传递一个唯一值，就算请求到达指定后台服务，写一个拦截器，需要配置太多不需要拦截的方法，也许你会说，可以拦截有规则的请求地址，这样真的好吗?
 *  第二种（推荐）：采用`AOP面向切面编程的思想`，在不污染源代码的情况下，进行增强功能，切入到要防重的接口上，实现统一防重处理、业务解耦。此处采用`AOP + 自定义注解`，灵活实现防重功能。

### 5.具体代码(采用第二种) ###

> 注解类

import java.lang.annotation.*;
    
    /**
     * 防重
     * @date 2020/8/12
     * @return
     */
    //标识该注解用于方法上
    @Target({ElementType.METHOD})
    //申明该注解为运行时注解，编译后改注解不会被遗弃
    @Retention(RetentionPolicy.RUNTIME)
    //javadoc工具记录
    @Documented
    public @interface PreventSubmit 
    {
    }

> 切面类

import com.qianxian.common.exception.AppException;
    import com.qianxian.common.util.TokenUtil;
    import lombok.extern.slf4j.Slf4j;
    import org.apache.commons.lang3.StringUtils;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.redisson.api.RLock;
    import org.redisson.api.RedissonClient;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.StringRedisTemplate;
    import org.springframework.stereotype.Component;
    import org.springframework.web.context.request.RequestAttributes;
    import org.springframework.web.context.request.RequestContextHolder;
    import javax.servlet.http.HttpServletRequest;
    import java.util.Arrays;
    import java.util.concurrent.TimeUnit;
    
    /**
     * 防重复提交
     * @date 2020/8/12
     * @return
     */
    @Component
    @Aspect
    @Slf4j
    public class PreventSubmitAspect {
    
        /**
         * 放重redis前缀
         */
        private static String API_PREVENT_SUBMIT = "api:preventSubmit:";
    
        /**
         * 放重分布式锁前缀
         */
        private static String API_LOCK_PREVENT_SUBMIT = "api:preventSubmit:lock:";
    
        /**
         * 失效时间
         */
        private static Integer INVALID_NUMBER = 3;
    
        /**
         * redis
         */
        @Autowired
        private StringRedisTemplate stringRedisTemplate;
    
        /**
         * 分布式锁
         */
        @Autowired
        private RedissonClient redissonClient;
    
    
        /**
         * 防重
         * @date 2020/8/12
         * @return
         */
        @Around("@annotation(com.qianxian.user.annotation.PreventSubmit)")
        public Object preventSubmitAspect(ProceedingJoinPoint joinPoint) throws Throwable {
    
            RLock lock = null;
    
            try {
    
                //获取目标方法的参数
                Object[] args = joinPoint.getArgs();
    
                //获取当前request请求
                RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
                HttpServletRequest request = (HttpServletRequest) requestAttributes.resolveReference(RequestAttributes.REFERENCE_REQUEST);
    
                //获取请求地址
                String requestUri = request.getRequestURI();
    
                //获取用户ID
                Long userId = null;
                try {
                    userId = TokenUtil.getUserId(request);
                }catch (Exception e){}
    
                //拼接锁前缀，采用同一方法，同一用户,同一接口
                String temp = requestUri.concat(Arrays.asList(args).toString()) + (userId != null ? userId : "");
                temp = temp.replaceAll("/","");
    
                //拼接rediskey
                String lockPrefix = API_LOCK_PREVENT_SUBMIT.concat(temp);
                String redisPrefix = API_PREVENT_SUBMIT.concat(temp);
    
                /**
                 * 对同一方法同一用户同一参数加锁,即使获取不到用户ID,每个用户请求数据也会不一致，不会造成接口堵塞
                 */
                lock = this.redissonClient.getLock(lockPrefix);
                lock.lock();
    
                String flag = this.stringRedisTemplate.opsForValue().get(redisPrefix);
                if(StringUtils.isNotEmpty(flag)){
                    throw new AppException("您当前的操作太频繁了,请稍后再试!");
                }
    
                //存入redis,设置失效时间
                this.stringRedisTemplate.opsForValue()
                                           .set(redisPrefix,redisPrefix,INVALID_NUMBER, TimeUnit.SECONDS);
    
                //执行目标方法
                Object result = joinPoint.proceed(args);
                return result;
    
            }finally {
                if(lock != null){
                    lock.unlock();
                }
            }
    
        }
    
    }