构建Zuul自定义过滤器，限制ip频繁请求
自定义zuul过滤器其实很简单
1. 首先pom文件得先引入zuul依赖
|
1
2
3
4
|
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-zuul</artifactId>
</dependency>
|
2. 创建一个类，继承自ZuulFilter
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
|
import com.netflix.zuul.ZuulFilter;
import com.netflix.zuul.exception.ZuulException;
import org.springframework.stereotype.Component;
/**
* 构建zuul自定义过滤器
*/
@Component
public class MyFilter extends ZuulFilter {
/**
* 定义过滤器的类型
* pre:在请求被路由之前执行
* route:在路由请求的时候执行
* post:请求路由以后执行
* error:处理请求时发生错误的时候执行
*
* @return 过滤器的类型
*/
@Override
public String filterType() {
return "pre";
}
/**
* 过滤器执行的顺序，配置多个有顺序的过滤
* 执行顺序从小到大
*
* @return 执行顺序
*/
@Override
public int filterOrder() {
return 1;
}
/**
* 是否开启过滤器
* true:开启
* false:禁用
*
* @return 是否开启过滤器
*/
@Override
public boolean shouldFilter() {
return true;
}
/**
* 过滤器的业务实现
*
* @return null 没有意义
* @throws ZuulException 异常信息
*/
@Override
public Object run() throws ZuulException {
System.out.println("per zuul filter...");
return null;
}
}
|
自定义类上需要加上 @Component 注解
a. filterType()方法，定义过滤器的类型，返回的就是字符串，有以下4种类型
- pre：在请求被路由之前执行
- route：在路由请求的时候执行
- post：请求路由以后执行
- error：处理请求时发生错误的时候执行
b. filterOrder()方法，过滤器执行的顺序
c. shouldFilter()方法，是否开启过滤器，true开启，false不开启
d. run()方法，过滤器的业务实现，在这里写实现逻辑的具体代码
3. 限制ip频繁请求，示例代码
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
|
import com.imooc.grace.result.GraceJsonResult;
import com.imooc.grace.result.ResponseStatusEnum;
import com.imooc.utils.IPUtil;
import com.imooc.utils.JsonUtils;
import com.imooc.utils.RedisOperator;
import com.netflix.zuul.ZuulFilter;
import com.netflix.zuul.context.RequestContext;
import com.netflix.zuul.exception.ZuulException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Component;
import javax.servlet.http.HttpServletRequest;
/**
* 限制ip频繁请求
*/
@Component
public class BlackIpFilter extends ZuulFilter {
/**
* ip连续请求的次数
*/
private static final int CONTINUE_COUNTS = 10;
/**
* ip判断的时间间隔，单位秒
*/
private static final int TIME_INTERVAL = 10;
/**
* 限制的时间，单位秒
*/
private static final int LIMIT_TIMES = 15;
@Autowired
private RedisOperator redisOperator;
@Override
public String filterType() {
return "pre";
}
@Override
public int filterOrder() {
// 这里设置为2，上面那个过滤器设置为1，则执行顺序为 1->2，大家可以测试一下
return 2;
}
@Override
public boolean shouldFilter() {
return true;
}
@Override
public Object run() throws ZuulException {
// 获取上下文对象
RequestContext currentContext = RequestContext.getCurrentContext();
HttpServletRequest request = currentContext.getRequest();
// 获取ip
String requestIp = IPUtil.getRequestIp(request);
// 判断该ip在10秒内请求次数是否超过10次，超过则限制该ip15秒内不能访问，15秒后再放行
final String ipRedisKey = "zuul-ip:" + requestIp;
final String ipRedisLimitKey = "zuul-ip-limit:" + requestIp;
// 获取当前ip这个key的剩余时间
long limitLeftTime = redisOperator.ttl(ipRedisLimitKey);
// 判断该ip是否还有剩余时间
if (limitLeftTime > 0) {
stopRequest(currentContext);
return null;
}
// 在redis中累加ip的请求次数
long requestCounts = redisOperator.increment(ipRedisKey, 1);
if (requestCounts == 1) {
redisOperator.expire(ipRedisKey, TIME_INTERVAL);
}
if (requestCounts > CONTINUE_COUNTS) {
// 限制ip访问
redisOperator.set(ipRedisLimitKey, ipRedisLimitKey, LIMIT_TIMES);
stopRequest(currentContext);
}
return null;
}
private void stopRequest(RequestContext context) {
// 停止zuul继续向下路由，禁止请求通信
context.setSendZuulResponse(false);
// 返回响应码200
context.setResponseStatusCode(200);
// TODO 要返回提示的json内容（可以自定义任何响应内容）
// 例如 {"status":544,"msg":"请求过于频繁，请稍后再试","success":false,"data":null}
String result = "json内容";
// 设置返回内容
context.setResponseBody(result);
// 设置编码
context.getResponse().setCharacterEncoding("utf-8");
// 设置返回内容格式为json
context.getResponse().setContentType(MediaType.APPLICATION_JSON_VALUE);
}
}
|
这里使用了redis来记录ip请求次数和控制时间间隔
获取ip工具类 IPUtil
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
|
import javax.servlet.http.HttpServletRequest;
/**
* 获取ip工具类
*/
public class IPUtil {
/**
* 获取请求IP:
* 用户的真实IP不能使用request.getRemoteAddr()
* 这是因为可能会使用一些代理软件，这样ip获取就不准确了
* 此外我们如果使用了多级（LVS/Nginx）反向代理的话，ip需要从X-Forwarded-For中获得第一个非unknown的IP才是用户的有效ip。
*/
public static String getRequestIp(HttpServletRequest request) {
String ip = request.getHeader("x-forwarded-for");
if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
ip = request.getHeader("Proxy-Client-IP");
}
if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
ip = request.getHeader("WL-Proxy-Client-IP");
}
if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
ip = request.getHeader("HTTP_CLIENT_IP");
}
if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
ip = request.getHeader("HTTP_X_FORWARDED_FOR");
}
if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
ip = request.getRemoteAddr();
}
return ip;
}
}
|
到此这篇关于Spring Cloud Zuul自定义过滤器的实现的文章就介绍到这了,更多相关Spring Cloud Zuul过滤器内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！
原文链接：https://juejin.cn/post/6940124043441864712