前言

ribbon是Netflix開源的用戶端負載均衡工具，ribbon實作一系列的負載均衡算法，通過這些負載均衡算法去查找相應的服務。ribbon被大家所熟知，可能是來源于spring cloud，今天就來聊聊如何單獨使用ribbon來實作業務用戶端負載均衡

實作關鍵

springcloud ribbon擷取服務清單是通過注冊中心，而單獨使用ribbon，因為沒有注冊中心加持，就得單獨配置服務清單

示例

1、在業務項目中pom引入ribbon GAV

<dependency>
    <groupId>com.netflix.ribbon</groupId>
    <artifactId>ribbon</artifactId>
    <version>2.2.2</version>
</dependency>

不過引進去，發現如果引入netfiix的相關的類，比如IPing，會發現引不進去，原因是因為這個GAV裡面依賴的jar的生命周期是runtime，即在運作期或者測試階段才生效，在編譯階段是不生效的。如果我們為了友善，可以直接單獨引入

spring cloud ribbon

<dependency>
           <groupId>org.springframework.cloud</groupId>-->
            <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>-->
           <version>2.2.2.RELEASE</version>
    </dependency>

本文我們是想脫離springcloud，直接使用ribbon，是以我們可以直接引入如下GAV

<!--  核心的通用性代碼-->
        <dependency>
            <groupId>com.netflix.ribbon</groupId>
            <artifactId>ribbon-core</artifactId>
            <version>${ribbon.version}</version>
        </dependency>
        <!-- 基于apache httpClient封裝的rest用戶端，內建了負載均衡子產品，内嵌http心跳檢測-->
        <dependency>
            <groupId>com.netflix.ribbon</groupId>
            <artifactId>ribbon-httpclient</artifactId>
            <version>${ribbon.version}</version>
        </dependency>
        <!-- 負載均衡子產品-->
        <dependency>
            <groupId>com.netflix.ribbon</groupId>
            <artifactId>ribbon-loadbalancer</artifactId>
            <version>${ribbon.version}</version>
        </dependency>

        <!-- IClientConfig配置相關-->
        <dependency>
            <groupId>com.netflix.archaius</groupId>
            <artifactId>archaius-core</artifactId>
            <version>0.7.6</version>
        </dependency>

        <!-- IClientConfig配置相關-->
        <dependency>
            <groupId>commons-configuration</groupId>
            <artifactId>commons-configuration</artifactId>
            <version>1.8</version>
        </dependency>

2、建立ribbon中繼資料配置類

@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class RuleDefinition {

    /**
     * 服務名稱
     */
    private String serviceName;

    /**
     * 命名空間，當服務名相同時，可以通過namesapce來進行隔離區分
     * 未指定預設為public
     */
    @Builder.Default
    private String namespace = DEFAULT_NAMESPACE;

    /**
     * 自定義負載均衡政策，未指定預設為輪詢
     */
    @Builder.Default
    private String loadBalancerRuleClassName = RoundRobin;

    /**
     * 自定義心跳檢測，未指定不檢測
     */
    @Builder.Default
    private String loadBalancerPingClassName = DummyPing;

    /**
     * 服務清單，多個用英文逗号隔開
     */
    private String listOfServers;


    /**
     * 該優先級大于loadBalancerPingClassName
     */
    private IPing ping;

    /**
     * 心跳間隔，不配置預設是10秒，機關秒
     */
    private int pingIntervalSeconds;


    /**
     * 該優先級大于loadBalancerRuleClassName
     */
    private IRule rule;



}

@Data
@AllArgsConstructor
@NoArgsConstructor
@ConfigurationProperties(prefix = PREFIX)
public class LoadBalanceProperty {

    public static final String PREFIX = "lybgeek.loadbalance";

    private List<RuleDefinition> rules;

    public Map<String,RuleDefinition> getRuleMap(){
        if(CollectionUtils.isEmpty(rules)){
            return Collections.emptyMap();
        }

        Map<String,RuleDefinition> ruleDefinitionMap = new LinkedHashMap<>();
        for (RuleDefinition rule : rules) {
            String key = rule.getServiceName() + RULE_JOIN + rule.getNamespace();
            ruleDefinitionMap.put(key,rule);
        }

        return Collections.unmodifiableMap(ruleDefinitionMap);
    }
}

3、建立負載均衡工廠【核心實作】

private final LoadBalanceProperty loadBalanceProperty;

    // key:serviceName + nameSpace
    private static final Map<String, ILoadBalancer> loadBalancerMap = new ConcurrentHashMap<>();

    public ILoadBalancer getLoadBalancer(String serviceName,String namespace){
        String key = serviceName + RULE_JOIN + namespace;
        if(loadBalancerMap.containsKey(key)){
            return loadBalancerMap.get(key);
        }
        RuleDefinition ruleDefinition = getAvailableRuleDefinition(serviceName,namespace);
        IPing ping = ruleDefinition.getPing();
        if(ObjectUtils.isEmpty(ping)){
            // 無法通過ConfigurationManager.getConfigInstance().setProperty(serviceName + DOT + namespace + DOT + PING_CLASS_NAME, ruleDefinition.getLoadBalancerPingClassName());
            //LoadBalancerBuilder沒提供通過ClientConfig配置ping方法，隻能通過withPing修改
            ping = getPing(serviceName,namespace);
        }

        IRule rule = ruleDefinition.getRule();
        if(ObjectUtils.isEmpty(rule)){
            // 也可以通過ConfigurationManager.getConfigInstance().setProperty(serviceName + DOT + namespace + DOT + RULE_CLASS_NAME, ruleDefinition.getLoadBalancerRuleClassName());
            rule = getRule(serviceName,namespace);
        }


        // 配置服務清單
        ConfigurationManager.getConfigInstance().setProperty(serviceName + DOT + namespace + DOT + SERVER_LIST, ruleDefinition.getListOfServers());
        // 因為服務清單目前是配置寫死，是以關閉清單更新，否則當觸發定時更新時，會重新将服務清單狀态恢複原樣,這樣會導緻server的isLive狀态不準确
        // 不設定預設采用com.netflix.loadbalancer.PollingServerListUpdater
        ConfigurationManager.getConfigInstance().setProperty(serviceName + DOT + namespace + DOT + SERVERLIST_UPDATER_CLASS_NAME, EmptyServerListUpdater.class.getName());
        IClientConfig config = new DefaultClientConfigImpl(namespace);
        config.loadProperties(serviceName);
        ZoneAwareLoadBalancer<Server> loadBalancer = getLoadBalancer(config, ping, rule);
        loadBalancerMap.put(key,loadBalancer);
        if(ruleDefinition.getPingIntervalSeconds() > 0){
            // 預設每隔10秒進行心跳檢測
            loadBalancer.setPingInterval(ruleDefinition.getPingIntervalSeconds());
        }

        return loadBalancer;


    }



    public ZoneAwareLoadBalancer<Server> getLoadBalancer(IClientConfig config, IPing ping, IRule rule){
        ZoneAwareLoadBalancer<Server> serverZoneAwareLoadBalancer = LoadBalancerBuilder.newBuilder()
                .withClientConfig(config)
                .withPing(ping)
                .withRule(rule)
                .buildDynamicServerListLoadBalancerWithUpdater();
        return serverZoneAwareLoadBalancer;
    }






    /**
     * 擷取 iping
     * @param serviceName
     * @param namespace
     * @return
     */
    @SneakyThrows
    public IPing getPing(String serviceName, String namespace){
        RuleDefinition ruleDefinition = getAvailableRuleDefinition(serviceName,namespace);
        Class<?> loadBalancerPingClass = ClassUtils.forName(ruleDefinition.getLoadBalancerPingClassName(), Thread.currentThread().getContextClassLoader());
        Assert.isTrue(IPing.class.isAssignableFrom(loadBalancerPingClass),String.format("loadBalancerPingClassName : [%s] is not Iping class type",ruleDefinition.getLoadBalancerPingClassName()));
        return (IPing) BeanUtils.instantiateClass(loadBalancerPingClass);


    }

    /**
     * 擷取 loadbalanceRule
     * @param serviceName
     * @param namespace
     * @return
     */
    @SneakyThrows
    public IRule getRule(String serviceName, String namespace){
        RuleDefinition ruleDefinition = getAvailableRuleDefinition(serviceName,namespace);
        Class<?> loadBalancerRuleClass = ClassUtils.forName(ruleDefinition.getLoadBalancerRuleClassName(), Thread.currentThread().getContextClassLoader());
        Assert.isTrue(IRule.class.isAssignableFrom(loadBalancerRuleClass),String.format("loadBalancerRuleClassName : [%s] is not Irule class type",ruleDefinition.getLoadBalancerRuleClassName()));
        return (IRule) BeanUtils.instantiateClass(loadBalancerRuleClass);

    }

    private RuleDefinition getAvailableRuleDefinition(String serviceName,String namespace){
        Map<String, RuleDefinition> ruleMap = loadBalanceProperty.getRuleMap();
        Assert.notEmpty(ruleMap,"ruleDefinition is empty");
        String key = serviceName + RULE_JOIN + namespace;
        RuleDefinition ruleDefinition = ruleMap.get(key);
        Assert.notNull(ruleDefinition,String.format("NOT FOUND AvailableRuleDefinition with serviceName : [{}] in namespace:[{}]",serviceName,namespace));
        return ruleDefinition;
    }

核心實作類：com.netflix.loadbalancer.LoadBalancerBuilder 利用該類建立相應的負載均衡

4、測試

a、新起2個服務提供者占用6666端口、和6667端口

b、在消費端的application.yml配置如下内容

lybgeek:
  loadbalance:
    rules:
      - serviceName: provider
        namespace: test
        loadBalancerPingClassName: com.github.lybgeek.loadbalance.ping.TelnetPing
        pingIntervalSeconds: 3
     #   loadBalancerRuleClassName: com.github.lybgeek.loadbalance.rule.CustomRoundRobinRule
        listOfServers: 127.0.0.1:6666,127.0.0.1:6667

c、測試類

@Override
    public void run(ApplicationArguments args) throws Exception {

        ServerChooser serverChooser = ServerChooser.builder()
                .loadBalancer(loadbalanceFactory.getLoadBalancer("provider", "test"))
                .build();

        while(true){
            Server reachableServer = serverChooser.getServer("provider");
            if(reachableServer != null){
                System.out.println(reachableServer.getHostPort());
            }
            TimeUnit.SECONDS.sleep(1);

        }


    }

當服務提供者都正常提供服務時，觀察控制台

可以觀察以輪詢的方式調用服務提供者，當斷掉其中一台服務提供者時，再觀察控制台

會發現隻調用服務正常的那台

總結

獨立使用ribbon其實不會很難，主要對LoadBalancerBuilder這個API熟悉就可以定制自己想要的負載均衡器。springcloud從2020版本就将ribbon廢棄了，轉而要扶持其親兒子loadbalancer，就目前功能而言，loadbalancer還沒ribbon豐富，通過本文紀念一下被springcloud遺棄的ribbon

demo連結

https://github.com/lyb-geek/springboot-learning/tree/master/springboot-ribbon-loadbalance

聊聊如何獨立使用ribbon實作業務用戶端負載均衡

前言

實作關鍵

示例

總結

demo連結

繼續閱讀

從入門到精通：負載均衡技術全攻略

詳談群集計劃與負載均衡

DNS負載均衡技術－同一個域名對應多個ip的方法

Kafka：Producer自定義Partition負載均衡

centos上利用nginx配置tomcat負載均衡

NGINX_TOMCAT 負載均衡配置

我對SOA的認識以及心得

企業級負載均衡解決方案之六：UCloud四層負載均衡解決方案Vortex

配置ipvsadm服務

裸眼3D技術原理及單晶片解決方案

PHP工程師面臨成長瓶頸

cisco交換機指令彙總

Oracle實作高可用性的工具（負載均衡/故障切換）

2.6核心netfilter包截獲

SpringCloud微服務（四）之ribbon筆記ribbon是什麼？入門案例自定義均衡負載算法

nginx location中斜線的位置的重要性