SpringBoot+Redis实现接口防刷功能

场景描述:

        在实际开发中,当前端请求后台时,如果后端处理比较慢,但是用户是不知情的,此时后端仍在处理,但是前端用户以为没点到,那么再次点击又发起请求,就会导致在短时间内有很多请求给到后台,可能会出现后台崩溃或者数据重复添加的问题。那么如何解决这个问题呢?

        为了避免短时间内对一个接口访问,我们可以通过AOP+自定义注解+Redis的方式,在接口上加一个自定义注解,然后通过AOP的前置通知,在Redis中存入一个有效期的值,当访问接口时这个值还未过期,则返回提示信息给前端,以此来避免短时间内对接口的方法。

        本文以一个文件下载的接口为例:假设文件下载会在20S内完成,当第一次下载的时候,在redis中存入一个key,并设置其过期时间为20s。当后续发起多次请求的时候,提示:访问过于频繁。先准备一个文件:

SpringBoot+Redis实现接口防刷功能_第1张图片

 SpringBoot+Redis实现接口防刷功能_第2张图片

实现过程:

(1)创建一个自定义注解,其中包括两个属性,一个是key,一个是key在Redis中的有效时间


import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface LimitAccess {

    /**
     * 限制访问的key
     * @return
     */
    String key();

    /**
     * 限制访问时间
     * @return
     */
    int times();
}

(2)创建对应的切面



import com.example.demo.anno.LimitAccess;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import java.util.concurrent.TimeUnit;

/**
 * AOP类(通知类)
 */
@Component
@Aspect
public class LimitAspect {

    @Autowired
    private RedisTemplate redisTemplate;

    @Pointcut("@annotation(com.example.demo.anno.LimitAccess)")
    public void pt(){};

    @Around("pt()")
    public Object aopAround(ProceedingJoinPoint pjp) throws Throwable {
        // 获取切入点上面的自定义注解
        Signature signature = pjp.getSignature();
        MethodSignature methodSignature = (MethodSignature) signature;
        // 获取方法上面的注解
        LimitAccess limitAccess = methodSignature.getMethod().getAnnotation(LimitAccess.class);
        // 获取注解上面的属性
        int limit = limitAccess.times();
        String key = limitAccess.key();
        // 根据key去找Redis中的值
        Object o = redisTemplate.opsForValue().get(key);
        // 如果不存在,说明是首次访问,存入Redis,过期时间为limitAccess中的time
        if (o == null) {
            redisTemplate.opsForValue().set(key, "", limit, TimeUnit.SECONDS);
            // 执行切入点的方法
            return pjp.proceed();
        } else {
            // 如果存在,说明不是首次访问,给出提示信息
            return  "访问过于频繁";
        }
    }
}

(3)在需要限制的接口上,加上注解,并设置key和限制访问时间

    @GetMapping("/download")
    @LimitAccess(key = "download_key", times = 20)
    public String downLoadFile(HttpServletRequest request, HttpServletResponse response) {
        FileInputStream inputStream = null;
        BufferedInputStream bufferedInputStream = null;
        OutputStream outputStream = null;
        try {
            File file = ResourceUtils.getFile("classpath:template/show.txt");
            if (file.exists()) {
                String fileName = file.getName();
                String mineType = request.getServletContext().getMimeType(fileName);
                response.setContentType(mineType);
                response.setHeader("content-type", "application/form-data");
                response.setHeader("Content-disposition", "attachment; fileName=" + fileName);
                inputStream = new FileInputStream(file);
                bufferedInputStream = new BufferedInputStream(inputStream);
                outputStream = response.getOutputStream();
                int len = 0;
                byte[] buff = new byte[1024];
                while ((len = bufferedInputStream.read(buff)) != -1) {
                    outputStream.write(buff, 0, len);
                }

            } else {
                return "下载的文件资源不存在";
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (inputStream != null) {
                    try {
                        inputStream.close();
                    } catch (IOException e) {
                        throw new RuntimeException(e);
                    }
                }
                if (bufferedInputStream != null) {
                    bufferedInputStream.close();
                }
                if (outputStream != null) {
                    outputStream.flush();
                    outputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return "success";
    }

测试结果:

第一次访问:

SpringBoot+Redis实现接口防刷功能_第3张图片

第二次访问:

SpringBoot+Redis实现接口防刷功能_第4张图片

当download_key过期后,则可以继续下载!

你可能感兴趣的:(SpringBoot,spring,boot,redis,后端,java,开发语言)