Spring Cloud Zuul路由动态配置

Spring Cloud Zuul动态路由配置

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

上一篇初步记录了Spring Cloud GateWay的动态路由配置,这一篇说一下Zuul的动态路由配置。ZuulNetflix 开源的微服务网关,Spring CloudZuul 进行了整合和增强。在 SpringCloud 体系中,Zuul 担任着网关的角色,对发送到服务端的请求进行一些预处理,比如安全验证、动态路由、负载分配等。还是那句话,由于水平有限,难免有不当或者错误之处,请大家指正,谢谢。

Zuul配置

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

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

当我们要新增或者改变一个网关路由时,我们不得不停止网关服务,修改配置文件,保存再重新启动网关服务,这样才能让我们新的设置生效。设想一样,如果是在生产环境,为了一个小小的路由变更,这样的停止再重启恐怕谁也受不了吧。接下来,看看我们怎么能做到动态配置网关路由,让网关路由配置在服务不需要重启的情况生效。(废话一堆啊)

在mysql中创建路由信息表,对于类如下:

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

/**
* 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;
}
}

定义CustomRouteLocator类

CustomRouteLocator集成SimpleRouteLocator,实现了RefreshableRouteLocator接口

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
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;
        System.out.println(properties.toString());
        logger.info("servletPath:{}", servletPath);
    }
 
    @Override
    public void refresh() {
        doRefresh();
    }
 
    @Override
    protected Map<String, ZuulProperties.ZuulRoute> locateRoutes() {
        LinkedHashMap<String, ZuulProperties.ZuulRoute> routesMap = new LinkedHashMap<>();
        System.out.println("start " + new Date().toLocaleString());
        //从application.properties中加载路由信息
        routesMap.putAll(super.locateRoutes());
        //从db中加载路由信息
        routesMap.putAll(locateRoutesFromDB());
        //优化一下配置
        LinkedHashMap<String, ZuulProperties.ZuulRoute> values = new LinkedHashMap<>();
        for (Map.Entry<String, ZuulProperties.ZuulRoute> entry : routesMap.entrySet()) {
            String path = entry.getKey();
            System.out.println(path);
            // 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, ZuulProperties.ZuulRoute> locateRoutesFromDB() {
        Map<String, ZuulProperties.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 (StringUtils.isEmpty(result.getPath()) ) {
                continue;
            }
            if (StringUtils.isEmpty(result.getServiceId()) && StringUtils.isEmpty(result.getUrl())) {
                continue;
            }
            ZuulProperties.ZuulRoute zuulRoute = new ZuulProperties.ZuulRoute();
            try {
                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 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;
System.out.println(properties.toString());
logger.info("servletPath:{}", servletPath);
}

@Override
public void refresh() {
doRefresh();
}

@Override
protected Map<String, ZuulProperties.ZuulRoute> locateRoutes() {
LinkedHashMap<String, ZuulProperties.ZuulRoute> routesMap = new LinkedHashMap<>();
System.out.println("start " + new Date().toLocaleString());
//从application.properties中加载路由信息
routesMap.putAll(super.locateRoutes());
//从db中加载路由信息
routesMap.putAll(locateRoutesFromDB());
//优化一下配置
LinkedHashMap<String, ZuulProperties.ZuulRoute> values = new LinkedHashMap<>();
for (Map.Entry<String, ZuulProperties.ZuulRoute> entry : routesMap.entrySet()) {
String path = entry.getKey();
System.out.println(path);
// 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, ZuulProperties.ZuulRoute> locateRoutesFromDB() {
Map<String, ZuulProperties.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 (StringUtils.isEmpty(result.getPath()) ) {
continue;
}
if (StringUtils.isEmpty(result.getServiceId()) && StringUtils.isEmpty(result.getUrl())) {
continue;
}
ZuulProperties.ZuulRoute zuulRoute = new ZuulProperties.ZuulRoute();
try {
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;
}
}

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

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

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

@Bean
public CustomRouteLocator routeLocator() {
CustomRouteLocator routeLocator = new CustomRouteLocator(this.server.getServlet().getPath(), this.zuulProperties);
routeLocator.setJdbcTemplate(jdbcTemplate);
return routeLocator;
}
}

CustomerRouteLocator 去数据库获取路由配置信息,需要一个JdbcTemplate Bean。this.zuulProperties 就是配置文件里面的路由配置,应该是网关服务启动时自动就获取过来的。

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

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

@Autowired
RouteLocator routeLocator;

public void refreshRoute() {
RoutesRefreshedEvent routesRefreshedEvent = new RoutesRefreshedEvent(routeLocator);
publisher.publishEvent(routesRefreshedEvent);

}
}

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

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

@Autowired
ZuulHandlerMapping zuulHandlerMapping;

@GetMapping("/refreshRoute")
public String refresh() {
refreshRouteService.refreshRoute();
return "refresh success";
}

@RequestMapping("/watchRoute")
public Object watchNowRoute() {
//可以用debug模式看里面具体是什么
return zuulHandlerMapping.getHandlerMap();
}
}

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

问题

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

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

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

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
private static class ZuulRefreshListener implements ApplicationListener<ApplicationEvent> {
        @Autowired
        private ZuulHandlerMapping zuulHandlerMapping;
        private HeartbeatMonitor heartbeatMonitor;
 
        private ZuulRefreshListener() {
            this.heartbeatMonitor = new HeartbeatMonitor();
        }
 
        @Override
        public void onApplicationEvent(ApplicationEvent event) {
            if (!(event instanceof ContextRefreshedEvent) && !(event instanceof RefreshScopeRefreshedEvent) && !(event instanceof RoutesRefreshedEvent) && !(event instanceof InstanceRegisteredEvent)) {
                if (event instanceof ParentHeartbeatEvent) {
                    ParentHeartbeatEvent e = (ParentHeartbeatEvent)event;
                    this.resetIfNeeded(e.getValue());
 
                } else if (event instanceof HeartbeatEvent) {
                    HeartbeatEvent e = (HeartbeatEvent)event;
                    this.resetIfNeeded(e.getValue());
 
                }
            } else {
                /**
                 * 原来代码
                 * this.reset();
                 */
                if ((event instanceof ContextRefreshedEvent) || (event instanceof RefreshScopeRefreshedEvent) || (event instanceof RoutesRefreshedEvent)) {
 
                    if (event instanceof ContextRefreshedEvent) {
                        ContextRefreshedEvent contextRefreshedEvent = (ContextRefreshedEvent) event;
                        ApplicationContext context = contextRefreshedEvent.getApplicationContext();
 
                        String eventClassName = context.getClass().getName();
 
                        /**
                         * 为了服务启动只执行一次从数据库里面获取路由信息,这儿进行判断
                         */
                        if (eventClassName.equals("org.springframework.context.annotation.AnnotationConfigApplicationContext")) {
                            this.reset();
                        }
                    } else {
                        this.reset();
                    }
                }
            }
 
        }
 
        private void resetIfNeeded(Object value) {
            /**
             * 发送监控心态信息接收到注册服务中心的数据后,只更新心态的相关信息,不再从新load整个路由
             * 原来是从新load路由信息,可以把新注册的服务都动态load进来。
             * 现在要求新的服务的路由在数据库里面配置。
             *
             * 否则的话每30秒发送心态检测,就会更新一次路由信息,没有必要
             *
             */
            if (!this.heartbeatMonitor.update(value)) {
                return;
            }
            /* 原来代码
            if (this.heartbeatMonitor.update(value)) {
                this.reset();
            }*/
 
        }

private ZuulRefreshListener() {
this.heartbeatMonitor = new HeartbeatMonitor();
}

@Override
public void onApplicationEvent(ApplicationEvent event) {
if (!(event instanceof ContextRefreshedEvent) && !(event instanceof RefreshScopeRefreshedEvent) && !(event instanceof RoutesRefreshedEvent) && !(event instanceof InstanceRegisteredEvent)) {
if (event instanceof ParentHeartbeatEvent) {
ParentHeartbeatEvent e = (ParentHeartbeatEvent)event;
this.resetIfNeeded(e.getValue());

} else if (event instanceof HeartbeatEvent) {
HeartbeatEvent e = (HeartbeatEvent)event;
this.resetIfNeeded(e.getValue());

}
} else {
/**
* 原来代码
* this.reset();
*/
if ((event instanceof ContextRefreshedEvent) || (event instanceof RefreshScopeRefreshedEvent) || (event instanceof RoutesRefreshedEvent)) {

if (event instanceof ContextRefreshedEvent) {
ContextRefreshedEvent contextRefreshedEvent = (ContextRefreshedEvent) event;
ApplicationContext context = contextRefreshedEvent.getApplicationContext();

String eventClassName = context.getClass().getName();

/**
* 为了服务启动只执行一次从数据库里面获取路由信息,这儿进行判断
*/
if (eventClassName.equals("org.springframework.context.annotation.AnnotationConfigApplicationContext")) {
this.reset();
}
} else {
this.reset();
}
}
}

}

private void resetIfNeeded(Object value) {
/**
* 发送监控心态信息接收到注册服务中心的数据后,只更新心态的相关信息,不再从新load整个路由
* 原来是从新load路由信息,可以把新注册的服务都动态load进来。
* 现在要求新的服务的路由在数据库里面配置。
*
* 否则的话每30秒发送心态检测,就会更新一次路由信息,没有必要
*
*/
if (!this.heartbeatMonitor.update(value)) {
return;
}
/* 原来代码
if (this.heartbeatMonitor.update(value)) {
this.reset();
}*/

}

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

发表评论

您的电子邮箱地址不会被公开。 必填项已用*标注

关注我们