正文

限流实现与解决方案(代码片段)

cuiqq  cuiqq  2023-04-20  306

关键词：

https://blog.csdn.net/qq_32447301/article/details/86659474

一、限流操作：

为什么限流，是防止用户恶意刷新接口，因为部署在外部服务器，并且我们采用websocket的接口实现的，公司没有对硬件升级，导致程序时长崩溃，为了解决这个问题，请教公司的大佬，提出一个方案，限流操作。但是最后找到原因所在，解决了，吞吐量1万6左右，用的测试服务器，进行测试的，我开发的笔记本进行压测，工具是Jmeter，结果我的电脑未响应，卡了，服务器还没有挂。
限流那些方法
常见的限流：
1、Netflix的hystrix
2、阿里系开源的sentinel
3、说白了限流，为了处理高并发接口那些方式：队列，线程，线程池，消息队列、 kafka、中间件、sentinel：直接拒绝、Warm Up、匀速排队等
技术层面：
1、判断是否有相同的请求，可以通过自身缓存挡住相同请求
2、用负载均衡，比如nginx
3、用缓存数据库，把热点数据get到缓存中，redis，ES
4、善于使用连接池
业务层面：
1、加入交互，排队等待
二、应用级别限流与限流实现：
方法一、使用google的guava，令牌桶算法实现：平滑突发限流 ( SmoothBursty) 、平滑预热限流 ( SmoothWarmingUp) 实现

<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>23.0</version>
</dependency>

package com.citydo.dialogue.controller;

import com.google.common.util.concurrent.RateLimiter;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import java.util.Collections;

@RestController
public class HomeController

// 这里的1表示每秒允许处理的量为10个
private RateLimiter limiter = RateLimiter.create(10.0);
//RateLimiter.create(doublepermitsPerSecond, long warmupPeriod, TimeUnit unit);
//RateLimiter limiter = RateLimiter.create(5, 1000, TimeUnit.MILLISECONDS);
//permitsPerSecond: 表示每秒新增的令牌数
// warmupPeriod: 表示在从冷启动速率过渡到平均速率的时间间隔

@GetMapping("/test/name")
public String Test(@PathVariable("name") String name)
// 请求RateLimiter, 超过permits会被阻塞
final double acquire = limiter.acquire();
System.out.println("--------"+acquire);
//判断double是否为空或者为0
if(acquire>=(-1e-6)&&acquire<=(1e-6))
return name;
else
return "操作太频繁";

这个有点类似与QPS流量控制：
当 QPS 超过某个阈值的时候，则采取措施进行流量控制。
直接拒绝：
方式是默认的流量控制方式，当QPS超过任意规则的阈值后，新的请求就会被立即拒绝，拒绝方式为抛出Exception或者返回值404。这种方式适用于对系统处理能力确切已知的情况下，比如通过压测确定了系统的准确水位时。

方法二、请求一次redis增加1，key可以是IP+时间或者一个标识+时间，没有就创建，需要设置过期时间
设置拦截器：

package com.citydo.dialogue.config;

import com.citydo.dialogue.service.AccessLimitInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;

/**
* 拦截器配置
* @author nick
*/

@Configuration
public class InterceptorConfig extends WebMvcConfigurationSupport 

@Override
public void addInterceptors(InterceptorRegistry registry) 
//addPathPatterns 添加拦截规则
registry.addInterceptor(new AccessLimitInterceptor())
//添加需要拦截请求的路径
.addPathPatterns("/**");
//swagger2 放行 .excludePathPatterns("/swagger-resources/**", "/webjars/**", "/v2/**", "/swagger-ui.html/**");
//.excludePathPatterns("/*")
//去除拦截请求的路径


@Override
public void addViewControllers(ViewControllerRegistry registry) 
registry.addViewController("/");

拦截方法

package com.citydo.dialogue.service;

import com.citydo.dialogue.entity.AccessLimit;
import com.citydo.dialogue.utils.IpUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.lang.reflect.Method;
import java.util.concurrent.TimeUnit;

public class AccessLimitInterceptor implements HandlerInterceptor 

//使用RedisTemplate操作redis

@Autowired
private RedisTemplate<String, Integer> redisTemplate;

@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception 
if (handler instanceof HandlerMethod) 
HandlerMethod handlerMethod = (HandlerMethod) handler;
Method method = handlerMethod.getMethod();
if (!method.isAnnotationPresent(AccessLimit.class)) 
return true;

AccessLimit accessLimit = method.getAnnotation(AccessLimit.class);
if (accessLimit == null) 
return true;

int limit = accessLimit.limit();
int sec = accessLimit.sec();
String key = IpUtil.getIpAddr(request) + request.getRequestURI();
//资源唯一标识
String formatDate=new SimpleDateFormat("yyyyMMddHHmm").format(new Date());
//String key="request_"+formatDate;
Integer maxLimit = redisTemplate.opsForValue().get(key);
if (maxLimit == null) 
//set时一定要加过期时间
redisTemplate.opsForValue().set(key, 1, sec, TimeUnit.SECONDS);
 else if (maxLimit < limit) 
redisTemplate.opsForValue().set(key, maxLimit + 1, sec, TimeUnit.SECONDS);
 else 
output(response, "请求太频繁!");
return false;


return true;


public void output(HttpServletResponse response, String msg) throws IOException 
response.setContentType("application/json;charset=UTF-8");
ServletOutputStream outputStream = null;
try 
outputStream = response.getOutputStream();
outputStream.write(msg.getBytes("UTF-8"));
 catch (IOException e) 
e.printStackTrace();
 finally 
outputStream.flush();
outputStream.close();



@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception 



@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception

可以设置成注解，当然也可以直接添加参数

package com.citydo.dialogue.entity;

import java.lang.annotation.*;

@Inherited
@Documented
@Target(ElementType.FIELD,ElementType.TYPE,ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface AccessLimit 
//标识 指定sec时间段内的访问次数限制
int limit() default 5;
//标识 时间段
int sec() default 5;

redis编写配置

package com.citydo.dialogue.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
* 解决redis乱码问题
* 解决配置问题
* @author nick
*/
@Configuration
public class RedisConfig 
/**
* 此方法解决存储乱码
*/
@Bean
public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) 
RedisTemplate<Object, Object> template = new RedisTemplate<Object, Object>();
template.setConnectionFactory(redisConnectionFactory);
template.setKeySerializer(new StringRedisSerializer());
template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
template.setHashKeySerializer(new GenericJackson2JsonRedisSerializer());
template.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
template.afterPropertiesSet();
return template;

方法三、分布式限流，分布式限流最关键的是要将限流服务做成原子化，而解决方案可以使用redis+lua或者nginx+lua技术进行实现。

方法四、可以使用池化技术来限制总资源数：连接池、线程池。比如分配给每个应用的数据库连接是 100，那么本应用最多可以使用 100 个资源，超出了可以等待或者抛异常。

方法五、限流总并发/连接/请求数，如果你使用过 Tomcat，其 Connector 其中一种配置有如下几个参数:

maxThreads:
Tomcat 能启动用来处理请求的最大线程数，如果请求处理量一直远远大于最大线程数，可能会僵死。
maxConnections:
瞬时最大连接数，超出的会排队等待。
acceptCount:
如果 Tomcat 的线程都忙于响应，新来的连接会进入队列排队，如果超出排队大小，则拒绝连接。

方法六、限流某个接口的总并发/请求数，使用 Java 中的 AtomicLong，示意代码：

try
if(atomic.incrementAndGet() > 限流数) 
//拒绝请求
 else 
//处理请求

 finally 
atomic.decrementAndGet();

方法七、限流某个接口的时间窗请求数使用 Guava 的 Cache，示意代码：

LoadingCache counter = CacheBuilder.newBuilder()
.expireAfterWrite(2, TimeUnit.SECONDS)
.build(newCacheLoader()
@Override
public AtomicLong load(Long seconds) throws Exception
return newAtomicLong(0);

);
longlimit =1000;
while(true)
// 得到当前秒
long currentSeconds = System.currentTimeMillis() /1000;
if(counter.get(currentSeconds).incrementAndGet() > limit)
System.out.println("限流了: " + currentSeconds);
continue;

// 业务处理
不管哪种目的是为了，进行限流操作。
参考：https://blog.csdn.net/fanrenxiang/article/details/80683378
参考：https://mp.weixin.qq.com/s/2_oDGJiI1GhaNYnaeL7Qpg
源码：https://github.com/863473007/springboot_current_limiting

常用限流方案的设计与实现(代码片段)

...高峰期的可用性，主流系统都会配备服务降级的工具，而限流就是目前系统最常采用的方案之一。限流即流量限制，目的是在遇到流量高峰或者流量突增（流量尖刺）时，把流量速率控制在合理的范围之内，不至于被高流量击垮... 查看详情

两个简单的api限流实现方案(代码片段)

1，Ngnix限流Nginx在架构中起到请求转发与负载均衡器的作用。外部req首先到Nginx监听的80端口，然后Nginx将req交给到监听8080端口的APP服务器处理。处理结果再经由Nginx返回给调用方。Nginx限流的配置：(/usr/local/etc/nginx/nginx.conf)1#userno... 查看详情

常见的限流算法与实现(代码片段)

限流的实现常见的限流算法：限流是对某一时间窗口内的请求数进行限制，保持系统的可用性和稳定性，防止因流量暴增而导致的系统运行缓慢或宕机。常见的限流算法有三种：计数器限流(固定窗口)原理：时... 查看详情

springcloudalibabasentinel实现熔断与限流(代码片段)

SpringCloudAlibabaSentinel实现熔断与限流一、Sentinel介绍与安装二、微服务项目整合Sentinel三、流控规则3.1阈值类型：QPS3.2阈值类型：线程数3.3流控模式：直接3.4流控模式：关联3.5流控模式：链路3.6流控效果：快... 查看详情

springboot限流实现(代码片段)

...0c;甚至引发连锁反映导致整个系统崩溃。这个时候常见的解决方案之一就是限流了，当请求达到一定的并发数或速率，就进行等待、排队、降级、拒绝服务等限流算法介绍a、令牌桶算法令牌桶算法的原理是系统会以一个... 查看详情

优雅解决分布式限流(代码片段)

...我们了解到 AtomicInteger、RateLimiter、Semaphore 这几种解决方案，但它们也仅仅是单机的解决手段，在集群环境下就透心凉了，后面又讲述了 Nginx 的限流手段，可它又属于网关层面的策略之一，并不能解决所有问题。... 查看详情

redis之zset实现滑动窗口限流(代码片段)

...#xff01; 目录1、需求2、常见的错误设计3、滑动窗口算法3.1解决方案3.2pipeline代码实现3.3lua代码实现1、需求限定用户的某个行为在指定时间T内，只允许发生N次。假设T为1秒钟，N为1000次。2、常见的错误设计查看详情

分布式系统中的限流与熔断(代码片段)

...11、618等高性能压力的场景时，限流已经成为了标配技术解决方案，为保证系统的平稳运行起到了关键性的作用。不管应用场景是哪种，限流无非就是针对超过预期的流量，通过预先设定的限流规则选择性的对某些请求进行限流&... 查看详情

漏斗限流详述(代码片段)

...技能！目录1、需求2、常见的错误设计3、漏斗限流3.1解决方案3.2Java代码实现3.3结合Redis实现4、总结1、需求限定用户的某个行为在指定时间T内，只允许发生N次。假设T为1秒钟，N为1000次。2、常见的错误设计程查看详情

详解redisson分布式限流的实现原理(代码片段)

...并发的时候，还是有可能压垮下游。所以目前唯一可行的解决方案就是分布式限流。我目前是选择直接使用Redisson库中的RRateLimiter实现了分布式限流，关于Redission可能很多人都有所耳闻，它其实是在Redis能力上构建的开发库... 查看详情

人人都能看懂的6种限流实现方案(代码片段)

　　为了上班方便，去年我把自己在北郊的房子租出去了，搬到了南郊，这样离我上班的地方就近了，它为我节约了很多的时间成本，我可以用它来做很多有意义的事，最起码不会因为堵车而闹心了，幸福感直线上升。　　但即... 查看详情

一个轻量级的基于ratelimiter的分布式限流实现(代码片段)

上篇文章（限流算法与GuavaRateLimiter解析）对常用的限流算法及GoogleGuava基于令牌桶算法的实现RateLimiter进行了介绍。RateLimiter通过线程锁控制同步，只适用于单机应用，在分布式环境下，虽然有像阿里Sentinel的限流开源框架，但对... 查看详情

两种白名单限流方案（redislua限流，guava方案）(代码片段)

两种白名单限流方案1、redislua方案创建注解类@Target(ElementType.METHOD)@Retention(RetentionPolicy.RUNTIME)public@interfaceLimit//资源名称，用于描述接口功能Stringname()default"";//资源keyStringkey()default&# 查看详情

详解redisson分布式限流的实现原理(代码片段)

...的时候，还是有可能压垮下游。所以目前唯一可行的解决方案就是分布式限流。我目前是选择直接使用Redisson库中的RRateLimiter实现了分布式限流，关于Redission可能很多人都有所耳闻，它其实是在Redis能力上构建的开发... 查看详情

接口限流算法(代码片段)

限流限流顾名思义，提前对各个类型的请求设置最高的QPS阈值，若高于设置的阈值则对该请求直接返回，不再调用后续资源。限流需要结合压测等，了解系统的最高水位，也是在实际开发中应用最多的一种稳定性保障手段。... 查看详情

redis实现限流策略(代码片段)

...4;reply",60,5)ifcan_reply:do_reply()else:raiseActionThresholdOverflow()解决方案这个限流需求中存在一个滑动时间窗口，想想zset数据结构的score值，是不是可以通过score来圈出这个时间窗口来。Redissortedsets|Redis而且我们只需要保留这个... 查看详情

使用sentinel实现热点参数限流(代码片段)

...数，针对一段时间内频繁访问的用户ID进行限制热点参数限流会统计传入参数中的热点参数，并根据配置的限流阈值与模式，对包含热点参数的资源调用进行限流。热点参数限流可以看做是一种特殊的流量控制，仅对包含热点参... 查看详情