Zuul路由源码

Zuul对于动态路由的实现，默认是从配置文件里面去拿到相关的配置数据的。
比如在 application.yml 里面做如下配置

  1. zuul:
  2.     routes:
  3.       service1:
  4.         path: /api/service1/**
  5.       serviceId: service1
  6.     github:
  7.         path: /github/**
  8.       url: https://github.com/

ZuulProperties

  1. @ConfigurationProperties("zuul")
  2. public class ZuulProperties {
  3.     public static final List<String> SECURITY_HEADERS = Arrays.asList("Pragma", "Cache-Control", "X-Frame-Options", "X-Content-Type-Options", "X-XSS-Protection", "Expires");
  4.     private String prefix = "";
  5.     private boolean stripPrefix = true;
  6.     private Boolean retryable = false;
  7.     private Map<String, ZuulProperties.ZuulRoute> routes = new LinkedHashMap();
  8.     private boolean addProxyHeaders = true;
  9.     private boolean addHostHeader = false;
  10.     private Set<String> ignoredServices = new LinkedHashSet();
  11.     private Set<String> ignoredPatterns = new LinkedHashSet();
  12.     private Set<String> ignoredHeaders = new LinkedHashSet();
  13.     private boolean ignoreSecurityHeaders = true;
  14.     private boolean forceOriginalQueryStringEncoding = false;
  15.     private String servletPath = "/zuul";
  16.     private boolean ignoreLocalService = true;
  17.     private ZuulProperties.Host host = new ZuulProperties.Host();
  18.     private boolean traceRequestBody = true;
  19.     private boolean removeSemicolonContent = true;
  20.     private Set<String> sensitiveHeaders = new LinkedHashSet(Arrays.asList("Cookie", "Set-Cookie", "Authorization"));
  21.     private boolean sslHostnameValidationEnabled = true;
  22.     private ExecutionIsolationStrategy ribbonIsolationStrategy;
  23.     private ZuulProperties.HystrixSemaphore semaphore;
  24.     private ZuulProperties.HystrixThreadPool threadPool;
  25.     ......
  26.     ......
  28.     public static class ZuulRoute {
  29.         private String id;
  30.         private String path;
  31.            private String serviceId;
  32.         private String url;
  33.         private boolean stripPrefix = true;
  34.            private Boolean retryable;
  35.         private Set<String> sensitiveHeaders = new LinkedHashSet();
  36.         private boolean customSensitiveHeaders = false; 
  37.         ......
  38.         ......    
  39.     }
  40. }

路由信息配置前置过滤器

  1. public class PreDecorationFilter extends ZuulFilter {
  3.     public PreDecorationFilter(RouteLocator routeLocator, String dispatcherServletPath, ZuulProperties properties, ProxyRequestHelper proxyRequestHelper) {
  4.         this.routeLocator = routeLocator;
  5.         this.properties = properties;
  6.         this.urlPathHelper.setRemoveSemicolonContent(properties.isRemoveSemicolonContent());
  7.         this.dispatcherServletPath = dispatcherServletPath;
  8.         this.proxyRequestHelper = proxyRequestHelper;
  9.     }
  11.     @Override
  12.     public Object run() {
  13.         RequestContext ctx = RequestContext.getCurrentContext();
  14.         // 根据request提取requestURI
  15.         String requestURI = this.urlPathHelper.getPathWithinApplication(ctx.getRequest());
  16.         Route route = this.routeLocator.getMatchingRoute(requestURI);
  17.         String location;
  18.         String xforwardedfor;
  19.         String remoteAddr;
  20.         if (route != null) {
  21.             location = route.getLocation();
  22.             if (location != null) {
  23.                 ctx.put("requestURI", route.getPath());
  24.                 ctx.put("proxy", route.getId());
  25.                 if (!route.isCustomSensitiveHeaders()) {
  26.                     this.proxyRequestHelper.addIgnoredHeaders((String[])this.properties.getSensitiveHeaders().toArray(new String[0]));
  27.                 } else {
  28.                     this.proxyRequestHelper.addIgnoredHeaders((String[])route.getSensitiveHeaders().toArray(new String[0]));
  29.                 }
  31.                 if (route.getRetryable() != null) {
  32.                     ctx.put("retryable", route.getRetryable());
  33.                 }
  35.                 if (!location.startsWith("http:") && !location.startsWith("https:")) {
  36.                     if (location.startsWith("forward:")) {
  37.                         ctx.set("forward.to", StringUtils.cleanPath(location.substring("forward:".length()) + route.getPath()));
  38.                         ctx.setRouteHost((URL)null);
  39.                         return null;
  40.                     }
  41.                     // 排除 http: 、 https: 、 forward:
  42.                     ctx.set("serviceId", location);
  43.                     ctx.setRouteHost((URL)null);
  44.                     ctx.addOriginResponseHeader("X-Zuul-ServiceId", location);
  45.                 } else { // http: 或 https:
  46.                     ctx.setRouteHost(this.getUrl(location));
  47.                     ctx.addOriginResponseHeader("X-Zuul-Service", location);
  48.                 }
  50.                 if (this.properties.isAddProxyHeaders()) {
  51.                     this.addProxyHeaders(ctx, route);
  52.                     xforwardedfor = ctx.getRequest().getHeader("X-Forwarded-For");
  53.                     remoteAddr = ctx.getRequest().getRemoteAddr();
  54.                     if (xforwardedfor == null) {
  55.                         xforwardedfor = remoteAddr;
  56.                     } else if (!xforwardedfor.contains(remoteAddr)) {
  57.                         xforwardedfor = xforwardedfor + ", " + remoteAddr;
  58.                     }
  60.                     ctx.addZuulRequestHeader("X-Forwarded-For", xforwardedfor);
  61.                 }
  63.                 if (this.properties.isAddHostHeader()) {
  64.                     ctx.addZuulRequestHeader("Host", this.toHostHeader(ctx.getRequest()));
  65.                 }
  66.             }
  67.         } else {
  68.             log.warn("No route found for uri: " + requestURI);
  69.             xforwardedfor = this.dispatcherServletPath;
  70.             if (RequestUtils.isZuulServletRequest()) {
  71.                 log.debug("zuulServletPath=" + this.properties.getServletPath());
  72.                 location = requestURI.replaceFirst(this.properties.getServletPath(), "");
  73.                 log.debug("Replaced Zuul servlet path:" + location);
  74.             } else {
  75.                 log.debug("dispatcherServletPath=" + this.dispatcherServletPath);
  76.                 location = requestURI.replaceFirst(this.dispatcherServletPath, "");
  77.                 log.debug("Replaced DispatcherServlet servlet path:" + location);
  78.             }
  80.             if (!location.startsWith("/")) {
  81.                 location = "/" + location;
  82.             }
  84.             remoteAddr = xforwardedfor + location;
  85.             remoteAddr = remoteAddr.replaceAll("//", "/");
  86.             ctx.set("forward.to", remoteAddr);
  87.         }
  89.         return null;
  90.     }
  91. }
  94. ############# 分割线 ##################
  95. this.routeLocator.getMatchingRoute(requestURI) 是重点，根据请求的URL获取Route，再根据Route的location
  96. 是否http:、https:、forward: 前缀来设置属性。
  98. 例如访问 
  99. http://location:8080/service1/echo 
  100. -> Route(id='service1', fullPath='/service1/echo', path='/echo', location='service1', prefix='/service1')
  102. http://location:8080/github/echo
  103. -> Route(id='github', fullPath='/github/echo', path='/echo', location='https://github.com/', prefix='/github')

路由定位

PreDecorationFilter 中通过 RouteLocator 根据URL获取Route。
动态路由可以通过扩展 RouteLocator 来完成。

  1. public interface RouteLocator {
  2.       Collection<String> getIgnoredPaths();
  3.       List<Route> getRoutes();
  4.       Route getMatchingRoute(String path);
  5. }
  7. ### RouteLocator主要能力有： 根据path获取Route  和 获取所有的Route

相关类图
image.png

RefreshableRouteLocator

  1. public interface RefreshableRouteLocator extends RouteLocator {
  2.     void refresh();
  3. }

SimpleRouteLocator

简单的路由定位器，路由信息来自 ZuulProperties 属性配置类， locateRoutes() 是定位路由的核心，从 ZuulProperties 中加载路由数据。

  1.  protected Map<String, ZuulRoute> locateRoutes() {
  2.      // routesMap 存储路由信息
  3.      LinkedHashMap<String, ZuulRoute> routesMap = new LinkedHashMap();
  4.      Iterator var2 = this.properties.getRoutes().values().iterator();
  6.      // 查找路由信息
  7.      while(var2.hasNext()) {
  8.          ZuulRoute route = (ZuulRoute)var2.next();
  9.          routesMap.put(route.getPath(), route);
  10.      }
  12.      return routesMap;
  13.  }

DiscoveryClientRouteLocator

基于DiscoveryClient，路由数据来自 properties 中的静态配置和 DiscoveryClient 从注册中心获取的数据。
DiscoveryClientRouteLocator 拥有几个重要能力： 动态添加路由，刷新路由，获取路由信息（用途不大）

  1. public class DiscoveryClientRouteLocator extends SimpleRouteLocator implements RefreshableRouteLocator {
  3.     public DiscoveryClientRouteLocator(String servletPath, DiscoveryClient discovery, ZuulProperties properties, ServiceInstance localServiceInstance) {
  4.         super(servletPath, properties);
  5.         if (properties.isIgnoreLocalService() && localServiceInstance != null) {
  6.             String localServiceId = localServiceInstance.getServiceId();
  7.             if (!properties.getIgnoredServices().contains(localServiceId)) {
  8.                 properties.getIgnoredServices().add(localServiceId);
  9.             }
  10.         }
  12.         this.serviceRouteMapper = new SimpleServiceRouteMapper();
  13.         this.discovery = discovery;
  14.         this.properties = properties;
  15.     }
  18.     public void addRoute(String path, String location) {
  19.         this.properties.getRoutes().put(path, new ZuulRoute(path, location));
  20.         this.refresh();
  21.     }
  23.     public void addRoute(ZuulRoute route) {
  24.         this.properties.getRoutes().put(route.getPath(), route);
  25.         this.refresh();
  26.     }
  28.     protected LinkedHashMap<String, ZuulRoute> locateRoutes() {
  29.         LinkedHashMap<String, ZuulRoute> routesMap = new LinkedHashMap();
  30.         // 通过父类 SimpleRouteLocator获取静态路由信息
  31.         routesMap.putAll(super.locateRoutes());
  32.         LinkedHashMap values;
  33.         Iterator var3;
  34.         String path;
  35.         if (this.discovery != null) {
  36.             values = new LinkedHashMap();
  37.             var3 = routesMap.values().iterator();
  39.             while(var3.hasNext()) {
  40.                 ZuulRoute route = (ZuulRoute)var3.next();
  41.                 path = route.getServiceId();
  42.                 if (path == null) {
  43.                     path = route.getId();
  44.                 }
  46.                 if (path != null) {
  47.                     values.put(path, route);
  48.                 }
  49.             }
  50.             // 通过DiscoveryClient获取路由信息
  51.             List<String> services = this.discovery.getServices();
  52.             String[] ignored = (String[])this.properties.getIgnoredServices().toArray(new String[0]);
  53.             Iterator var13 = services.iterator();
  55.             while(var13.hasNext()) {
  56.                 String serviceId = (String)var13.next();
  57.                 String key = "/" + this.mapRouteToService(serviceId) + "/**";
  58.                 if (values.containsKey(serviceId) && ((ZuulRoute)values.get(serviceId)).getUrl() == null) {
  59.                     ZuulRoute staticRoute = (ZuulRoute)values.get(serviceId);
  60.                     if (!StringUtils.hasText(staticRoute.getLocation())) {
  61.                         staticRoute.setLocation(serviceId);
  62.                     }
  63.                 }
  65.                 if (!PatternMatchUtils.simpleMatch(ignored, serviceId) && !routesMap.containsKey(key)) {
  66.                     routesMap.put(key, new ZuulRoute(key, serviceId));
  67.                 }
  68.             }
  69.         }
  71.         if (routesMap.get("/**") != null) {
  72.             ZuulRoute defaultRoute = (ZuulRoute)routesMap.get("/**");
  73.             routesMap.remove("/**");
  74.             routesMap.put("/**", defaultRoute);
  75.         }
  77.         values = new LinkedHashMap();
  79.         Entry entry;
  80.         for(var3 = routesMap.entrySet().iterator(); var3.hasNext(); values.put(path, entry.getValue())) {
  81.             entry = (Entry)var3.next();
  82.             path = (String)entry.getKey();
  83.             if (!path.startsWith("/")) {
  84.                 path = "/" + path;
  85.             }
  87.             if (StringUtils.hasText(this.properties.getPrefix())) {
  88.                 path = this.properties.getPrefix() + path;
  89.                 if (!path.startsWith("/")) {
  90.                     path = "/" + path;
  91.                 }
  92.             }
  93.         }
  94.         return values;
  95.     }
  97.     // 刷新时会调用 locateRoute()
  98.     public void refresh() {
  99.         this.doRefresh();
  100.     }
  101. }
  103. 以service1为例，配置 /api/service1/** -> service1, 存储的路由信息为：
  104. /api/service1/** --> service1 # 根据静态路由配置生成的路由规则
  105. /service1/** --> service1  # 利用DiscoveryClient提取后根据默认规则生成的路由信息（用处不大）

CompositeRouteLocator

具备组合多个 RouteLocator 的能力，用 Collection 存储多个 RouteLocator ，调用 getRoutes() 、 getMatchingRoute() 、 refresh() 都会逐个调用每一个 RouteLocator 相应的方法。

  1. public class CompositeRouteLocator implements RefreshableRouteLocator {
  3.     private final Collection<? extends RouteLocator> routeLocators;
  4.     private ArrayList<RouteLocator> rl;
  6.     public CompositeRouteLocator(Collection<? extends RouteLocator> routeLocators) {
  7.         Assert.notNull(routeLocators, "'routeLocators' must not be null");
  8.         this.rl = new ArrayList(routeLocators);
  9.         AnnotationAwareOrderComparator.sort(this.rl);
  10.         this.routeLocators = this.rl;
  11.     }
  13.      public List<Route> getRoutes() {
  14.         List<Route> route = new ArrayList();
  15.         Iterator var2 = this.routeLocators.iterator();
  17.         while(var2.hasNext()) {
  18.             RouteLocator locator = (RouteLocator)var2.next();
  19.             route.addAll(locator.getRoutes());
  20.         }
  22.         return route;
  23.     }
  25.     public Route getMatchingRoute(String path) {
  26.         Iterator var2 = this.routeLocators.iterator();
  28.         Route route;
  29.         do {
  30.             if (!var2.hasNext()) {
  31.                 return null;
  32.             }
  34.             RouteLocator locator = (RouteLocator)var2.next();
  35.             route = locator.getMatchingRoute(path);
  36.         } while(route == null);
  38.         return route;
  39.     }
  41.     public void refresh() {
  42.         Iterator var1 = this.routeLocators.iterator();
  44.         while(var1.hasNext()) {
  45.             RouteLocator locator = (RouteLocator)var1.next();
  46.             if (locator instanceof RefreshableRouteLocator) {
  47.                 ((RefreshableRouteLocator)locator).refresh();
  48.             }
  49.         }
  51.     }
  52. }

Zuul动态路由实现

数据表实现

  1. id  | path  | service_id  | url | retryable | enable  | strip_prefix  | api_name
  2. 主键  路径      服务名称      url   可重试       是否可用    带前缀         接口名称
  5. CREATE TABLE `gateway_api_route` (
  6.    `id` varchar(50) NOT NULL,
  7.    `path` varchar(255) NOT NULL,
  8.    `service_id` varchar(50) DEFAULT NULL,
  9.    `url` varchar(255) DEFAULT NULL,
  10.    `retryable` tinyint(1) DEFAULT NULL,
  11.    `enabled` tinyint(1) NOT NULL,
  12.    `strip_prefix` int(11) DEFAULT NULL,
  13.    `api_name` varchar(255) DEFAULT NULL,
  14.    PRIMARY KEY (`id`)
  15.  ) ENGINE=InnoDB DEFAULT CHARSET=utf8
  17. INSERT INTO gateway_api_route (id, path, service_id, retryable, strip_prefix, url, enabled) 
  18. VALUES ('order-service', '/order/**', 'order-service',0,1, NULL, 1);

异步路由定位器

  1. import org.springframework.beans.BeanUtils;
  2. import org.springframework.cloud.netflix.zuul.filters.RefreshableRouteLocator;
  3. import org.springframework.cloud.netflix.zuul.filters.SimpleRouteLocator;
  4. import org.springframework.cloud.netflix.zuul.filters.ZuulProperties;
  5. import org.springframework.jdbc.core.BeanPropertyRowMapper;
  6. import org.springframework.jdbc.core.JdbcTemplate;
  7. import org.springframework.util.StringUtils;
  9. import java.util.LinkedHashMap;
  10. import java.util.List;
  11. import java.util.Map;
  13. public class DynamicRouteLocator extends SimpleRouteLocator implements RefreshableRouteLocator {
  15.     private JdbcTemplate jdbcTemplate;
  16.     private ZuulProperties properties;
  18.     public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
  19.         this.jdbcTemplate = jdbcTemplate;
  20.     }
  22.     public DynamicRouteLocator(String servletPath, ZuulProperties properties) {
  23.         super(servletPath, properties);
  24.         this.properties = properties;
  25.     }
  27.     @Override
  28.     public void refresh() {
  29.         doRefresh();
  30.     }
  32.     @Override
  33.     protected Map<String, ZuulProperties.ZuulRoute> locateRoutes() {
  34.         LinkedHashMap<String, ZuulProperties.ZuulRoute> routesMap = new LinkedHashMap<>();
  35.         // 加载application.yml中的路由表
  36.         routesMap.putAll(super.locateRoutes());
  37.         // 加载db中的路由表
  38.         routesMap.putAll(locateRoutesFromDB());
  40.         // 统一处理一下路由path的格式
  41.         LinkedHashMap<String, ZuulProperties.ZuulRoute> values = new LinkedHashMap<>();
  42.         for (Map.Entry<String, ZuulProperties.ZuulRoute> entry : routesMap.entrySet()) {
  43.             String path = entry.getKey();
  44.             if (!path.startsWith("/")) {
  45.                 path = "/" + path;
  46.             }
  47.             if (StringUtils.hasText(this.properties.getPrefix())) {
  48.                 path = this.properties.getPrefix() + path;
  49.                 if (!path.startsWith("/")) {
  50.                     path = "/" + path;
  51.                 }
  52.             }
  53.             values.put(path, entry.getValue());
  54.         }
  56.         System.out.println("路由表：" + values); 
  58.         return values;
  59.     }
  61.     private Map<String, ZuulProperties.ZuulRoute> locateRoutesFromDB() {
  62.         // routesMap 存储路由信息
  63.         Map<String, ZuulProperties.ZuulRoute> routes = new LinkedHashMap<>();
  65.         // 从数据表里获取启用的路由服务
  66.         List<GatewayApiRoute> results = jdbcTemplate.query(
  67.                 "select * from gateway_api_route where enabled = true ", 
  68.                 new BeanPropertyRowMapper<>(GatewayApiRoute.class));
  70.         for (GatewayApiRoute result : results) {
  71.             if (StringUtils.isEmpty(result.getPath()) ) {
  72.                 continue;
  73.             }
  74.             if (StringUtils.isEmpty(result.getServiceId()) && StringUtils.isEmpty(result.getUrl())) {
  75.                 continue;
  76.             }
  77.             ZuulProperties.ZuulRoute zuulRoute = new ZuulProperties.ZuulRoute();
  78.             try {
  79.                 BeanUtils.copyProperties(result, zuulRoute);
  80.             } catch (Exception e) { 
  81.                 e.printStackTrace();
  82.             }
  83.             routes.put(zuulRoute.getPath(), zuulRoute);
  84.         }
  86.         return routes;
  87.     }
  89. }
  1. public class GatewayApiRoute {
  2.     private String id;
  3.     private String path;
  4.     private String serviceId;
  5.     private String url;
  6.     private boolean stripPrefix = true;
  7.     private Boolean retryable;
  8.     private Boolean enabled;
  9. }
  1. @Configuration
  2. public class DynamicRouteConfiguration {
  4.     @Autowired
  5.     private ZuulProperties zuulProperties;
  6.     @Autowired
  7.     private ServerProperties server;
  8.     @Autowired
  9.     private JdbcTemplate jdbcTemplate;
  11.     @Bean
  12.     public DynamicRouteLocator routeLocator() {
  13.         DynamicRouteLocator routeLocator = new DynamicRouteLocator(
  14.                 this.server.getServletPrefix(), this.zuulProperties);
  15.         routeLocator.setJdbcTemplate(jdbcTemplate);
  16.         return routeLocator;
  17.     }
  19. }

定时刷新路由信息

  1. import org.springframework.beans.factory.annotation.Autowired;
  2. import org.springframework.cloud.netflix.zuul.RoutesRefreshedEvent;
  3. import org.springframework.cloud.netflix.zuul.filters.RouteLocator;
  4. import org.springframework.context.ApplicationEventPublisher;
  5. import org.springframework.context.annotation.Configuration;
  6. import org.springframework.scheduling.annotation.EnableScheduling;
  7. import org.springframework.scheduling.annotation.Scheduled;
  8. import org.springframework.stereotype.Component;
  10. @Component
  11. @Configuration      
  12. @EnableScheduling   
  13. public class RefreshRouteTask {
  15.     @Autowired
  16.     private ApplicationEventPublisher publisher;
  17.     @Autowired
  18.     private RouteLocator routeLocator;
  20.     @Scheduled(fixedRate = 5000) 
  21.     private void refreshRoute() {
  22.         System.out.println("定时刷新路由表");  
  23.         RoutesRefreshedEvent routesRefreshedEvent = new RoutesRefreshedEvent(routeLocator);
  24.         publisher.publishEvent(routesRefreshedEvent);
  25.     }
  26. }