一、开闭操作形式：
为何开闭
是避免使用者蓄意创下USB，即使布署在内部伺服器，因此我们选用websocket的USB同时实现的，子公司没对硬体升级换代，引致流程时数崩盘，为的是化解这个难题，求教子公司的元老，明确提出一个计划，开闭操作形式。
但最终找出其原因所处，化解了，客运量1万6左右，用的试验伺服器，进行试验的，我合作开发的笔记本笔记本电脑进行银穗草，辅助工具是Jmeter，结论我的笔记本电脑未积极响应，卡了，伺服器还没挂。
开闭这些形式
常用的开闭：
Netflix的hystrix穆萨系开放源码的sentinel说到底开闭，为的是处置高mammalianUSB这些形式：堆栈，缓存，缓存池，最新消息堆栈、 kafka、合作开发辅助工具、sentinel：间接婉拒、Warm Up、慢速排队等候等控制技术微观：
推论与否有完全相同的允诺，可以透过另一方面内存压住完全相同允诺用阻抗平衡，比如说nginx用内存资料库，把领涨板块统计数据get到内存中，redis，ES擅于选用连接池销售业务微观：
重新加入可视化，排队等候等候二、应用领域等级开闭与开闭同时实现：
形式一、选用google的guava，副本桶演算法同时实现：光滑突发性开闭 ( SmoothBursty) 、光滑紧接著开闭 ( SmoothWarmingUp) 同时实现
<!–Java工程项目广为倚赖 的核心理念库–>
<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 个资源，超出了可以 等候 或者 抛异常。
形式五、开闭总mammalian/连接/允诺数，如果你选用过 Tomcat，其 Connector 其中一种配置有如下几个参数:
maxThreads: Tomcat 能启动用来处置允诺的 最大缓存数，如果允诺处置量一直远远大于最大缓存数，可能会僵死。maxConnections: 瞬时最大连接数，超出的会 排队等候等候。acceptCount: 如果 Tomcat 的缓存都忙于积极响应，新来的连接会进入 堆栈排队等候，如果 超出排队等候大小，则 拒绝连接。形式六、开闭某个USB的总mammalian/允诺数，选用 Java 中的 AtomicLong，示意代码：
try{
if(atomic.incrementAndGet() > 开闭数) {
//婉拒允诺
} else {
//处置允诺 }
} finally {
atomic.decrementAndGet();
}
形式七、 开闭某个USB的时间窗允诺数选用 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_limitinghttps://www.cxyxiaowu.com/21467.html 作者：灬点点关注我 @Java编程宇宙，学习更多 Java 知识
