zuul动态配置路由规则，从DB读取

前面已经讲过zuul在application.yml里配置路由规则，将用户请求分发至不同微服务的例子。

zuul作为一个网关，是用户请求的入口，担当鉴权、转发的重任，理应保持高可用性和具备动态配置的能力。

我画了一个实际中可能使用的配置框架，如图。

当用户发起请求后，首先通过并发能力强、能承担更多用户请求的负载均衡器进行第一步的负载均衡，将大量的请求分发至多个网关服务。这是分布式的第一步。如果是使用docker的话，并且使用rancher进行docker管理，那么可以很简单的使用rancher自带的负载均衡，创建HaProxy，将请求分发至多个Zuul的docker容器。使用多个zuul的原因即是避免单点故障，由于网关非常重要，尽量配置多个实例。

然后在Zuul网关中，执行完自定义的网关职责后，将请求转发至另一个HaProxy负载的微服务集群，同样是避免微服务单点故障和性能瓶颈。

最后由具体的微服务处理用户请求并返回结果。

那么为什么要设置zuul的动态配置呢，因为网关其特殊性，我们不希望它重启再加载新的配置，而且如果能实时动态配置，我们就可以完成无感知的微服务迁移替换，在某种程度还可以完成服务降级的功能。

zuul的动态配置也很简单，这里我们参考http://blog.csdn.net/u013815546/article/details/68944039 并使用他的方法，从数据库读取配置信息，刷新配置。

看实现类

配置文件里我们可以不配置zuul的任何路由，全部交给数据库配置。

[java] view plain copy

 print?

1. package com.tianyalei.testzuul.config;  
2.   
3. import org.slf4j.Logger;  
4. import org.slf4j.LoggerFactory;  
5. import org.springframework.beans.BeanUtils;  
6. import org.springframework.cloud.netflix.zuul.filters.RefreshableRouteLocator;  
7. import org.springframework.cloud.netflix.zuul.filters.SimpleRouteLocator;  
8. import org.springframework.cloud.netflix.zuul.filters.ZuulProperties;  
9. import org.springframework.jdbc.core.BeanPropertyRowMapper;  
10. import org.springframework.jdbc.core.JdbcTemplate;  
11. import org.springframework.util.StringUtils;  
12.   
13. import java.util.LinkedHashMap;  
14. import java.util.List;  
15. import java.util.Map;  
16.   
17. public class CustomRouteLocator extends SimpleRouteLocator implements RefreshableRouteLocator {  
18.   
19.     public final static Logger logger = LoggerFactory.getLogger(CustomRouteLocator.class);  
20.   
21.     private JdbcTemplate jdbcTemplate;  
22.   
23.     private ZuulProperties properties;  
24.   
25.     public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {  
26.         this.jdbcTemplate = jdbcTemplate;  
27.     }  
28.   
29.     public CustomRouteLocator(String servletPath, ZuulProperties properties) {  
30.         super(servletPath, properties);  
31.         this.properties = properties;  
32.         logger.info("servletPath:{}", servletPath);  
33.     }  
34.   
35.     //父类已经提供了这个方法，这里写出来只是为了说明这一个方法很重要！！！  
36. //    @Override  
37. //    protected void doRefresh() {  
38. //        super.doRefresh();  
39. //    }  
40.   
41.   
42.     @Override  
43.     public void refresh() {  
44.         doRefresh();  
45.     }  
46.   
47.     @Override  
48.     protected Map<String, ZuulProperties.ZuulRoute> locateRoutes() {  
49.         LinkedHashMap<String, ZuulProperties.ZuulRoute> routesMap = new LinkedHashMap<>();  
50.         //从application.properties中加载路由信息  
51.         routesMap.putAll(super.locateRoutes());  
52.         //从db中加载路由信息  
53.         routesMap.putAll(locateRoutesFromDB());  
54.         //优化一下配置  
55.         LinkedHashMap<String, ZuulProperties.ZuulRoute> values = new LinkedHashMap<>();  
56.         for (Map.Entry<String, ZuulProperties.ZuulRoute> entry : routesMap.entrySet()) {  
57.             String path = entry.getKey();  
58.             // Prepend with slash if not already present.  
59.             if (!path.startsWith("/")) {  
60.                 path = "/" + path;  
61.             }  
62.             if (StringUtils.hasText(this.properties.getPrefix())) {  
63.                 path = this.properties.getPrefix() + path;  
64.                 if (!path.startsWith("/")) {  
65.                     path = "/" + path;  
66.                 }  
67.             }  
68.             values.put(path, entry.getValue());  
69.         }  
70.         return values;  
71.     }  
72.   
73.     private Map<String, ZuulProperties.ZuulRoute> locateRoutesFromDB() {  
74.         Map<String, ZuulProperties.ZuulRoute> routes = new LinkedHashMap<>();  
75.         List<ZuulRouteVO> results = jdbcTemplate.query("select * from gateway_api_define where enabled = true ", new  
76.                 BeanPropertyRowMapper<>(ZuulRouteVO.class));  
77.         for (ZuulRouteVO result : results) {  
78.             if (StringUtils.isEmpty(result.getPath()) ) {  
79.                 continue;  
80.             }  
81.             if (StringUtils.isEmpty(result.getServiceId()) && StringUtils.isEmpty(result.getUrl())) {  
82.                 continue;  
83.             }  
84.             ZuulProperties.ZuulRoute zuulRoute = new ZuulProperties.ZuulRoute();  
85.             try {  
86.                 BeanUtils.copyProperties(result, zuulRoute);  
87.             } catch (Exception e) {  
88.                 logger.error("=============load zuul route info from db with error==============", e);  
89.             }  
90.             routes.put(zuulRoute.getPath(), zuulRoute);  
91.         }  
92.         return routes;  
93.     }  
94.   
95.     public static class ZuulRouteVO {  
96.   
97.         /** 
98.          * The ID of the route (the same as its map key by default). 
99.          */  
100.         private String id;  
101.   
102.         /** 
103.          * The path (pattern) for the route, e.g. /foo/**. 
104.          */  
105.         private String path;  
106.   
107.         /** 
108.          * The service ID (if any) to map to this route. You can specify a physical URL or 
109.          * a service, but not both. 
110.          */  
111.         private String serviceId;  
112.   
113.         /** 
114.          * A full physical URL to map to the route. An alternative is to use a service ID 
115.          * and service discovery to find the physical address. 
116.          */  
117.         private String url;  
118.   
119.         /** 
120.          * Flag to determine whether the prefix for this route (the path, minus pattern 
121.          * patcher) should be stripped before forwarding. 
122.          */  
123.         private boolean stripPrefix = true;  
124.   
125.         /** 
126.          * Flag to indicate that this route should be retryable (if supported). Generally 
127.          * retry requires a service ID and ribbon. 
128.          */  
129.         private Boolean retryable;  
130.   
131.         private Boolean enabled;  
132.   
133.         public String getId() {  
134.             return id;  
135.         }  
136.   
137.         public void setId(String id) {  
138.             this.id = id;  
139.         }  
140.   
141.         public String getPath() {  
142.             return path;  
143.         }  
144.   
145.         public void setPath(String path) {  
146.             this.path = path;  
147.         }  
148.   
149.         public String getServiceId() {  
150.             return serviceId;  
151.         }  
152.   
153.         public void setServiceId(String serviceId) {  
154.             this.serviceId = serviceId;  
155.         }  
156.   
157.         public String getUrl() {  
158.             return url;  
159.         }  
160.   
161.         public void setUrl(String url) {  
162.             this.url = url;  
163.         }  
164.   
165.         public boolean isStripPrefix() {  
166.             return stripPrefix;  
167.         }  
168.   
169.         public void setStripPrefix(boolean stripPrefix) {  
170.             this.stripPrefix = stripPrefix;  
171.         }  
172.   
173.         public Boolean getRetryable() {  
174.             return retryable;  
175.         }  
176.   
177.         public void setRetryable(Boolean retryable) {  
178.             this.retryable = retryable;  
179.         }  
180.   
181.         public Boolean getEnabled() {  
182.             return enabled;  
183.         }  
184.   
185.         public void setEnabled(Boolean enabled) {  
186.             this.enabled = enabled;  
187.         }  
188.     }  
189. }  

[java] view plain copy

 print?

1. package com.tianyalei.testzuul.config;  
2.   
3. import org.springframework.beans.factory.annotation.Autowired;  
4. import org.springframework.boot.autoconfigure.web.ServerProperties;  
5. import org.springframework.cloud.netflix.zuul.filters.ZuulProperties;  
6. import org.springframework.context.annotation.Bean;  
7. import org.springframework.context.annotation.Configuration;  
8. import org.springframework.jdbc.core.JdbcTemplate;  
9.   
10. @Configuration  
11. public class CustomZuulConfig {  
12.   
13.     @Autowired  
14.     ZuulProperties zuulProperties;  
15.     @Autowired  
16.     ServerProperties server;  
17.     @Autowired  
18.     JdbcTemplate jdbcTemplate;  
19.   
20.     @Bean  
21.     public CustomRouteLocator routeLocator() {  
22.         CustomRouteLocator routeLocator = new CustomRouteLocator(this.server.getServletPrefix(), this.zuulProperties);  
23.         routeLocator.setJdbcTemplate(jdbcTemplate);  
24.         return routeLocator;  
25.     }  
26.   
27. }  

下面的config类功能就是使用自定义的RouteLocator类，上面的类就是这个自定义类。

里面主要是一个方法，locateRoutes方法，该方法就是zuul设置路由规则的地方，在方法里做了2件事，一是从application.yml读取配置的路由信息，二是从数据库里读取路由信息，所以数据库里需要一个各字段和ZuulProperties.ZuulRoute一样的表，存储路由信息，从数据库读取后添加到系统的Map<String, ZuulProperties.ZuulRoute>中。

在实际的路由中，zuul就是按照Map<String, ZuulProperties.ZuulRoute>里的信息进行路由转发的。

建表语句：

[html] view plain copy

 print?

1. create table `gateway_api_define` (  
2.   `id` varchar(50) not null,  
3.   `path` varchar(255) not null,  
4.   `service_id` varchar(50) default null,  
5.   `url` varchar(255) default null,  
6.   `retryable` tinyint(1) default null,  
7.   `enabled` tinyint(1) not null,  
8.   `strip_prefix` int(11) default null,  
9.   `api_name` varchar(255) default null,  
10.   primary key (`id`)  
11. ) engine=innodb default charset=utf8  
12.   
13.   
14. INSERT INTO gateway_api_define (id, path, service_id, retryable, strip_prefix, url, enabled) VALUES ('user', '/user/**', null,0,1, 'http://localhost:8081', 1);  
15. INSERT INTO gateway_api_define (id, path, service_id, retryable, strip_prefix, url, enabled) VALUES ('club', '/club/**', null,0,1, 'http://localhost:8090', 1);  

通过上面的两个类，再结合前面几篇讲过的zuul的使用，就可以自行测试一下在数据库里配置的信息能否在zuul中生效了。

数据库里的各字段分别对应原本在yml里配置的同名属性，如path，service_id，url等，等于把配置文件存到数据库里。

至于修改数据库值信息后（增删改），让zuul动态生效需要借助于下面的方法

[java] view plain copy

 print?

1. package com.tianyalei.testzuul.config;  
2.   
3. import org.springframework.beans.factory.annotation.Autowired;  
4. import org.springframework.cloud.netflix.zuul.RoutesRefreshedEvent;  
5. import org.springframework.cloud.netflix.zuul.filters.RouteLocator;  
6. import org.springframework.context.ApplicationEventPublisher;  
7. import org.springframework.stereotype.Service;  
8.   
9. @Service  
10. public class RefreshRouteService {  
11.     @Autowired  
12.     ApplicationEventPublisher publisher;  
13.   
14.     @Autowired  
15.     RouteLocator routeLocator;  
16.   
17.     public void refreshRoute() {  
18.         RoutesRefreshedEvent routesRefreshedEvent = new RoutesRefreshedEvent(routeLocator);  
19.         publisher.publishEvent(routesRefreshedEvent);  
20.     }  
21. }  

可以定义一个Controller，在Controller里调用refreshRoute方法即可，zuul就会重新加载一遍路由信息，完成刷新功能。通过修改数据库，然后刷新，经测试是正常的。

[java] view plain copy

 print?

1. @RestController  
2. public class RefreshController {  
3.     @Autowired  
4.     RefreshRouteService refreshRouteService;  
5.     @Autowired  
6.     ZuulHandlerMapping zuulHandlerMapping;  
7.   
8.     @GetMapping("/refreshRoute")  
9.     public String refresh() {  
10.         refreshRouteService.refreshRoute();  
11.         return "refresh success";  
12.     }  
13.   
14.     @RequestMapping("/watchRoute")  
15.     public Object watchNowRoute() {  
16.         //可以用debug模式看里面具体是什么  
17.         Map<String, Object> handlerMap = zuulHandlerMapping.getHandlerMap();  
18.         return handlerMap;  
19.     }  
20.   
21. }  

参考http://blog.csdn.net/u013815546/article/details/68944039，作者从源码角度讲解了动态配置的使用。