負載均衡框架 ribbon 三

阿新 • • 發佈：2018-12-05

Ribbon 在 SpringCloud 中的使用

1.構建 Eureka 註冊中心 smart-platform-eureka1

（1）匯入jar包

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

  <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>2.0.2.RELEASE</version>
  </parent>

  <dependencyManagement>
      <dependencies>
         <dependency>
             <groupId>org.springframework.cloud</groupId>
             <artifactId>spring-cloud-dependencies</artifactId>
             <version>Finchley.SR2</version>
             <type>pom</type>
             <scope>import 
</scope>
         </dependency>
     </dependencies>
  </dependencyManagement>

  <dependencies>
      <dependency>
         <groupId>org.springframework.cloud</groupId>
         <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
      </dependency>
  </dependencies>

  <build>
    <pluginManagement>
      <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>                                   
                <fork>true 
</fork>
                <addResources>true</addResources>
            </configuration>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>

（2）新增eureka配置 application.yml

server:
  port: 8761
spring:
  application:
    name: smart 
-platform-eureka1
eureka:
  instance:
    hostname: localhost
  client:
    registerWithEureka: false
    fetchRegistry: false
    serviceUrl:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
  server:
    #eureka服務自我保護模式 預設是開啟的
    enable-self-preservation: true
    #eureka服務 指定時間清理死掉的服務 預設60秒 單位毫秒
    eviction-interval-timer-in-ms: 60000

(3) 編寫啟動類

import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

/**
 * eureka註冊中心服務
 */
@SpringBootApplication
@EnableEurekaServer
public class Application {
    public static void main( String[] args) throws Exception{
        new SpringApplicationBuilder(Application.class).run(args);
    }
}

2.構建生產者服務 smart-platform-base

（1）匯入jar包

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

  <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>2.0.2.RELEASE</version>
  </parent>

  <dependencyManagement>
      <dependencies>
         <dependency>
             <groupId>org.springframework.cloud</groupId>
             <artifactId>spring-cloud-dependencies</artifactId>
             <version>Finchley.SR2</version>
             <type>pom</type>
             <scope>import</scope>
         </dependency>
     </dependencies>
  </dependencyManagement>

  <dependencies>
      <dependency>
         <groupId>org.springframework.cloud</groupId>
         <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>

  </dependencies>

  <build>
    <pluginManagement>
      <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>                                   
                <fork>true</fork>
                <addResources>true</addResources>
            </configuration>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>

(2) 編寫介面

public class User {
    private int id;
    private String userName;
    private String sex;
    private int age;
    private String createTime;
    private String message;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getCreateTime() {
        return createTime;
    }

    public void setCreateTime(String createTime) {
        this.createTime = createTime;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

@RestController
@RequestMapping(value = "/platform/base")
public class TestController {
   
    @GetMapping(value = "/getUser")
    public User getUser(HttpServletRequest request){
        User user = new User();
        user.setId(1);
        user.setUserName("delan");
        user.setAge(5);
        user.setMessage(request.getRequestURL().toString());
        return user;
    }

}

（3）編寫啟動類（由於此處要做負載均衡，所以啟動兩個埠）

@SpringBootApplication
@EnableEurekaClient
public class Application {
    public static void main( String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("請輸入埠號：");
        String port = scan.nextLine();
        new SpringApplicationBuilder(Application.class).properties("server.port="+port).run(args);
    }
}

3.構建消費者服務 smart-platform-sm

(1) 匯入jar包

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

  <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>2.0.2.RELEASE</version>
  </parent>

  <dependencyManagement>
      <dependencies>
         <dependency>
             <groupId>org.springframework.cloud</groupId>
             <artifactId>spring-cloud-dependencies</artifactId>
             <version>Finchley.SR2</version>
             <type>pom</type>
             <scope>import</scope>
         </dependency>
     </dependencies>
  </dependencyManagement>

  <dependencies>
      <dependency>
         <groupId>org.springframework.cloud</groupId>
         <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>

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

      <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-devtools</artifactId>
          <optional>true</optional>
          <scope>true</scope>
      </dependency>
  </dependencies>

  <build>
    <pluginManagement>
      <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>                                   
                <fork>true</fork>
                <addResources>true</addResources>
            </configuration>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>

（2）編寫呼叫程式碼

import com.netflix.loadbalancer.ILoadBalancer;
import com.netflix.loadbalancer.ZoneAwareLoadBalancer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.cloud.netflix.ribbon.SpringClientFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@RestController
@Configuration　　//由於此類種有使用@Bean註解將 RestTemplate 注入到 spring 容器所以需要此註解
@RequestMapping(value = "/platform/shumeng")
public class TestController {

    @Bean
    @LoadBalanced
    public RestTemplate getRestTemplate() {
        return new RestTemplate();
    }

    @GetMapping(value = "/getUser")
    public String getUser(){
　　　　//此種方式會通過輪詢服務列表的方式訪問服務介面
       RestTemplate restTemplate = getRestTemplate();
       String json = restTemplate.getForObject("http://smart-platform-base/platform/base/getUser", String.class);
        return json;
    }

    //獲取例項
    @Autowired
    private LoadBalancerClient client;

    @GetMapping(value = "/lb", produces = MediaType.APPLICATION_JSON_VALUE)
    public ServiceInstance lb() {
        ServiceInstance serviceInstance = client.choose("smart-platform-base");
        return serviceInstance;
    }

    //獲取spring客戶端
    @Autowired
    private SpringClientFactory factory;

    @GetMapping(value = "/factory", produces = MediaType.APPLICATION_JSON_VALUE)
    public String factory() {

        ILoadBalancer balancer = factory.getLoadBalancer("default");
        System.out.println("預設使用的負載均衡器是：" + balancer.getClass().getName());

        ZoneAwareLoadBalancer zb = (ZoneAwareLoadBalancer) balancer;
        System.out.println("預設使用的負載均衡規則是：" + zb.getRule().getClass().getName());

        //預設使用的負載均衡器是：com.netflix.loadbalancer.ZoneAwareLoadBalancer
        //預設使用的負載均衡規則：com.netflix.loadbalancer.ZoneAvoidanceRule

        ZoneAwareLoadBalancer zbm = (ZoneAwareLoadBalancer)factory.getLoadBalancer("smart-platform-base");
        return zbm.getRule().getClass().getName();
    }

}

(3) 自定義負載均衡規則

① 建立規則類

import com.netflix.loadbalancer.ILoadBalancer;
import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.Server;

import java.util.List;
import java.util.Random;

public class MyRule implements IRule {

    private ILoadBalancer iLoadBalancer;

    @Override
    public Server choose(Object o) {
        List<Server> servers = iLoadBalancer.getAllServers();
        System.out.println("自定義負載均衡規則,伺服器數量:"+servers.size());
        Random random = new Random();
        int num = random.nextInt(10);
        if (num > 7) {
　　　　　　　　//特別注意為了方便測試此處將生產者服務的啟動埠寫死為了8001，8002 如果不一樣記得修改
            return getServerByPort(servers, 8001);
        }
        return getServerByPort(servers, 8002);
    }

    @Override
    public void setLoadBalancer(ILoadBalancer iLoadBalancer) {
        this.iLoadBalancer = iLoadBalancer;
    }

    @Override
    public ILoadBalancer getLoadBalancer() {
        return this.iLoadBalancer;
    }

    private Server getServerByPort(List<Server> servers, int port) {
        for (Server server : servers) {
            if (server.getPort() == port) {
                return server;
            }
        }
        return null;
    }
}

② 建立規則例項並注入到spring容器中

import com.netflix.loadbalancer.IRule;
import org.springframework.context.annotation.Bean;

public class MyConfig {

    @Bean
    public IRule getRule() {
        return new MyRule();
    }
}

③ 給 ribbon 客戶端新增自定規則

import org.springframework.cloud.netflix.ribbon.RibbonClient;

@RibbonClient(name = "smart-platform-base", configuration = MyConfig.class)
public class MyClient {
}

上訴② ③方法是通過程式碼的方式將自定義的負載均衡規則新增給了ribbon客戶端 smart-platform-base

通過application.yml配置檔案的方式新增自定義規則，如下

server:
  port: 9001
spring:
  application:
    name: smart-platform-shumeng
#設定自定義規則 如果將smart-platform-base 改成default 則會對所有的客戶端生效，將預設的規則改成 MyRule
smart-platform-base:
  ribbon:
    NFLoadBalancerRuleClassName: com.idelan.platform.config.MyRule
eureka:
  client:
    #指定時間去抓取一次服務列表 預設30秒
    registry-fetch-interval-seconds: 30
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/

負載均衡框架 ribbon 三

Ribbon 在 SpringCloud 中的使用 1.構建 Eureka 註冊中心 smart-platform-eureka1 （1）匯入jar包 <properties> <project.build.sourceEncoding>UTF-8<

SpringCloud系列五：Ribbon 負載均衡（Ribbon 基本使用、Ribbon 負載均衡、自定義 Ribbon 配置、禁用 Eureka 實現 Ribbon 調用）

control context .mm 別名 void 用戶 size ali ram 1、概念：Ribbon 負載均衡 2、具體內容現在所有的服務已經通過了 Eureka 進行了註冊，那麽使用 Eureka 註冊的目的是希望所有的服務都統一歸屬到 Eureka 之中進

SpringCloud教程(Finchley版本)-03：負載均衡（Ribbon）

Spring Cloud Ribbon是一個基於Http和TCP的客服端負載均衡工具，它是基於Netflix Ribbon實現的。它是一個工具類框架，不像服務註冊中心、配置中心、API閘道器那樣獨立部署，但是它幾乎存在於每個微服務的基礎設施中。微服務間的呼叫，API閘道器的請求轉發等，都

eureka的負載均衡、ribbon的原理

ribbon 來完成負載均衡 RibbonLoadBalanceClient 類，是用來進行負載均衡的；其中有個 choose 的方法，原始碼如下：》意思是，對serverId 進行例項化；建立測試類；那麼對其進行詳解下： RibbonLoadBa

Haproxy+etcd+confd+Docker搭建節點自動發現的高可用負載均衡框架

作業系統：Centos 6.5 先扔出一張圖來解釋這四個元件之間的關係下面細說 1.Haproxy Haproxy不用多說，負載均衡軟體，安裝Haproxy yum -y install haproxy 版本是haproxy-1.5

spring cloud (四) 服務端客戶端負載均衡（Ribbon）

概述Ribbon是一個客戶端負載均衡器，它可以讓您對HTTP和TCP客戶端的行為有很大的控制權。 Feign已經使用Ribbon，所以如果您使用的是@FeignClient，那麼這個部分也適用。 Ribbon中一個重要的概念是named client。 Spring Cloud使用Ri

負載均衡之ribbon

一、什麼是負載均衡？做web開發都會接觸到負載均衡，這裡我們就不細說了。（摘自百度百科）負載均衡，英文名稱為Load Balance，其含義就是指將負載（工作任務）進行平衡、分攤到多個操作單元上進行執行，例如FTP伺服器、Web伺服器、企業核心應用伺服器和其它主要任務伺服器等，從而協同完成工作任務。

SpringCloud系列之客戶端負載均衡Netflix Ribbon

### 1. 什麼是負載均衡？負載均衡是一種基礎的網路服務，它的核心原理是按照指定的負載均衡演算法，將請求分配到後端服務叢集上，從而為系統提供並行處理和高可用的能力。提到負載均衡，你可能想到nginx。對於負載均衡，一般分為服務端負載均衡和客戶端負載均衡 * 服務端負載均衡：在消費者和服務提供方中間使

Springboot 框架 gateway 前後端分離實現 zuul Ribbon 負載均衡脫離Eureka實現

專案後臺框架是使用的springboot ，前端使用的是angularJS，中間使用gateway做一層轉發。其實也是微服務的思想。那麼在gateway這層怎麼實現負載均衡。就使用到了zuul，那麼可以使用zuul 的Ribbon來實現負載均衡。這個是我們專案原先做了一個配置。主要是zu

spring cloud: zuul(三): ribbon負載均衡配置

zuul的routes配置下path/url組合不支援負載均衡下面介紹zuul的routes配置下的path/serviceId負載均衡配置 spring-boot-user微服務開啟了：7901,7902兩個服務 zuul服務 eureka服務看配置： zuul: routes:

Eclipse初次搭建SpringCloud+ribbon負載均衡(三)

把上一個文章的專案重新複製一份修改下yml中埠(文章地址: https://blog.csdn.net/yuzhiqiang_1/article/details/84580665) 一: application.yml server: port: 12347 # 你的埠 eure

三、SpringCloud五大神獸之Ribbon（負載均衡）

Ribbon是Netflix釋出的開源專案，主要功能是提供客戶端的軟體負載均衡演算法，將Netflix的中間層服務連線在一起。Ribbon客戶端元件提供一系列完善的配置項如連線超時，重試等。簡單的說，就是在配置檔案中列出Load Balancer（簡稱LB）後面

（三）Spring Cloud實踐：使用Netflix Ribbon實現負載均衡

按照前面兩篇實現模組1、模組2、模組3、模組4，基本上能夠滿足一定的應用需求了（在訪問量不是太大的情況下）。如果我們的微服務的訪問量比較大，單臺伺服器無法滿足需求或者考慮到IO問題，需要把微服務部署到多臺伺服器上時，就需要考慮負載均衡的問題。 Spring提供了Ribb

淺談SpringCloud (三) Ribbon負載均衡

就會 rul back alt build 算法實例 app creat 什麽是負載均衡當一臺服務器的單位時間內的訪問量越大時，服務器壓力就越大，大到超過自身承受能力時，服務器就會崩潰。為了避免服務器崩潰，讓用戶有更好的體驗，我們通過負載均衡的方式來分擔服務器壓力。

三、SpringCloud使用Ribbon+RestTemplate實現負載均衡

一、Ribbon簡介 Ribbon是Netflix公司開源的使用在客戶端的一個負載均衡的專案。是SpringCloud Finchley.M8版本結合使用Consul時使用預設負載均衡客戶端。負載均衡策略有以下，當然我們一可以更具實際需求，來自定義負載均衡

SpringCloud服務發現與負載均衡ribbon（三）

SpringCloud學習總結 3、服務發現與負載均衡ribbon 一、服務發現修改provider8001主啟動類，增加註解@EnableDiscoveryClient package com.atguigu.springcloud; import org.spri

一起來學Spring Cloud | 第三章：服務消費者 (負載均衡Ribbon)

一、負載均衡的簡介：負載均衡是高可用架構的一個關鍵元件，主要用來提高效能和可用性，通過負載均衡將流量分發到多個伺服器，多伺服器能夠消除單個伺服器的故障，減輕單個伺服器的訪問壓力。 1、服務端負載均衡：客戶端請求到負載均衡伺服器，負載均衡伺服器根據自身的演算法將該請求轉給某臺真正提供業務的伺服器，該伺服器將響

springcloud 系列教程三：RestTemplate實現服務的呼叫以及Ribbon負載均衡

springcloud 中有兩種呼叫方式，RestTemplate、Fegin。RestTemplate 由 spring 提供，

【一起學原始碼-微服務】Feign 原始碼三：Feign結合Ribbon實現負載均衡的原理分析

前言前情回顧上一講我們已經知道了Feign的工作原理其實是在專案啟動的時候，通過JDK動態代理為每個FeignClinent生成一個動態代理。動態代理的資料結構是：ReflectiveFeign.FeignInvocationHandler。其中包含target(裡面是serviceName等資訊)和d

三、Spring Cloud之軟負載均衡 Ribbon

前言上一節我們已經學習了Eureka 註冊中心，其實我們也使用到了Ribbon ,只是當時我們沒有細講，所以我們現在一起來學習一下Ribbon。什麼是Ribbon 之前接觸到的負載均衡都是硬負載均衡，什麼是硬負載均衡呢？硬負載均衡就是在以往的大型系統中，會有單獨一套系統來負責負載均衡策略，我們所以的請求都

負載均衡框架 ribbon 三

相關推薦