后台限制请求访问次数的实现

最新推荐文章于 2024-04-07 22:58:28 发布

禛陌

最新推荐文章于 2024-04-07 22:58:28 发布

阅读量1.7k

点赞数 2

分类专栏：技术相关笔记文章标签： java spring eclipse maven intellij-idea

本文链接：https://blog.csdn.net/xuxiannian/article/details/120888776

版权

技术相关同时被 2 个专栏收录

44 篇文章 0 订阅

订阅专栏

笔记

10 篇文章 0 订阅

订阅专栏

背景

最近搞接口服务器，对兄弟团队提供数据接口，由于对接生产数据，担心小伙伴把我的数据库玩死，于是想着搞个请求限制吧，规定时间限制你的访问次数~~

大致设计了下思路就是，同一客户端请求同一资源时在规定时间给你的请求次数做限制，即标识你同一客户端且是同一资源的请求时，就给你个请求次数，当在规定时间里请求次数超过了我的阈值，我就给提示：“等回再来拿数据，你来的次数有点多~~~~”，次数清除的机制就是指定的时间过了；怎么用呢？？在每个请求接口上加个注解就能用，这样扩展好，也简单复用

嗯，大致就是这个思路了，看来map是跑不了了，然后有一个点就是过期时间限制，自己写！@！#￥%……&*）,想了一下放弃吧，搜搜总有类似的需求，不要浪费时间自己造车了，对，我就是懒~~~

ExpiringMap

简简单单搜了一下，就是这货了，被封装好的高性能的线程安全的一个轻量级的map组件(A high performance, low-overhead, zero dependency, thread-safe ConcurrentMap implementation that expires entries)，敲黑板~~~

关键字：高性能、低开销、零依赖、线程安全

它包括的功能点：

Expiration policies ：过期策略基于实体的创建时间或是最后一次的访问时间制定

Map<String, Connection> map = ExpiringMap.builder()
  .expirationPolicy(ExpirationPolicy.ACCESSED)
  .build();
//CREATED是每次创建元素时过期时间清0；ACCESSED是指每次访问时清0
map.put("connection", connection, ExpirationPolicy.CREATED);

Variable expiration：多种：也可以针对map中的实体制定它的过期策略

ExpiringMap<String, Connection> map = ExpiringMap.builder()
  .variableExpiration()
  .build();
map.put("connection", connection, ExpirationPolicy.ACCESSED, 5, TimeUnit.MINUTES);
//像这样给Map中的connection设定过期时间和过期策略
map.setExpiration(connection, 5, TimeUnit.MINUTES);
map.setExpirationPolicy(connection, ExpirationPolicy.ACCESSED);

Maximum size: 可以指定大小，当map大小到达指定时，会自己扩展且过期策略会与第一个entry相同

Map<String, Connection> map = ExpiringMap.builder()
  .maxSize(123)
  .build();

Expiration listeners: 可以用事件的监听做为过期策略

//当entry过期时，监听会被通知
Map<String, Connection> map = ExpiringMap.builder()
  .expirationListener((key, connection) -> connection.close())
  .build();
//entries 过期时同步调用过期监听，map的写操作会被blocked，直到过期监听事件完成后；也可以配置成不阻塞map操作的过期监听
Map<String, Connection> map = ExpiringMap.builder()
  .asyncExpirationListener((key, connection) -> connection.close())
  .build();
//map在使用的时间也可以增加或移除过期监听
ExpirationListener<String, Connection> connectionCloser = (key, connection) -> connection.close();
map.addExpirationListener(connectionCloser);
map.removeExpirationListener(connectionCloser);

Lazy entry loading：当ExpiringMap.get被调用时，Entries可以通过EntryLoader进行懒加载

Map<String, Connection> connections = ExpiringMap.builder()
  .expiration(10, TimeUnit.MINUTES)
  .entryLoader(address -> new Connection(address))
  .build();
  
// Loads a new connection into the map via the EntryLoader
connections.get("jodah.net");

Expiration Introspection：过期时间监测（自省检查），可以查看到过期时间，也可以重置过期时间，也可以知道Map中的特定的entries的配置情况

有兴趣深究的可以去下载源码哈：

https://github.com/jhalterman/expiringmap#expiration-policies

限制请求次数应用示例

pom依赖

<dependency>
     <groupId>net.jodah</groupId>
     <artifactId>expiringmap</artifactId>
     <version>0.5.8</version>
</dependency>

注解类定义

上面在思路设计中也说了，想在每个被请求的接口上直接加一个注解类，就可以了，这样可做到简单复用。那我们开始码注解类吧

import java.lang.annotation.*;

/**
 * @Description: 接口注解用，30秒内同一接口只许调1次
 * @Param:
 * @return:
 * @Author: 张璐
 * @Date: 2021/10/21
 */
@Documented
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface LimitRequest {
    long time() default 1000 * 30;//限制时间，单位ms

    int count() default 1;
}

切面定义

注解类搞定了，利用AOP思想，每个请求来先到我的切面里校验下是不是超限了呢。现在还需要一个切面;自己先定义一个全局的map：book 里面装键是请求的资源信息；值是ExpiringMap,我们用的过期策略是生成新的对象是清0；它的键对象是请求的客户端的地址，值是请求的次数，然后进行判断就可以了。

package com.test.zhanglu.interfaceapi.component;

import com.chenergy.positioning.coalmine.positioning.interfaceapi.common.BusinessException;
import com.chenergy.positioning.coalmine.positioning.interfaceapi.common.Constants;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import net.jodah.expiringmap.ExpirationPolicy;
import net.jodah.expiringmap.ExpiringMap;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;

/**
 * @Description: 每个请求不能超过30s/次的切面控制器
 * @Param:
 * @return:
 * @Author: 张璐
 * @Date: 2021/10/21
 */
@Component
@Aspect
@Slf4j
public class LimitRequestAspct {
    private static ConcurrentHashMap<String, ExpiringMap<String, Integer>> book = new ConcurrentHashMap<>();

    @Pointcut("@annotation(limitRequest)")
    public void excute(LimitRequest limitRequest) {

    }

    @SneakyThrows
    @Around("excute(limitRequest)")
    public Object doAround(ProceedingJoinPoint pjp, LimitRequest limitRequest) {
        RequestAttributes ra = RequestContextHolder.getRequestAttributes();
        ServletRequestAttributes sra = (ServletRequestAttributes) ra;
        HttpServletRequest request = sra.getRequest();
        log.info("进入切页调试项，uri:{},remoteUrl:{}", request.getRequestURI(), request.getRemoteAddr());
        ExpiringMap<String, Integer> expiringMap = book.getOrDefault(request.getRequestURI(), ExpiringMap.builder().variableExpiration().build());
        Integer uCount = expiringMap.getOrDefault(request.getRemoteAddr(), 0);
        if (uCount >= limitRequest.count()) {
            throw new BusinessException(Constants.ResultBodyErrorEnum.SIGNATURE_NOT_MATCH.getCode(), Constants.ResultBodyErrorEnum.SIGNATURE_NOT_MATCH.getMessage());
        } else if (uCount == 0) {
            expiringMap.put(request.getRemoteAddr(), ++uCount, ExpirationPolicy.CREATED, limitRequest.time(), TimeUnit.MILLISECONDS);
        } else {
            expiringMap.put(request.getRemoteAddr(), ++uCount);
        }
        book.put(request.getRequestURI(), expiringMap);
        Object result = pjp.proceed();
        return result;
    }

}

Controler示例

方法体上加上我们写好的注解就行了

/**
 * @Description: 报警相关的接口请求类
 * @Param:
 * @return:
 * @Author: 张璐
 * @Date: 2021/10/21
 */
@RestController
@Slf4j
public class AlarmController {
    @Autowired
    IAlarmService alarmService;

    @LimitRequest
    @GetMapping(value = "/getTestCount")
    public ResultBody getAlarmCountByType(@RequestParam("token") String token, @RequestParam(value = "com", required = false) String com, @RequestParam(value = "code", required = false) String code, @RequestParam(value = "type", required = false) String tepe) {
        Map<String, Integer> map = alarmService.getAlarmCount(corpCode, mienCode, teyp);
        return ResultBody.success(map);
    }
}

示例展现情况

禛陌

关注

2
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
后台限制请求访问次数的实现

目录背景ExpiringMap限制请求次数应用示例pom依赖注解类定义切面定义Controler示例示例展现情况背景最近搞接口服务器，对兄弟团队提供数据接口，由于对接生产数据，担心小伙伴把我的数据库玩死，于是想着搞个请求限制吧，规定时间限制你的访问次数~~大致设计了下思路就是，同一客户端请求同一资源时在规定时间给你的请求次数做限制，即标识你同一客户端且是同一资源的请求时，就给你个请求次数，当在规定时间里请求次数超过了我的阈值，我就给提示：“等回再来拿数据，你来
复制链接

扫一扫