Sringcloud 微服务zuul动态获取路由---多服务节点实现负载均衡（eureka）熔断器

实现负载均衡策略

1：使用eureka则不同的服务节点application name需要一致 如：spring.application.name=active-service ，因为zuul 和服务在启动的时候都会向eureka进行注册，所有根据这个服务节点就可以找到对应的服务节点，然后综合下面的zuul动态路由即可实现负载均衡。
2：不使用eureka，则需要一张表来记录服务节点，在zuul启动的时，查询表数据，加载服务节点。综合zuul动态路由即可实现负载均衡，如下

// 服务节点配置在数据库，使用此sql进行查询
    private static final String  SQL = "select id, service_type, service_url from rx_service_node where enabled = 0";
    // 服务节点类型 {service-app, service-org, service-otr, service-sidecar, service-oauth}
    private static final String SERVICE_APP = "demo-service";

    @Autowired
    private JdbcTemplate jdbcTemplate;

    public void refreshRibbon() {

        List<String> LIST_SERVERS_APP = new ArrayList<>();
        List<ServiceNode> serviceNodes = jdbcTemplate.query(SQL, new BeanPropertyRowMapper<>(ServiceNode.class));
        String serviceType;
        String serviceUrl;
        for(ServiceNode serviceNode : serviceNodes) {
            serviceType = serviceNode.getServiceType();
            serviceUrl = serviceNode.getServiceUrl();
            if(SERVICE_APP.equals(serviceType)) {
                LIST_SERVERS_APP.add(serviceUrl);
            }
        }

        createRibbonClient(SERVICE_APP, LIST_SERVERS_APP.isEmpty() ? "" : StringUtils.join(LIST_SERVERS_APP, ","));
    }

    public static void createRibbonClient(String CLIENT_ID, String LIST_SERVERS){
        // 设置：配置项 (ribbon 会读取此配置)
        // 根据 archaius 动态配置的特性 ， 服务列表更新时只需重新赋值即可
        ConfigurationManager.getConfigInstance().setProperty(CLIENT_ID + ".ribbon.listOfServers", LIST_SERVERS);


        // 负载均衡服务
        DynamicServerListLoadBalancer serverListLoadBalancer = (DynamicServerListLoadBalancer) ClientFactory.getNamedLoadBalancer(CLIENT_ID);

        // 负载均衡规则，改为随机
        serverListLoadBalancer.setRule(new RandomRule());

        // Ribbon的实例检查策略，默认为com.netflix.loadbalancer.NoOpPing,实际上并不会检查，而是直接返回true，默认实例都是可用的
        serverListLoadBalancer.setPing(new NoOpPing());

    }

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

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  
package com.tianyalei.testzuul.config;  
  
import org.slf4j.Logger;  
import org.slf4j.LoggerFactory;  
import org.springframework.beans.BeanUtils;  
import org.springframework.cloud.netflix.zuul.filters.RefreshableRouteLocator;  
import org.springframework.cloud.netflix.zuul.filters.SimpleRouteLocator;  
import org.springframework.cloud.netflix.zuul.filters.ZuulProperties;  
import org.springframework.jdbc.core.BeanPropertyRowMapper;  
import org.springframework.jdbc.core.JdbcTemplate;  
import org.springframework.util.StringUtils;  
  
import java.util.LinkedHashMap;  
import java.util.List;  
import java.util.Map;  
  
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;  
        logger.info("servletPath:{}", servletPath);  
    }  
  
    //父类已经提供了这个方法，这里写出来只是为了说明这一个方法很重要！！！  
//    @Override  
//    protected void doRefresh() {  
//        super.doRefresh();  
//    }  
  
  
    @Override  
    public void refresh() {  
        doRefresh();  
    }  
  
    @Override  
    protected Map<String, ZuulProperties.ZuulRoute> locateRoutes() {  
        LinkedHashMap<String, ZuulProperties.ZuulRoute> routesMap = new LinkedHashMap<>();  
        //从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();  
            // 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 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;  
        }  
    }  
}  


[java] view plain copy  
package com.tianyalei.testzuul.config;  
  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.boot.autoconfigure.web.ServerProperties;  
import org.springframework.cloud.netflix.zuul.filters.ZuulProperties;  
import org.springframework.context.annotation.Bean;  
import org.springframework.context.annotation.Configuration;  
import org.springframework.jdbc.core.JdbcTemplate;  
  
@Configuration  
public class CustomZuulConfig {  
  
    @Autowired  
    ZuulProperties zuulProperties;  
    @Autowired  
    ServerProperties server;  
    @Autowired  
    JdbcTemplate jdbcTemplate;  
  
    @Bean  
    public CustomRouteLocator routeLocator() {  
        CustomRouteLocator routeLocator = new CustomRouteLocator(this.server.getServletPrefix(), this.zuulProperties);  
        routeLocator.setJdbcTemplate(jdbcTemplate);  
        return routeLocator;  
    }  
  
}

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

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

建表语句：

[html] view plain copy

create table `gateway_api_define` (  
  `id` varchar(50) not null,  
  `path` varchar(255) not null,  
  `service_id` varchar(50) default null,  
  `url` varchar(255) default null,  
  `retryable` tinyint(1) default null,  
  `enabled` tinyint(1) not null,  
  `strip_prefix` int(11) default null,  
  `api_name` varchar(255) default null,  
  primary key (`id`)  
) engine=innodb default charset=utf8  

INSERT INTO gateway_api_define (id, path, service_id, retryable, strip_prefix, url, enabled) VALUES ('user', '/user/**', null,0,1, 'http://localhost:8081', 1);  
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  
package com.tianyalei.testzuul.config;  
  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.cloud.netflix.zuul.RoutesRefreshedEvent;  
import org.springframework.cloud.netflix.zuul.filters.RouteLocator;  
import org.springframework.context.ApplicationEventPublisher;  
import org.springframework.stereotype.Service;  
  
@Service  
public class RefreshRouteService {  
    @Autowired  
    ApplicationEventPublisher publisher;  
  
    @Autowired  
    RouteLocator routeLocator;  
  
    public void refreshRoute() {  
        RoutesRefreshedEvent routesRefreshedEvent = new RoutesRefreshedEvent(routeLocator);  
        publisher.publishEvent(routesRefreshedEvent);  
    }  
}  
可以定义一个Controller，在Controller里调用refreshRoute方法即可，zuul就会重新加载一遍路由信息，完成刷新功能。通过修改数据库，然后刷新，经测试是正常的。
[java] view plain copy  
@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模式看里面具体是什么  
        Map<String, Object> handlerMap = zuulHandlerMapping.getHandlerMap();  
        return handlerMap;  
    }  
  
}  

熔断器 zuul都封装好主要实现接口即可

 /**
     * getRoute方法的返回值就是要监听的挂掉的微服务的名字
     * 如果需要所有服务都走这个熔断回退，则return "*" 或 return null
     *
     * @return
     */
    @Override
    public String getRoute() {
        return "*";
    }

    /**
     * 当服务无法执行的时候，返回托底信息
     *
     * @param route
     * @param cause
     * @return
     */
    @Override
    public ClientHttpResponse fallbackResponse(String route, Throwable cause) {
        logger.info("--> route:{}进行熔断降级", route);
        return new ClientHttpResponse() {

            /**
             * ClientHttpResponse的fallback的状态码
             * @return
             * @throws IOException
             */
            @Override
            public HttpStatus getStatusCode() throws IOException {
                return HttpStatus.OK;
            }

            /**
             * ClientHttpResponse的fallback的状态码
             * @return
             * @throws IOException
             */
            @Override
            public int getRawStatusCode() throws IOException {
                return this.getStatusCode().value();
            }

            /**
             * ClientHttpResponse的fallback的状态码
             * @return
             * @throws IOException
             */
            @Override
            public String getStatusText() throws IOException {
                return this.getStatusCode().getReasonPhrase();
            }

            /**
             * Close this response, freeing any resources created.
             */
            @Override
            public void close() {

            }

            /**
             * 设置响应体
             * @return
             * @throws IOException
             */
            @Override
            public InputStream getBody() throws IOException {
                String content = "商品服务不可用，请与管理员联系";
                return new ByteArrayInputStream(content.getBytes());
            }

            /**
             * 设置响应头信息
             * @return
             */
            @Override
            public HttpHeaders getHeaders() {
                HttpHeaders headers = new HttpHeaders();
                MediaType mt = new MediaType("application", "json", Charset.forName("utf-8"));
                headers.setContentType(mt);

                return headers;
            }
        };
    }

记录下，点点滴滴，分享给大家，有问题可以咨询，亲测可用