springcloud-gateway-自定义ribbon策略本机服务优先

问题

springcloud服务化经常遇到的问题，本机开发的代码在测试环境需要联调时，由于注册中心有其它同学也正在开发此服务，此时就需要优先调用本机的服务已完成测试。如果本机没有服务应该优先测试服务器上的稳定服务优先。

解决方案

通过自定义ribbon策略实现本机优先，稳定服务优先

ribbon代码

package tmp.eureka.server.server.conf;

import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import com.netflix.client.config.IClientConfig;
import com.netflix.loadbalancer.BestAvailableRule;
import com.netflix.loadbalancer.ILoadBalancer;
import com.netflix.loadbalancer.Server;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.commons.util.InetUtils;
import org.springframework.cloud.commons.util.InetUtilsProperties;
import org.springframework.context.annotation.Configuration;

import java.net.InetAddress;
import java.util.List;
import java.util.Random;

/**
 * @program: gateway
 * @description:
 * @author: zhoupengfei
 * @create: 2019-08-16 17:15
 **/
@Slf4j
@Configuration
public class IpUserHashRule extends BestAvailableRule {

    public static ThreadLocal<String> originHost=new ThreadLocal<>();
    public static  String originHostHeader="originHost";
    public static  String stable="stable";
    public static String dev;

    public Server choose(ILoadBalancer lb, Object key) {
        log.info("步骤2");
        if (lb == null) {
            log.warn("no load balancer");
            return null;
        }
        Server server = null;
        List<Server> reachableServers = lb.getReachableServers();

        if(reachableServers==null ||reachableServers.size()==0){
            log.warn("没有可用的服务");
            return null;
        }
        // 优先找和访问ip同源的服务
        if(originHost.get()!=null){
            //自定义策略生效
            for(Server serverl:reachableServers){
                if(serverl.getHost().equals(originHost.get())){
                    server=serverl;
                    log.info("host{},server{}",server.getHost(),JSONUtil.toJsonStr(server));
                    return  server;
                }
            }
        }
        //通过注册信息-找稳定的服务
        for(Server s:reachableServers){
            if(s.getMetaInfo()!=null){
                String meta=JSONUtil.toJsonStr(s);
               // log.info(meta);
                JSONObject metadata=JSONUtil.parseObj(meta).getJSONObject("instanceInfo").getJSONObject("metadata");
                if(metadata!=null && metadata.get(stable)!=null){
                    server=s;
                    log.info("host{},server{}",server.getHost(),JSONUtil.toJsonStr(server));
                    return  server;
                }
            }

        }

        //随机一个服务
        Random random=new Random();
        int index=reachableServers.size();
        server=reachableServers.get(random.nextInt(index));
        log.info("host{},server{}",server.getHost(),JSONUtil.toJsonStr(server));
        return  server;
    }
    @Override
    public Server choose(Object key) {
        return choose(getLoadBalancer(), key);
    }

    @Override
    public void initWithNiwsConfig(IClientConfig clientConfig) {
        // TODO Auto-generated method stub

    }


    public static void main(String[] args) {
        InetUtilsProperties target = new InetUtilsProperties();
        InetUtils ipUtils=new InetUtils(target);
        InetAddress address=ipUtils.findFirstNonLoopbackAddress();
        log.info(JSONUtil.toJsonStr(address.getCanonicalHostName()));
    }
}

通过过滤器拿到请求的host

package tmp.eureka.server.server.conf;
import static org.springframework.cloud.gateway.support.ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR;

import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.cloud.gateway.config.LoadBalancerProperties;
import org.springframework.cloud.gateway.filter.LoadBalancerClientFilter;
import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancerClient;
import org.springframework.http.HttpHeaders;
import org.springframework.web.server.ServerWebExchange;

import java.net.URI;
import java.util.List;

/**
 * @program: gateway
 * @description:
 * @author: zhoupengfei
 * @create: 2019-08-16 18:05
 **/
@Slf4j
public class UserLoadBalancerClientFilter extends LoadBalancerClientFilter {

    public  static  ThreadLocal<ServerWebExchange> exchange=new ThreadLocal<>();
    public UserLoadBalancerClientFilter(LoadBalancerClient loadBalancer, LoadBalancerProperties properties) {
        super(loadBalancer, properties);
    }

    @Override
    protected ServiceInstance choose(ServerWebExchange exchange) {
        //这里可以拿到web请求的上下文，可以从header中取出来自己定义的数据。
        String userId = exchange.getRequest().getHeaders().getFirst("userId");
        UserLoadBalancerClientFilter.exchange.set(exchange);
        log.info("步骤1");
        if(IpUserHashRule.originHost.get()==null){
            //IpUserHashRule.originHostHeader
            HttpHeaders httpHeaders=exchange.getRequest().getHeaders();
            List<String> originHostHeader=httpHeaders.get(IpUserHashRule.originHostHeader);
            if(originHostHeader==null || originHostHeader.size()==0 ){
                String host=exchange.getRequest().getURI().getHost();
                //设置请求头
                //httpHeaders.set(IpUserHashRule.originHostHeader,host);
                exchange.getRequest().mutate().header(IpUserHashRule.originHostHeader,host).build();
                IpUserHashRule.originHost.set(host);
            }else{
                IpUserHashRule.originHost.set(originHostHeader.get(0));
            }
        }
        if (this.loadBalancer instanceof RibbonLoadBalancerClient) {
            RibbonLoadBalancerClient client = (RibbonLoadBalancerClient) this.loadBalancer;
            String serviceId = ((URI) exchange.getAttribute(GATEWAY_REQUEST_URL_ATTR)).getHost();
            //这里使用userId做为选择服务实例的key
            return client.choose(serviceId, userId);
        }
        return super.choose(exchange);
    }

}

配置

package tmp.eureka.server.server.conf;

import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.cloud.gateway.config.LoadBalancerProperties;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.annotation.Order;
import org.springframework.web.client.RestTemplate;
import reactor.core.publisher.Mono;


/**
 * @program: gateway
 * @description:
 * @author: zhoupengfei
 * @create: 2019-08-16 17:10
 **/
@Configuration
@Slf4j
public class GlobalGatewayFilterConfig {
    @Bean
    @Order(-100)
    public GlobalFilter elapsedGlobalFilter() {
        return (exchange, chain) -> {
            //调用请求之前统计时间
            Long startTime = System.currentTimeMillis();
            return chain.filter(exchange).then().then(Mono.fromRunnable(() -> {
                //调用请求之后统计时间
                Long endTime = System.currentTimeMillis();
                log.info(exchange.getRequest().getURI().getRawPath() + ", cost time : " + (endTime - startTime) + "ms");
            }));
        };
    }
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }

    @Bean
    public UserLoadBalancerClientFilter userLoadBalanceClientFilter(LoadBalancerClient client, LoadBalancerProperties properties) {
        return new UserLoadBalancerClientFilter(client, properties);
    }
}

本机代码 模拟稳定服务

增加启动参数

--eureka.instance.metadata-map.stable=true

修改配置文件

eureka:
  client:
  instance:
    metadata-map:
      stable: true

未完待续 服务之间调用保证本机优先，通过springmvc拦截器获取host。