关于网关的作用，这里就不再次赘述了，我们今天的重点是zuul的Filter。通过Filter，我们可以实现安全控制，比如，只有请求参数中有用户名和密码的客户端才能访问服务端的资源。那么如何来实现Filter了？
要想实现Filter，需要以下几个步骤：
1、继承ZuulFilter类，为了验证Filter的特性，我们这里创建3个Filter
根据用户名来过滤
1. package com.chhliu.springcloud.zuul;
2.
3. import javax.servlet.http.HttpServletRequest;
4.
5. import com.netflix.zuul.ZuulFilter;
6. import com.netflix.zuul.context.RequestContext;
7.
8. public class AccessUserNameFilter extends ZuulFilter {
9. @Override
10. public Object run() {
11. RequestContext ctx = RequestContext.getCurrentContext();
12. HttpServletRequest request = ctx.getRequest();
13.
14. "%s AccessUserNameFilter request to %s", request.getMethod(), request.getRequestURL().toString()));
15.
16. "username");// 获取请求的参数
17. if(null != username && username.equals("chhliu")) {// 如果请求的参数不为空，且值为chhliu时，则通过
18. true);// 对该请求进行路由
19. 200);
20. "isSuccess", true);// 设值，让下一个Filter看到上一个Filter的状态
21. return null;
22. else{
23. false);// 过滤该请求，不对其进行路由
24. 401);// 返回错误码
25. "{\"result\":\"username is not correct!\"}");// 返回错误内容
26. "isSuccess", false);
27. return null;
28. }
29. }
30.
31. @Override
32. public boolean shouldFilter() {
33. return true;// 是否执行该过滤器，此处为true，说明需要过滤
34. }
35.
36. @Override
37. public int filterOrder() {
38. return 0;// 优先级为0，数字越大，优先级越低
39. }
40.
41. @Override
42. public String filterType() {
43. return "pre";// 前置过滤器
44. }
45. }
通过继承ZuulFilter然后覆写上面的4个方法，就可以实现一个简单的过滤器，下面就相关注意点进行说明
filterType：返回一个字符串代表过滤器的类型，在zuul中定义了四种不同生命周期的过滤器类型，具体如下：
-
pre：可以在请求被路由之前调用 -
route：在路由请求时候被调用 -
post：在route和error过滤器之后被调用 -
error：处理请求时发生错误时被调用
Zuul的主要请求生命周期包括“pre”，“route”和“post”等阶段。对于每个请求，都会运行具有这些类型的所有过滤器。
filterOrder：通过int值来定义过滤器的执行顺序
shouldFilter：返回一个boolean类型来判断该过滤器是否要执行，所以通过此函数可实现过滤器的开关。在上例中，我们直接返回true，所以该过滤器总是生效
run：过滤器的具体逻辑。需要注意，这里我们通过ctx.setSendZuulResponse(false)令zuul过滤该请求，不对其进行路由，然后通过ctx.setResponseStatusCode(401)设置了其返回的错误码
过滤器间的协调
过滤器没有直接的方式来访问对方。 它们可以使用RequestContext共享状态，这是一个类似Map的结构，具有一些显式访问器方法用于被认为是Zuul的原语，内部是使用ThreadLocal实现的，有兴趣的同学可以看下源码。
再建一个过滤器，根据密码来过滤：
1. package com.chhliu.springcloud.zuul;
2.
3. import javax.servlet.http.HttpServletRequest;
4.
5. import com.netflix.zuul.ZuulFilter;
6. import com.netflix.zuul.context.RequestContext;
7.
8. public class AccessPasswordFilter extends ZuulFilter {
9.
10. @Override
11. public Object run() {
12. RequestContext ctx = RequestContext.getCurrentContext();
13. HttpServletRequest request = ctx.getRequest();
14.
15. "%s AccessPasswordFilter request to %s", request.getMethod(), request.getRequestURL().toString()));
16.
17. "password");
18. if(null != username && username.equals("123456")) {
19. true);
20. 200);
21. "isSuccess", true);
22. return null;
23. else{
24. false);
25. 401);
26. "{\"result\":\"password is not correct!\"}");
27. "isSuccess", false);
28. return null;
29. }
30. }
31.
32. @Override
33. public boolean shouldFilter() {
34. RequestContext ctx = RequestContext.getCurrentContext();
35. return (boolean) ctx.get("isSuccess");// 如果前一个过滤器的结果为true，则说明上一个过滤器成功了，需要进入当前的过滤，如果前一个过滤器的结果为false，则说明上一个过滤器没有成功，则无需进行下面的过滤动作了，直接跳过后面的所有过滤器并返回结果
36. }
37.
38. @Override
39. public int filterOrder() {
40. return 1; // 优先级设置为1
41. }
42.
43. @Override
44. public String filterType() {
45. return "pre";
46. }
47. }
最后建一个post过滤器
1. package com.chhliu.springcloud.zuul;
2.
3. import javax.servlet.http.HttpServletRequest;
4.
5. import com.netflix.zuul.ZuulFilter;
6. import com.netflix.zuul.context.RequestContext;
7.
8. public class AccessTokenFilter extends ZuulFilter {
9. @Override
10. public Object run() {
11. RequestContext ctx = RequestContext.getCurrentContext();
12. HttpServletRequest request = ctx.getRequest();
13.
14. "%s AccessTokenFilter request to %s", request.getMethod(),
15. request.getRequestURL().toString()));
16.
17. true);
18. 200);
19. "{\"name\":\"chhliu\"}");// 输出最终结果
20. return null;
21. }
22.
23. @Override
24. public boolean shouldFilter() {
25. return true;
26. }
27.
28. @Override
29. public int filterOrder() {
30. return 0;
31. }
32.
33. @Override
34. public String filterType() {
35. return "post";// 在请求被处理之后，会进入该过滤器
36. }
37. }
2、在主类中，先开启前面的两个过滤器
1. @Bean
2. public AccessUserNameFilter accessUserNameFilter() {
3. return new AccessUserNameFilter();
4. }
5.
6. @Bean
7. public AccessPasswordFilter accessPasswordFilter(){
8. return new AccessPasswordFilter();
9. }
3、输入请求，验证
(1)请求为：http://localhost:8768/h2service/user/1?username=chhliu
测试结果为：
{"result":"password is not correct!"}
控制台打印结果
1. GET AccessUserNameFilter request to http://localhost:8768/h2service/user/1
2. GET AccessPasswordFilter request to http://localhost:8768/h2service/user/1
通过了AccessUserNameFilter过滤器，在验证AccessPasswordFilter过滤器的时候失败了
后台无sql打印，说明请求没有被路由
(2)请求为：http://localhost:8768/h2service/user/1?password=123456
测试结果为：
{"result":"username is not correct!"}
控制台打印结果：
1. GET AccessUserNameFilter request to http://localhost:8768/h2service/user/1
说明到了AccessUserNameFilter过滤器，但是没有到AccessPasswordFilter过滤器，因为AccessUserNameFilter过滤器的优先级高一些，会先执行，在执行的时候，发现过滤条件不符合，于是跳过了后面所有的过滤器，并返回结果
后台无sql打印，说明请求没有被路由
(3)请求为：http://localhost:8768/h2service/user/1?password=123456&username=chhliu
测试结果为：
1. {
2.
3. "id": 1,
4. "username": "user1",
5. "name": "张三",
6. "age": 20,
7. "balance": 100.00
8.
9. }
控制台打印的结果：
1. GET AccessUserNameFilter request to http://localhost:8768/h2service/user/1
2. GET AccessPasswordFilter request to http://localhost:8768/h2service/user/1
说明是先执行了AccessUserNameFilter然后才执行AccessPasswordFilter这也和我们前面说的order的值越小，优先级越高是吻合的。
同时被请求的服务有sql输出：
1. Hibernate: select user0_.id as id1_0_0_, user0_.age as age2_0_0_, user0_.balance as balance3_0_0_, user0_.name as name4_0_0_, user0_.username as username5_0_0_ from user user0_ where user0_.id=?
说明请求被路由了。
4、开启post过滤器，再跑一次
测试结果：发现post过滤器是最后执行的，尽管它的优先级为0
关于zuul的Filter的生命周期，见下图
注：上图有个小错误，routing应该是route
5、拓展
zuul还提供了一类特殊的过滤器，分别为：StaticResponseFilter和SurgicalDebugFilter
StaticResponseFilter允许从Zuul本身生成响应，而不是将请求转发到源。
SurgicalDebugFilter允许将特定请求路由到分隔的调试集群或主机
