spring cloud zuul实现从数据库中动态路由

项目引用jdbctemplate和druid从数据库中动态获取路由信息。

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

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

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

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

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

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

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

 

看实现类

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

 

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.  
     }

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>里的信息进行路由转发的。

建表语句：

 

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动态生效需要借助于下面的方法

 

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就会重新加载一遍路由信息，完成刷新功能。通过修改数据库，然后刷新，经测试是正常的。

 

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.  
    }

 application.yml文件

spring:

  application:

    name: microservice-api-gateway

  datasource:

    driver-class-name: com.mysql.jdbc.Driver

    initialize: true 

    name: base

    url: jdbc:mysql://127.0.0.1:3306/test

    username: tuping

    password: 123456

    initialSize: 5

    minIdle: 5

    maxIdle: 20

    maxActive: 20

    maxWait: 60000 

    timeBetweenEvictionRunsMillis: 60000 

    minEvictableIdleTimeMillis: 300000

    testWhileIdle: true

    testOnBorrow: false

    testOnReturn: false

    poolPreparedStatements: true

    maxPoolPreparedStatementPerConnectionSize: 20

server:

  port: 8050

eureka:

  instance:

    hostname: gateway

  client:

    serviceUrl:

      defaultZone: http://localhost:8761/eureka/

zuul:

  ignored-services: microservice-provider-user                        # 需要忽视的服务(配置后将不会被路由)

  routes:

    api-a:                                                            # 可以随便写，在zuul上面唯一即可；当这里的值 = service-id时，service-id可以不写。

      path: /api-a/**                                             # 想要映射到的路径

      service-id: CLOUD-RIBBON-MESSAGESYSTEM     # Eureka中的serviceId

 

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