前言
zuul 是netflix 提供的一个开源组件,致力于在云平台上提供动态路由，监控，弹性，安全等边缘服务的框架。也有很多公司使用它来作为网关的重要组成部分，碰巧今年公司的架构组决定自研一个网关产品，集动态路由，动态权限，限流配额等功能为一体，为其他部门的项目提供统一的外网调用管理，最终形成产品(这方面阿里其实已经有成熟的网关产品了，但是不太适用于个性化的配置，也没有集成权限和限流降级)。
不过这里并不想介绍整个网关的架构，而是想着重于讨论其中的一个关键点，并且也是经常在交流群中听人说起的：动态路由怎么做？
再阐释什么是动态路由之前，需要介绍一下架构的设计。
传统互联网架构图
上图是没有网关参与的一个最典型的互联网架构(本文中统一使用book代表应用实例，即真正提供服务的一个业务系统)
加入eureka的架构图
book注册到eureka注册中心中，zuul本身也连接着同一个eureka，可以拉取book众多实例的列表。服务中心的注册发现一直是值得推崇的一种方式，但是不适用与网关产品。因为我们的网关是面向众多的其他部门的已有或是异构架构的系统，不应该强求其他系统都使用eureka，这样是有侵入性的设计。
最终架构图
要强调的一点是，gateway最终也会部署多个实例，达到分布式的效果，在架构图中没有画出，请大家自行脑补。
本博客的示例使用最后一章架构图为例，带来动态路由的实现方式，会有具体的代码。
动态路由
动态路由需要达到可持久化配置，动态刷新的效果。如架构图所示，不仅要能满足从spring的配置文件properties加载路由信息，还需要从数据库加载我们的配置。另外一点是，路由信息在容器启动时就已经加载进入了内存，我们希望配置完成后，实施发布，动态刷新内存中的路由信息，达到不停机维护路由信息的效果。
zuul–helloworlddemo
项目结构
|
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
|
<groupid>com.sinosoft</groupid>
<artifactid>zuul-gateway-demo</artifactid>
<packaging>pom</packaging>
<version>1.0</version>
<parent>
<groupid>org.springframework.boot</groupid>
<artifactid>spring-boot-starter-parent</artifactid>
<version>1.5.2.release</version>
</parent>
<modules>
<module>gateway</module>
<module>book</module>
</modules>
<dependencymanagement>
<dependencies>
<dependency>
<groupid>org.springframework.cloud</groupid>
<artifactid>spring-cloud-dependencies</artifactid>
<version>camden.sr6</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencymanagement>
|
tip：springboot-1.5.2对应的springcloud的版本需要使用camden.sr6，一开始想专门写这个demo时，只替换了springboot的版本1.4.0->1.5.2，结果启动就报错了，最后发现是版本不兼容的锅。
gateway项目：
启动类：gatewayapplication.java
|
1
2
3
4
5
6
7
8
9
|
@enablezuulproxy
@springbootapplication
public class gatewayapplication {
public static void main(string[] args) {
springapplication.run(gatewayapplication.class, args);
}
}
|
配置：application.properties
|
1
2
3
4
5
6
7
|
#配置在配置文件中的路由信息
zuul.routes.books.url=http://localhost:8090
zuul.routes.books.path=/books/**
#不使用注册中心,会带来侵入性
ribbon.eureka.enabled=false
#网关端口
server.port=8080
|
book项目：
启动类：bookapplication.java
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
@restcontroller
@springbootapplication
public class bookapplication {
@requestmapping(value = "/available")
public string available() {
system.out.println("spring in action");
return "spring in action";
}
@requestmapping(value = "/checked-out")
public string checkedout() {
return "spring boot in action";
}
public static void main(string[] args) {
springapplication.run(bookapplication.class, args);
}
}
|
配置类：application.properties
|
1
|
server.port=8090
|
测试访问：http://localhost:8080/books/available
上述demo是一个简单的静态路由，简单看下源码，zuul是怎么做到转发，路由的。
|
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
136
137
138
139
140
|
@configuration
@enableconfigurationproperties({ zuulproperties.class })
@conditionalonclass(zuulservlet.class)
@import(serverpropertiesautoconfiguration.class)
public class zuulconfiguration {
@autowired
//zuul的配置文件,对应了application.properties中的配置信息
protected zuulproperties zuulproperties;
@autowired
protected serverproperties server;
@autowired(required = false)
private errorcontroller errorcontroller;
@bean
public hasfeatures zuulfeature() {
return hasfeatures.namedfeature("zuul (simple)", zuulconfiguration.class);
}
//核心类，路由定位器，最最重要
@bean
@conditionalonmissingbean(routelocator.class)
public routelocator routelocator() {
//默认配置的实现是simpleroutelocator.class
return new simpleroutelocator(this.server.getservletprefix(),
this.zuulproperties);
}
//zuul的控制器，负责处理链路调用
@bean
public zuulcontroller zuulcontroller() {
return new zuulcontroller();
}
//mvc handlermapping that maps incoming request paths to remote services.
@bean
public zuulhandlermapping zuulhandlermapping(routelocator routes) {
zuulhandlermapping mapping = new zuulhandlermapping(routes, zuulcontroller());
mapping.seterrorcontroller(this.errorcontroller);
return mapping;
}
//注册了一个路由刷新监听器，默认实现是zuulrefreshlistener.class，这个是我们动态路由的关键
@bean
public applicationlistener<applicationevent> zuulrefreshrouteslistener() {
return new zuulrefreshlistener();
}
@bean
@conditionalonmissingbean(name = "zuulservlet")
public servletregistrationbean zuulservlet() {
servletregistrationbean servlet = new servletregistrationbean(new zuulservlet(),
this.zuulproperties.getservletpattern());
// the whole point of exposing this servlet is to provide a route that doesn't
// buffer requests.
servlet.addinitparameter("buffer-requests", "false");
return servlet;
}
// pre filters
@bean
public servletdetectionfilter servletdetectionfilter() {
return new servletdetectionfilter();
}
@bean
public formbodywrapperfilter formbodywrapperfilter() {
return new formbodywrapperfilter();
}
@bean
public debugfilter debugfilter() {
return new debugfilter();
}
@bean
public servlet30wrapperfilter servlet30wrapperfilter() {
return new servlet30wrapperfilter();
}
// post filters
@bean
public sendresponsefilter sendresponsefilter() {
return new sendresponsefilter();
}
@bean
public senderrorfilter senderrorfilter() {
return new senderrorfilter();
}
@bean
public sendforwardfilter sendforwardfilter() {
return new sendforwardfilter();
}
@configuration
protected static class zuulfilterconfiguration {
@autowired
private map<string, zuulfilter> filters;
@bean
public zuulfilterinitializer zuulfilterinitializer() {
return new zuulfilterinitializer(this.filters);
}
}
//上面提到的路由刷新监听器
private static class zuulrefreshlistener
implements applicationlistener<applicationevent> {
@autowired
private zuulhandlermapping zuulhandlermapping;
private heartbeatmonitor heartbeatmonitor = new heartbeatmonitor();
@override
public void onapplicationevent(applicationevent event) {
if (event instanceof contextrefreshedevent
|| event instanceof refreshscoperefreshedevent
|| event instanceof routesrefreshedevent) {
//设置为脏,下一次匹配到路径时，如果发现为脏，则会去刷新路由信息
this.zuulhandlermapping.setdirty(true);
}
else if (event instanceof heartbeatevent) {
if (this.heartbeatmonitor.update(((heartbeatevent) event).getvalue())) {
this.zuulhandlermapping.setdirty(true);
}
}
}
}
}
|
我们要解决动态路由的难题，第一步就得理解路由定位器的作用。
很失望，因为从接口关系来看，spring考虑到了路由刷新的需求，但是默认实现的simpleroutelocator没有实现refreshableroutelocator接口，看来我们只能借鉴discoveryclientroutelocator去改造simpleroutelocator使其具备刷新能力。
|
1
2
3
|
public interface refreshableroutelocator extends routelocator {
void refresh();
}
|
discoveryclientroutelocator比simpleroutelocator多了两个功能，第一是从discoveryclient（如eureka）发现路由信息，之前的架构图已经给大家解释清楚了，我们不想使用eureka这种侵入式的网关模块，所以忽略它，第二是实现了refreshableroutelocator接口，能够实现动态刷新。
对simpleroutelocator.class的源码加一些注释，方便大家阅读：
|
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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
|
public class simpleroutelocator implements routelocator {
//配置文件中的路由信息配置
private zuulproperties properties;
//路径正则配置器,即作用于path:/books/**
private pathmatcher pathmatcher = new antpathmatcher();
private string dispatcherservletpath = "/";
private string zuulservletpath;
private atomicreference<map<string, zuulroute>> routes = new atomicreference<>();
public simpleroutelocator(string servletpath, zuulproperties properties) {
this.properties = properties;
if (servletpath != null && stringutils.hastext(servletpath)) {
this.dispatcherservletpath = servletpath;
}
this.zuulservletpath = properties.getservletpath();
}
//路由定位器和其他组件的交互，是最终把定位的routes以list的方式提供出去,核心实现
@override
public list<route> getroutes() {
if (this.routes.get() == null) {
this.routes.set(locateroutes());
}
list<route> values = new arraylist<>();
for (string url : this.routes.get().keyset()) {
zuulroute route = this.routes.get().get(url);
string path = route.getpath();
values.add(getroute(route, path));
}
return values;
}
@override
public collection<string> getignoredpaths() {
return this.properties.getignoredpatterns();
}
//这个方法在网关产品中也很重要，可以根据实际路径匹配到route来进行业务逻辑的操作，进行一些加工
@override
public route getmatchingroute(final string path) {
if (log.isdebugenabled()) {
log.debug("finding route for path: " + path);
}
if (this.routes.get() == null) {
this.routes.set(locateroutes());
}
if (log.isdebugenabled()) {
log.debug("servletpath=" + this.dispatcherservletpath);
log.debug("zuulservletpath=" + this.zuulservletpath);
log.debug("requestutils.isdispatcherservletrequest()="
+ requestutils.isdispatcherservletrequest());
log.debug("requestutils.iszuulservletrequest()="
+ requestutils.iszuulservletrequest());
}
string adjustedpath = adjustpath(path);
zuulroute route = null;
if (!matchesignoredpatterns(adjustedpath)) {
for (entry<string, zuulroute> entry : this.routes.get().entryset()) {
string pattern = entry.getkey();
log.debug("matching pattern:" + pattern);
if (this.pathmatcher.match(pattern, adjustedpath)) {
route = entry.getvalue();
break;
}
}
}
if (log.isdebugenabled()) {
log.debug("route matched=" + route);
}
return getroute(route, adjustedpath);
}
private route getroute(zuulroute route, string path) {
if (route == null) {
return null;
}
string targetpath = path;
string prefix = this.properties.getprefix();
if (path.startswith(prefix) && this.properties.isstripprefix()) {
targetpath = path.substring(prefix.length());
}
if (route.isstripprefix()) {
int index = route.getpath().indexof("*") - 1;
if (index > 0) {
string routeprefix = route.getpath().substring(0, index);
targetpath = targetpath.replacefirst(routeprefix, "");
prefix = prefix + routeprefix;
}
}
boolean retryable = this.properties.getretryable();
if (route.getretryable() != null) {
retryable = route.getretryable();
}
return new route(route.getid(), targetpath, route.getlocation(), prefix,
retryable,
route.iscustomsensitiveheaders() ? route.getsensitiveheaders() : null);
}
//注意这个类并没有实现refresh接口，但是却提供了一个protected级别的方法,旨在让子类不需要重复维护一个private atomicreference<map<string, zuulroute>> routes = new atomicreference<>();也可以达到刷新的效果
protected void dorefresh() {
this.routes.set(locateroutes());
}
//具体就是在这儿定位路由信息的，我们之后从数据库加载路由信息，主要也是从这儿改写
/**
* compute a map of path pattern to route. the default is just a static map from the
* {@link zuulproperties}, but subclasses can add dynamic calculations.
*/
protected map<string, zuulroute> locateroutes() {
linkedhashmap<string, zuulroute> routesmap = new linkedhashmap<string, zuulroute>();
for (zuulroute route : this.properties.getroutes().values()) {
routesmap.put(route.getpath(), route);
}
return routesmap;
}
protected boolean matchesignoredpatterns(string path) {
for (string pattern : this.properties.getignoredpatterns()) {
log.debug("matching ignored pattern:" + pattern);
if (this.pathmatcher.match(pattern, path)) {
log.debug("path " + path + " matches ignored pattern " + pattern);
return true;
}
}
return false;
}
private string adjustpath(final string path) {
string adjustedpath = path;
if (requestutils.isdispatcherservletrequest()
&& stringutils.hastext(this.dispatcherservletpath)) {
if (!this.dispatcherservletpath.equals("/")) {
adjustedpath = path.substring(this.dispatcherservletpath.length());
log.debug("stripped dispatcherservletpath");
}
}
else if (requestutils.iszuulservletrequest()) {
if (stringutils.hastext(this.zuulservletpath)
&& !this.zuulservletpath.equals("/")) {
adjustedpath = path.substring(this.zuulservletpath.length());
log.debug("stripped zuulservletpath");
}
}
else {
// do nothing
}
log.debug("adjustedpath=" + path);
return adjustedpath;
}
}
|
重写过后的自定义路由定位器如下：
|
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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
|
public class customroutelocator extends simpleroutelocator implements refreshableroutelocator{
public final static logger logger = loggerfactory.getlogger(customroutelocator.class);
private jdbctemplate jdbctemplate;
private zuulproperties properties;
public void setjdbctemplate(jdbctemplate jdbctemplate){
this.jdbctemplate = jdbctemplate;
}
public customroutelocator(string servletpath, zuulproperties properties) {
super(servletpath, properties);
this.properties = properties;
logger.info("servletpath:{}",servletpath);
}
//父类已经提供了这个方法，这里写出来只是为了说明这一个方法很重要！！！
// @override
// protected void dorefresh() {
// super.dorefresh();
// }
@override
public void refresh() {
dorefresh();
}
@override
protected map<string, zuulroute> locateroutes() {
linkedhashmap<string, zuulroute> routesmap = new linkedhashmap<string, zuulroute>();
//从application.properties中加载路由信息
routesmap.putall(super.locateroutes());
//从db中加载路由信息
routesmap.putall(locateroutesfromdb());
//优化一下配置
linkedhashmap<string, zuulroute> values = new linkedhashmap<>();
for (map.entry<string, zuulroute> entry : routesmap.entryset()) {
string path = entry.getkey();
// prepend with slash if not already present.
if (!path.startswith("/")) {
path = "/" + path;
}
if (stringutils.hastext(this.properties.getprefix())) {
path = this.properties.getprefix() + path;
if (!path.startswith("/")) {
path = "/" + path;
}
}
values.put(path, entry.getvalue());
}
return values;
}
private map<string, zuulroute> locateroutesfromdb(){
map<string, zuulroute> routes = new linkedhashmap<>();
list<zuulroutevo> results = jdbctemplate.query("select * from gateway_api_define where enabled = true ",new beanpropertyrowmapper<>(zuulroutevo.class));
for (zuulroutevo result : results) {
if(org.apache.commons.lang3.stringutils.isblank(result.getpath()) || org.apache.commons.lang3.stringutils.isblank(result.geturl()) ){
continue;
}
zuulroute zuulroute = new zuulroute();
try {
org.springframework.beans.beanutils.copyproperties(result,zuulroute);
} catch (exception e) {
logger.error("=============load zuul route info from db with error==============",e);
}
routes.put(zuulroute.getpath(),zuulroute);
}
return routes;
}
public static class zuulroutevo {
/**
* the id of the route (the same as its map key by default).
*/
private string id;
/**
* the path (pattern) for the route, e.g. /foo/**.
*/
private string path;
/**
* the service id (if any) to map to this route. you can specify a physical url or
* a service, but not both.
*/
private string serviceid;
/**
* a full physical url to map to the route. an alternative is to use a service id
* and service discovery to find the physical address.
*/
private string url;
/**
* flag to determine whether the prefix for this route (the path, minus pattern
* patcher) should be stripped before forwarding.
*/
private boolean stripprefix = true;
/**
* flag to indicate that this route should be retryable (if supported). generally
* retry requires a service id and ribbon.
*/
private boolean retryable;
private boolean enabled;
public string getid() {
return id;
}
public void setid(string id) {
this.id = id;
}
public string getpath() {
return path;
}
public void setpath(string path) {
this.path = path;
}
public string getserviceid() {
return serviceid;
}
public void setserviceid(string serviceid) {
this.serviceid = serviceid;
}
public string geturl() {
return url;
}
public void seturl(string url) {
this.url = url;
}
public boolean isstripprefix() {
return stripprefix;
}
public void setstripprefix(boolean stripprefix) {
this.stripprefix = stripprefix;
}
public boolean getretryable() {
return retryable;
}
public void setretryable(boolean retryable) {
this.retryable = retryable;
}
public boolean getenabled() {
return enabled;
}
public void setenabled(boolean enabled) {
this.enabled = enabled;
}
}
}
|
配置这个自定义的路由定位器：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
@configuration
public class customzuulconfig {
@autowired
zuulproperties zuulproperties;
@autowired
serverproperties server;
@autowired
jdbctemplate jdbctemplate;
@bean
public customroutelocator routelocator() {
customroutelocator routelocator = new customroutelocator(this.server.getservletprefix(), this.zuulproperties);
routelocator.setjdbctemplate(jdbctemplate);
return routelocator;
}
}
|
现在容器启动时，就可以从数据库和配置文件中一起加载路由信息了，离动态路由还差最后一步，就是实时刷新，前面已经说过了，默认的zuulconfigure已经配置了事件监听器，我们只需要发送一个事件就可以实现刷新了。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
public class refreshrouteservice {
@autowired
applicationeventpublisher publisher;
@autowired
routelocator routelocator;
public void refreshroute() {
routesrefreshedevent routesrefreshedevent = new routesrefreshedevent(routelocator);
publisher.publishevent(routesrefreshedevent);
}
}
|
具体的刷新流程其实就是从数据库重新加载了一遍，有人可能会问，为什么不自己是手动重新加载locator.dorefresh？非要用事件去刷新。这牵扯到内部的zuul内部组件的工作流程，不仅仅是locator本身的一个变量，具体想要了解的还得去看源码。
到这儿我们就实现了动态路由了，所以的实例代码和建表语句我会放到github上，下载的时候记得给我star qaq ！！！
链接：https://github.com/lexburner/zuul-gateway-demo
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持服务器之家。
原文链接：https://blog.csdn.net/u013815546/article/details/68944039