Spring Cloud Zuul路由动态配置

目录

• Zuul配置
  
• 在mysql中创建路由信息表
  
• 定义CustomRouteLocator类
  
• 增加CustomZuulConfig类，主要是为了配置CustomRouteLocator
  
• RefreshRouteService类，用于实现数据库路由信息的刷新
  
• 当然也要提供RefreshController，提供从浏览器访问的刷新功能
  
• 问题
  
• 后记
  

上一篇初步记录了Spring Cloud GateWay的动态路由配置，这一篇说一下Zuul的动态路由配置。Zuul 是 Netflix 开源的微服务网关，Spring Cloud 对 Zuul 进行了整合和增强。在 SpringCloud 体系中，Zuul 担任着网关的角色，对发送到服务端的请求进行一些预处理，比如安全验证、动态路由、负载分配等。

还是那句话，由于水平有限，难免有不当或者错误之处，请大家指正，谢谢。

Zuul配置

一般的，我们如果使用Spring Cloud Zuul 进行路由配置，类似于下面的样子:

1. zuul:
   
2.  routes:
   
3.    users:
   
4.      path:/myusers/**
   
5.      stripPrefix:false
   

当我们要新增或者改变一个网关路由时，我们不得不停止网关服务，修改配置文件，保存再重新启动网关服务，这样才能让我们新的设置生效。

设想一样，如果是在生产环境，为了一个小小的路由变更，这样的停止再重启恐怕谁也受不了吧。接下来，看看我们怎么能做到动态配置网关路由，让网关路由配置在服务不需要重启的情况生效。（废话一堆啊）

在mysql中创建路由信息表，对于类如下：

1. publicstaticclassZuulRouteVO{
   
2. 
   
3.        /**
   
4.         * The ID of the route (the same as its map key by default).
   
5.         */
   
6.        privateString id;
   
7. 
   
8.        /**
   
9.         * The path (pattern) for the route, e.g. /foo/**.
   
10.         */
    
11.        privateString path;
    
12. 
    
13.        /**
    
14.         * The service ID (if any) to map to this route. You can specify a physical URL or
    
15.         * a service, but not both.
    
16.         */
    
17.        privateString serviceId;
    
18. 
    
19.        /**
    
20.         * A full physical URL to map to the route. An alternative is to use a service ID
    
21.         * and service discovery to find the physical address.
    
22.         */
    
23.        privateString url;
    
24. 
    
25.        /**
    
26.         * Flag to determine whether the prefix for this route (the path, minus pattern
    
27.         * patcher) should be stripped before forwarding.
    
28.         */
    
29.        privateboolean stripPrefix =true;
    
30. 
    
31.        /**
    
32.         * Flag to indicate that this route should be retryable (if supported). Generally
    
33.         * retry requires a service ID and ribbon.
    
34.         */
    
35.        privateBoolean retryable;
    
36. 
    
37.        privateBoolean enabled;
    
38. 
    
39.        publicString getId(){
    
40.            return id;
    
41.        }
    
42. 
    
43.        publicvoid setId(String id){
    
44.            this.id = id;
    
45.        }
    
46. 
    
47.        publicString getPath(){
    
48.            return path;
    
49.        }
    
50. 
    
51.        publicvoid setPath(String path){
    
52.            this.path = path;
    
53.        }
    
54. 
    
55.        publicString getServiceId(){
    
56.            return serviceId;
    
57.        }
    
58. 
    
59.        publicvoid setServiceId(String serviceId){
    
60.            this.serviceId = serviceId;
    
61.        }
    
62. 
    
63.        publicString getUrl(){
    
64.            return url;
    
65.        }
    
66. 
    
67.        publicvoid setUrl(String url){
    
68.            this.url = url;
    
69.        }
    
70. 
    
71.        publicboolean isStripPrefix(){
    
72.            return stripPrefix;
    
73.        }
    
74. 
    
75.        publicvoid setStripPrefix(boolean stripPrefix){
    
76.            this.stripPrefix = stripPrefix;
    
77.        }
    
78. 
    
79.        publicBoolean getRetryable(){
    
80.            return retryable;
    
81.        }
    
82. 
    
83.        publicvoid setRetryable(Boolean retryable){
    
84.            this.retryable = retryable;
    
85.        }
    
86. 
    
87.        publicBoolean getEnabled(){
    
88.            return enabled;
    
89.        }
    
90. 
    
91.        publicvoid setEnabled(Boolean enabled){
    
92.            this.enabled = enabled;
    
93.        }
    
94.    }
    

定义CustomRouteLocator类

CustomRouteLocator集成SimpleRouteLocator,实现了RefreshableRouteLocator接口

1. publicclassCustomRouteLocatorextendsSimpleRouteLocatorimplementsRefreshableRouteLocator{
   
2. 
   
3.    publicfinalstaticLogger logger =LoggerFactory.getLogger(CustomRouteLocator.class);
   
4. 
   
5.    privateJdbcTemplate jdbcTemplate;
   
6. 
   
7.    privateZuulProperties properties;
   
8. 
   
9.    publicvoid setJdbcTemplate(JdbcTemplate jdbcTemplate){
   
10.        this.jdbcTemplate = jdbcTemplate;
    
11.    }
    
12. 
    
13.    publicCustomRouteLocator(String servletPath,ZuulProperties properties){
    
14. 
    
15.        super(servletPath, properties);
    
16.        this.properties = properties;
    
17.        System.out.println(properties.toString());
    
18.        logger.info("servletPath:{}", servletPath);
    
19.    }
    
20. 
    
21.    @Override
    
22.    publicvoid refresh(){
    
23.        doRefresh();
    
24.    }
    
25. 
    
26.    @Override
    
27.    protectedMap<String,ZuulProperties.ZuulRoute> locateRoutes(){
    
28.        LinkedHashMap<String,ZuulProperties.ZuulRoute> routesMap =newLinkedHashMap<>();
    
29.        System.out.println("start "+newDate().toLocaleString());
    
30.        //从application.properties中加载路由信息
    
31.        routesMap.putAll(super.locateRoutes());
    
32.        //从db中加载路由信息
    
33.        routesMap.putAll(locateRoutesFromDB());
    
34.        //优化一下配置
    
35.        LinkedHashMap<String,ZuulProperties.ZuulRoute> values =newLinkedHashMap<>();
    
36.        for(Map.Entry<String,ZuulProperties.ZuulRoute> entry : routesMap.entrySet()){
    
37.            String path = entry.getKey();
    
38.            System.out.println(path);
    
39.            // Prepend with slash if not already present.
    
40.            if(!path.startsWith("/")){
    
41.                path ="/"+ path;
    
42.            }
    
43.            if(StringUtils.hasText(this.properties.getPrefix())){
    
44.                path =this.properties.getPrefix()+ path;
    
45.                if(!path.startsWith("/")){
    
46.                    path ="/"+ path;
    
47.                }
    
48.            }
    
49.            values.put(path, entry.getValue());
    
50.        }
    
51.        return values;
    
52.    }
    
53. 
    
54.    privateMap<String,ZuulProperties.ZuulRoute> locateRoutesFromDB(){
    
55.        Map<String,ZuulProperties.ZuulRoute> routes =newLinkedHashMap<>();
    
56.        List<ZuulRouteVO> results = jdbcTemplate.query("select * from gateway_api_define where enabled = true ",new
    
57.                BeanPropertyRowMapper<>(ZuulRouteVO.class));
    
58.        for(ZuulRouteVO result : results){
    
59.            if(StringUtils.isEmpty(result.getPath())){
    
60.                continue;
    
61.            }
    
62.            if(StringUtils.isEmpty(result.getServiceId())&&StringUtils.isEmpty(result.getUrl())){
    
63.                continue;
    
64.            }
    
65.            ZuulProperties.ZuulRoute zuulRoute =newZuulProperties.ZuulRoute();
    
66.            try{
    
67.                BeanUtils.copyProperties(result, zuulRoute);
    
68.            }catch(Exception e){
    
69.                logger.error("=============load zuul route info from db with error==============", e);
    
70.            }
    
71.            routes.put(zuulRoute.getPath(), zuulRoute);
    
72.        }
    
73.        return routes;
    
74.    }  
    
75. }
    

主要的是locateRoutes和locateRoutesFromDB这两个函数，locateRoutes是从SimpleRouteLocator Override过来的，先装载配置文件里面的路由信息，在从数据库里面获取路由信息，最后都是保存在SimpleRoteLocator 的AtomicReference<map> routes属性中，注意routes是类型，它是可以保证线程俺去的。</map

增加CustomZuulConfig类，主要是为了配置CustomRouteLocator

1. @Configuration
   
2. publicclassCustomZuulConfig{
   
3.    @Autowired
   
4.    ZuulProperties zuulProperties;
   
5.    @Autowired
   
6.    ServerProperties server;
   
7.    @Autowired
   
8.    JdbcTemplate jdbcTemplate;
   
9. 
   
10.    @Bean
    
11.    publicCustomRouteLocator routeLocator(){
    
12.        CustomRouteLocator routeLocator =newCustomRouteLocator(this.server.getServlet().getPath(),this.zuulProperties);
    
13.        routeLocator.setJdbcTemplate(jdbcTemplate);
    
14.        return routeLocator;
    
15.    }
    
16. }
    

CustomerRouteLocator 去数据库获取路由配置信息，需要一个JdbcTemplate Bean。

this.zuulProperties 就是配置文件里面的路由配置，应该是网关服务启动时自动就获取过来的。

RefreshRouteService类，用于实现数据库路由信息的刷新

1. @Service
   
2. publicclassRefreshRouteService{
   
3.    @Autowired
   
4.    ApplicationEventPublisher publisher;
   
5. 
   
6.    @Autowired
   
7.    RouteLocator routeLocator;
   
8. 
   
9.    publicvoid refreshRoute(){
   
10.        RoutesRefreshedEvent routesRefreshedEvent =newRoutesRefreshedEvent(routeLocator);
    
11.        publisher.publishEvent(routesRefreshedEvent);
    
12. 
    
13.    }
    
14. }
    

当然也要提供RefreshController，提供从浏览器访问的刷新功能

1. @RestController
   
2. publicclassRefreshController{
   
3.    @Autowired
   
4.    RefreshRouteService refreshRouteService;
   
5. 
   
6.    @Autowired
   
7.    ZuulHandlerMapping zuulHandlerMapping;
   
8. 
   
9.    @GetMapping("/refreshRoute")
   
10.    publicString refresh(){
    
11.        refreshRouteService.refreshRoute();
    
12.        return"refresh success";
    
13.    }
    
14. 
    
15.    @RequestMapping("/watchRoute")
    
16.    publicObject watchNowRoute(){
    
17.        //可以用debug模式看里面具体是什么
    
18.        return zuulHandlerMapping.getHandlerMap();
    
19.    }
    
20. }
    

上面两个实现的功能是，在数据库里面新增或者修改路由信息，通过上面的功能进行刷新。

问题

网关服务跑起来了，也能实现正常的路由功能。但是，等等，查看日志，发现每隔30秒，服务自动从数据库再次加载路由配置，这是为什么呢？

这个问题在于ZuulRefreshListener 这个类，这个类j实现了ApplicationListener 接口，监听系统的Event，然后进行刷新。

让我们来更改这个类的代码：

1. privatestaticclassZuulRefreshListenerimplementsApplicationListener<ApplicationEvent>{
   
2.        @Autowired
   
3.        privateZuulHandlerMapping zuulHandlerMapping;
   
4.        privateHeartbeatMonitor heartbeatMonitor;
   
5. 
   
6.        privateZuulRefreshListener(){
   
7.            this.heartbeatMonitor =newHeartbeatMonitor();
   
8.        }
   
9. 
   
10.        @Override
    
11.        publicvoid onApplicationEvent(ApplicationEventevent){
    
12.            if(!(eventinstanceofContextRefreshedEvent)&&!(eventinstanceofRefreshScopeRefreshedEvent)&&!(eventinstanceofRoutesRefreshedEvent)&&!(eventinstanceofInstanceRegisteredEvent)){
    
13.                if(eventinstanceofParentHeartbeatEvent){
    
14.                    ParentHeartbeatEvent e =(ParentHeartbeatEvent)event;
    
15.                    this.resetIfNeeded(e.getValue());
    
16. 
    
17.                }elseif(eventinstanceofHeartbeatEvent){
    
18.                    HeartbeatEvent e =(HeartbeatEvent)event;
    
19.                    this.resetIfNeeded(e.getValue());
    
20. 
    
21.                }
    
22.            }else{
    
23.                /**
    
24.                 * 原来代码
    
25.                 * this.reset();
    
26.                 */
    
27.                if((eventinstanceofContextRefreshedEvent)||(eventinstanceofRefreshScopeRefreshedEvent)||(eventinstanceofRoutesRefreshedEvent)){
    
28. 
    
29.                    if(eventinstanceofContextRefreshedEvent){
    
30.                        ContextRefreshedEvent contextRefreshedEvent =(ContextRefreshedEvent)event;
    
31.                        ApplicationContext context = contextRefreshedEvent.getApplicationContext();
    
32. 
    
33.                        String eventClassName = context.getClass().getName();
    
34. 
    
35.                        /**
    
36.                         * 为了服务启动只执行一次从数据库里面获取路由信息，这儿进行判断
    
37.                         */
    
38.                        if(eventClassName.equals("org.springframework.context.annotation.AnnotationConfigApplicationContext")){
    
39.                            this.reset();
    
40.                        }
    
41.                    }else{
    
42.                        this.reset();
    
43.                    }
    
44.                }
    
45.            }
    
46. 
    
47.        }
    
48. 
    
49.        privatevoid resetIfNeeded(Object value){
    
50.            /**
    
51.             * 发送监控心态信息接收到注册服务中心的数据后，只更新心态的相关信息，不再从新load整个路由
    
52.             * 原来是从新load路由信息，可以把新注册的服务都动态load进来。
    
53.             * 现在要求新的服务的路由在数据库里面配置。
    
54.             *
    
55.             * 否则的话每30秒发送心态检测，就会更新一次路由信息，没有必要
    
56.             *
    
57.             */
    
58.            if(!this.heartbeatMonitor.update(value)){
    
59.                return;
    
60.            }
    
61.            /* 原来代码
    
62.            if (this.heartbeatMonitor.update(value)) {
    
63.                this.reset();
    
64.            }*/
    
65. 
    
66.        }
    

为什么会30秒一次频繁的获取路由配置，上面的注释已经说的很清楚了。 测试，一切顺利！

后记

写博客很累，主要是没有经验，又担心有的地方理解错误，误导大家。出现问题，有的时候需要去从源码哪里找到答案。本文如果在实践中出现任何问题，欢迎留言指正。