springcloud(第九篇)netflix zuul

WindySky 2017-07-17

展開全文

netflix zuul

introduction

zuul用來提供動態(tài)路由、監(jiān)控、授權(quán)、安全、調(diào)度等等的邊緣服務(wù)(edge service)

ZuulFilter

ZuulFilter是Zuul中核心組件，通過繼承該抽象類，覆寫幾個關(guān)鍵方法達到自定義調(diào)度請求的作用,這里filter不是Java web中的filter，不要混淆.

new ZuulFilter() {
                @Override
                public int filterOrder() {
                    return 0;
                }

                @Override
                public String filterType() {
                    return null;
                }

                @Override
                public boolean shouldFilter() {
                    return false;
                }

                @Override
                public Object run() {
                    return null;
                }
            }1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

filterOrder:filter執(zhí)行順序，通過數(shù)字指定
shouldFilter:filter是否需要執(zhí)行 true執(zhí)行 false 不執(zhí)行
run : filter具體邏輯
filterType :filter類型,分為以下幾種

pre:請求執(zhí)行之前filter
route: 處理請求，進行路由
post: 請求處理完成后執(zhí)行的filter
error:出現(xiàn)錯誤時執(zhí)行的filter

quick start

直接給出一個簡單demo，通過demo代碼再具體解析

package com.lkl.springcloud.zuul;

import com.netflix.zuul.ZuulFilter;
import com.netflix.zuul.context.ContextLifecycleFilter;
import com.netflix.zuul.context.RequestContext;
import com.netflix.zuul.filters.FilterRegistry;
import com.netflix.zuul.http.ZuulServlet;
import com.netflix.zuul.monitoring.MonitoringHelper;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.context.embedded.FilterRegistrationBean;
import org.springframework.boot.context.embedded.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

import java.io.IOException;

/**
 * Created by liaokailin on 16/5/24.
 */
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        new SpringApplicationBuilder(Application.class).web(true).run(args);
    }

    @Component
    public static class MyCommandLineRunner implements CommandLineRunner {
        @Override
        public void run(String... args) throws Exception {
            MonitoringHelper.initMocks();
            initJavaFilters();
        }

        private void initJavaFilters() {
            final FilterRegistry r = FilterRegistry.instance();

            r.put("javaPreFilter", new ZuulFilter() {
                @Override
                public int filterOrder() {
                    return 50000;
                }

                @Override
                public String filterType() {
                    return "pre";
                }

                @Override
                public boolean shouldFilter() {
                    return true;
                }

                @Override
                public Object run() {
                    System.out.println("running javaPreFilter");
                    RequestContext.getCurrentContext().set("name", "liaokailin");
                    return null;
                }
            });

            r.put("javaRoutingFilter", new ZuulFilter() {
                @Override
                public int filterOrder() {
                    return 50000;
                }

                @Override
                public String filterType() {
                    return "route";
                }

                @Override
                public boolean shouldFilter() {
                    return true;
                }

                @Override
                public Object run() {
                    System.out.println("running javaRoutingFilter");
                    try {
                        RequestContext.getCurrentContext().getResponse().sendRedirect("http://blog.csdn.net/liaokailin/");
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    return null;
                }
            });

            r.put("javaPostFilter", new ZuulFilter() {
                @Override
                public int filterOrder() {
                    return 50000;
                }

                @Override
                public String filterType() {
                    return "post";
                }

                @Override
                public boolean shouldFilter() {
                    return true;
                }

                @Override
                public Object run() {
                    System.out.println("running javaPostFilter");
                    System.out.println(RequestContext.getCurrentContext().get("name").toString());
                    return null;
                }

            });

        }

    }

    @Bean
    public ServletRegistrationBean zuulServlet() {
        ServletRegistrationBean servlet = new ServletRegistrationBean(new ZuulServlet());
        servlet.addUrlMappings("/test");
        return servlet;
    }

    @Bean
    public FilterRegistrationBean contextLifecycleFilter() {
        FilterRegistrationBean filter = new FilterRegistrationBean(new ContextLifecycleFilter());
        filter.addUrlPatterns("/*");
        return filter;
    }
}

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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

servlet注冊

通過ServletRegistrationBean構(gòu)造ZuulServlet，該Servlet用以進行filter執(zhí)行調(diào)度以及監(jiān)控等等操作
訪問 http://localhost:8080/test 進入該servlet

filter注冊

通過FilterRegistrationBean進行filter注冊，ContextLifecycleFilter的核心功能是為了清除RequestContext；
請求上下文通過ThreadLocal存儲，因此需要在請求完成后刪除該對象。

CommandLineRunner

CommandLineRunner接口很簡單，知道spring boot的知道其功能，在工程啟動后會執(zhí)行對應(yīng)run方法:

MonitoringHelper.initMocks(); 啟動監(jiān)控，這個再后續(xù)文章中具體再說
initJavaFilters()方法中注冊三種類型filter

RequestContext

RequestContext 在zuul有很重作用，在不同組件傳遞數(shù)據(jù)都是通過它來實現(xiàn)的

啟動工程后訪問 http://localhost:8080/test 可以看到后臺答應(yīng)消息，頁面也會定位到我的博客首頁。

zuul執(zhí)行流程

借用官網(wǎng)的一張圖片

Lifecycle

通過圖片可以清晰看出執(zhí)行過程，在微服務(wù)中后端各種引用，利用zuul進行合理調(diào)用還是很有必要的，例如負載、限流、監(jiān)控、安全等等功能。

zuul with groovy

為了動態(tài)修改filter，zuul利用groovy,它是基于jvm的語言，語法簡單而且和Java很類似，可以簡單的理解為在java語法上進行拓展，但groovy是可以動態(tài)加載的，應(yīng)用發(fā)布到線上后可以在不重啟情況下對業(yè)務(wù)邏輯進行修改。

為了簡單起見，下面創(chuàng)建一個groovy filter

import com.netflix.zuul.ZuulFilter
import com.netflix.zuul.context.RequestContext

import javax.servlet.http.HttpServletRequest

class PreRequest extends ZuulFilter{

    @Override
    String filterType() {
        return "pre"
    }

    @Override
    int filterOrder() {
        return 1000
    }

    @Override
    boolean shouldFilter() {
        return true
    }

    @Override
    Object run() {
        HttpServletRequest req = RequestContext.currentContext.request as HttpServletRequest
        Iterator headerIt = req.getHeaderNames().iterator()
        while (headerIt.hasNext()) {
            String name = (String) headerIt.next()
            String value = req.getHeader(name)
            println("header: " + name + ":" + value)
        }
        return null
    }
}
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
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

創(chuàng)建一個pre類型的filter，在run方法中獲取HttpServletRequest 然后答應(yīng)header信息

在代碼中加入groovy編譯器，間隔10秒掃描一次groovy文件，其代碼如下：

 <dependency>
            <groupId>org.codehaus.groovy</groupId>
            <artifactId>groovy-all</artifactId>
            <version>2.4.4</version>
        </dependency>1
2
3
4
5
1
2
3
4
5

 FilterLoader.getInstance().setCompiler(new GroovyCompiler());
            try {
                FilterFileManager.setFilenameFilter(new GroovyFileFilter());
                FilterFileManager.init(10,"/Users/liaokailin/code/ieda/springcloud/myzuul/src/main/java/com/lkl/springcloud/zuul/filters/groovy/pre");
            } catch (Exception e) {
                throw new RuntimeException(e);
            }1
2
3
4
5
6
7
1
2
3
4
5
6
7

這里groovy文件通過絕對路徑指定，如果是實際開發(fā)中，可以通過db去存儲groovy文件。

啟動應(yīng)用后再訪問該工程，可以發(fā)現(xiàn)header信息全部答應(yīng)出來。

ok ~ it’s work ! more about is here
轉(zhuǎn)載請注明
http://blog.csdn.net/liaokailin/article/details/51525908

歡迎關(guān)注，您的肯定是對我最大的支持