一个注解搞定接口防刷!还有谁不会?

点击上方 "编程技术圈"关注, 星标或置顶一起成长

后台回复“大礼包”有惊喜礼包!

日英文

Anywhere, it is a good in the past, recall the number of times many, all would be light. 

任何地方,再好的过去,回忆的次数多了,一切也就淡了。

每日掏心话

你知不知道。我用所有的勇气走近你,你的好与不好,我都在不断地发现,不停地接收,我心里能够装下的,全是和你有关的东西。

责编:乐乐 | 来自:CS打赢你链接:blog.csdn.net/weixin_42533856/article/details/82593123

编程技术圈(ID:study_tech)第 1195 次推文

往日回顾:新版Win10来了!网友:丑哭了

     

   正文   



说明:使用了注解的方式进行对接口防刷的功能,非常高大上,本文章仅供参考一,技术要点:springboot的基本知识,redis基本操作,
首先是写一个注解类:
import java.lang.annotation.Retention;
import java.lang.annotation.Target;

import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

/**
 * @author yhq
 * @date 2018/9/10 15:52
 */

@Retention(RUNTIME)
@Target(METHOD)
public @interface AccessLimit {

    int seconds();
    int maxCount();
    boolean needLogin()default true;
}
接着就是在Interceptor拦截器中实现:搜索顶级架构师公众号回复“架构整洁”,送你一份惊喜礼包。

import com.alibaba.fastjson.JSON;
import com.example.demo.action.AccessLimit;
import com.example.demo.redis.RedisService;
import com.example.demo.result.CodeMsg;
import com.example.demo.result.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.OutputStream;

/**
 * @author yhq
 * @date 2018/9/10 16:05
 */


@Component
public class FangshuaInterceptor extends HandlerInterceptorAdapter {

    @Autowired
    private RedisService redisService;

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        //判断请求是否属于方法的请求
        if(handler instanceof HandlerMethod){

            HandlerMethod hm = (HandlerMethod) handler;

            //获取方法中的注解,看是否有该注解
            AccessLimit accessLimit = hm.getMethodAnnotation(AccessLimit.class);
            if(accessLimit == null){
                return true;
            }
            int seconds = accessLimit.seconds();
            int maxCount = accessLimit.maxCount();
            boolean login = accessLimit.needLogin();
            String key = request.getRequestURI();
            //如果需要登录
            if(login){
                //获取登录的session进行判断
                //.....
                key+=""+"1";  //这里假设用户是1,项目中是动态获取的userId
            }

            //从redis中获取用户访问的次数
            AccessKey ak = AccessKey.withExpire(seconds);
            Integer count = redisService.get(ak,key,Integer.class);
            if(count == null){
                //第一次访问
                redisService.set(ak,key,1);
            }else if(count < maxCount){
                //加1
                redisService.incr(ak,key);
            }else{
                //超出访问次数
                render(response,CodeMsg.ACCESS_LIMIT_REACHED); //这里的CodeMsg是一个返回参数
                return false;
            }
        }

        return true;

    }
    private void render(HttpServletResponse response, CodeMsg cm)throws Exception {
        response.setContentType("application/json;charset=UTF-8");
        OutputStream out = response.getOutputStream();
        String str  = JSON.toJSONString(Result.error(cm));
        out.write(str.getBytes("UTF-8"));
        out.flush();
        out.close();
    }
}
再把Interceptor注册到springboot中
import com.example.demo.ExceptionHander.FangshuaInterceptor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

/**
 * @author yhq
 * @date 2018/9/10 15:58
 */
@Configuration
public class WebConfig extends WebMvcConfigurerAdapter {

    @Autowired
    private FangshuaInterceptor interceptor;


    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(interceptor);
    }
}
接着在Controller中加入注解import com.example.demo.result.Result;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 * @author yhq
 * @date 2018/9/10 15:49
 */

@Controller
public class FangshuaController {

    @AccessLimit(seconds=5, maxCount=5, needLogin=true)
    @RequestMapping("/fangshua")
    @ResponseBody
    public Result<String> fangshua(){


        return Result.success("请求成功");

    }
本文有参考其他视频的教学,希望可以帮助更多热爱it行业的人,
PS:欢迎在留言区留下你的观点,一起讨论提高。如果今天的文章让你有新的启发,欢迎转发分享给更多人。版权申明:内容来源网络,版权归原创者所有。除非无法确认,我们都会标明作者及出处,如有侵权烦请告知,我们会立即删除并表示歉意。谢谢!

欢迎加入后端架构师交流群,在后台回复“学习”即可。

在这里,我为大家准备了一份2021年最新最全BAT等大厂Java面试经验总结
别找了,想获取史上最简单的Java大厂面试题学习资料
扫下方二维码回复「手册」就好了


猜你还想看
阿里、腾讯、百度、华为、京东最新面试题汇集
HashMap 面试二十一问!看它就够了!

不要再满屏写 try...catch 了!这个更香!

纠结!拼多多和国家电网 Offer ,我选了活着
嘿,你在看吗?

### 回答1: 好的,为了实现 Spring Boot 接口防刷的切面和注解,您需要执行以下步骤: 1. 在您的 Spring Boot 应用中创建一个切面类。在该类中,您可以使用 `@Aspect` 注解声明它是一个切面。 2. 在切面类中创建一个方法,使用 `@Around` 注解声明它是一个环绕通知方法。环绕通知方法可以在目标方法执行前后执行指定的代码。 3. 在环绕通知方法中,使用 `@Pointcut` 注解声明切点,并使用 `ProceedingJoinPoint` 类的 `proceed()` 方法执行目标方法。 4. 在环绕通知方法中,使用注解来声明需要进行防刷的方法。您可以自定义注解,并使用 `@Target` 和 `@Retention` 注解来声明该注解可以用在方法上。 5. 在环绕通知方法中,使用注解中的参数来控制方法的访问频率。您可以使用任意方式来实现这一点,例如使用缓存或者计数器。 以下是一个简单的例子,该例子使用了注解 `@AntiBrush` 来声明需要进行防刷的方法,并使用了缓存来实现防刷功能: ``` @Aspect @Component public class AntiBrushAspect { private Cache<String, AtomicInteger> cache = CacheBuilder.newBuilder().expireAfterWrite(1, TimeUnit.MINUTES).build ### 回答2: 首先,我们需要定义一个自定义注解,用于标识某个接口需要进行防刷限制。我们可以定义一个名为AntiSpam的注解,代码如下: ```java @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) public @interface AntiSpam { int limit() default 10; // 默认限制为10秒内只能请求10次 } ``` 接下来,我们需要实现一个切面来拦截带有AntiSpam注解接口。首先,需要引入以下依赖: ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> ``` 然后,在你的Spring Boot应用程序中创建一个名为AntiSpamAspect的类,代码如下: ```java @Aspect @Component public class AntiSpamAspect { private ConcurrentHashMap<String, Long> methodLastAccessTimeMap = new ConcurrentHashMap<>(); @Around("@annotation(antiSpam)") public Object handleAntiSpam(ProceedingJoinPoint joinPoint, AntiSpam antiSpam) throws Throwable { String methodName = joinPoint.getSignature().toShortString(); Long lastAccessTime = methodLastAccessTimeMap.get(methodName); long currentTime = System.currentTimeMillis(); if (lastAccessTime != null && currentTime - lastAccessTime < (antiSpam.limit() * 1000)) { throw new RuntimeException("操作频率过高,请稍后再试!"); } else { methodLastAccessTimeMap.put(methodName, currentTime); return joinPoint.proceed(); } } } ``` 在上面的代码中,我们使用了ConcurrentHashMap来存储每个方法最后一次访问的时间。在处理切面时,我们会根据方法名从map中获取上一次访问时间,并与当前时间进行比较。如果两次访问间隔小于限定时间,则抛出异常,否则继续执行方法。 最后,我们需要在Spring Boot的主类上添加@EnableAspectJAutoProxy注解,开启切面的自动代理功能。 至此,我们已经完成了Spring Boot接口防刷的切面和注解实现。接下来,只需要在需要进行防刷接口方法上添加@AntiSpam注解,并在需要处理切面的类上添加@Component注解即可。 ### 回答3: 在Spring Boot中实现接口防刷功能,可以通过切面和注解的方式来实现。 首先,我们需要定义一个自定义注解,用于标识需要进行接口防刷限制的方法。可以命名为@RateLimit。 ```java @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) public @interface RateLimit { int value(); // 设置接口频率限制值,比如每秒允许访问的次数 int timeout() default 1; // 设置超时时间,默认1秒 } ``` 接下来,我们可以定义一个切面类,用于处理接口防刷逻辑。可以命名为RateLimitAspect。 ```java @Aspect @Component public class RateLimitAspect { private Map<String, Long> requestCounts = new ConcurrentHashMap<>(); // 记录请求次数的Map @Around("@annotation(rateLimit)") public Object around(ProceedingJoinPoint joinPoint, RateLimit rateLimit) throws Throwable { String methodName = joinPoint.getSignature().toLongString(); int limit = rateLimit.value(); int timeout = rateLimit.timeout(); long currentTime = System.currentTimeMillis(); if (!requestCounts.containsKey(methodName)) { requestCounts.put(methodName, currentTime); return joinPoint.proceed(); } long lastTime = requestCounts.get(methodName); long interval = currentTime - lastTime; if (interval < timeout * 1000) { if (requestCounts.get(methodName + "_count") == null) { requestCounts.put(methodName + "_count", 1L); } else { long count = requestCounts.get(methodName + "_count"); if (count >= limit) { throw new RuntimeException("接口调用频率过高,请稍后再试!"); } requestCounts.put(methodName + "_count", count + 1); } } else { requestCounts.remove(methodName); requestCounts.remove(methodName + "_count"); } requestCounts.put(methodName, currentTime); return joinPoint.proceed(); } } ``` 在切面类中,我们使用了一个Map来记录接口每次请求的时间和次数。如果接口调用频率超过限制,则阻止请求继续执行,并抛出异常。 使用@Around注解和@RateLimit注解来标识切面和需要进行限制的方法。通过@Around注解,我们可以在接口方法的执行前后进行处理,从而实现防刷逻辑。 最后,我们需要在Spring Boot的启动类上添加@EnableAspectJAutoProxy注解,开启切面自动代理功能。 ```java @SpringBootApplication @EnableAspectJAutoProxy public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } } ``` 这样,就可以在需要进行接口防刷限制的方法上添加@RateLimit注解,并在超过限制的情况下阻止请求继续执行。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值