springcloud 第1課：Rest學習環境搭建—服務提供者

springcloud 第2課：Rest學習環境搭建—服務消費者

springcloud 第3課：Eureka是什麼

springcloud 第4課：Eureka服務注冊、資訊配置、自我保護機制

springcloud 第5課：Eureka叢集環境配置

Ribbon是什麼？

Ribbon是Netflix釋出的雲中間層服務開源項目，其主要功能是提供用戶端實作負載均衡算法。Ribbon用戶端元件提供一系列完善的配置項如連接配接逾時，重試等。簡單的說，Ribbon是一個用戶端負載均衡器，我們可以在配置檔案中Load Balancer後面的所有機器，Ribbon會自動的幫助你基于某種規則（如簡單輪詢，随機連接配接等）去連接配接這些機器，我們也很容易使用Ribbon實作自定義的負載均衡算法。

實作負載均衡方式1：通過伺服器端實作負載均衡(nginx)

實作負載均衡方式2：通過用戶端實作負載均衡(ribbon)

1、負載均衡和Ribbon案例

便于了解，消費者目錄結構圖如下

SpringCloud06：Ribbon實作負載均衡1、負載均衡和Ribbon案例2、使用Ribbon實作負載均衡

1.1、将ribbon和eureka配置到用戶端

導入ribbon和eureka的pom依賴

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>demo1</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springcloud-consumer-dept-80</artifactId>

<dependencies>
    <!--Ribbon，負責負載均衡-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-ribbon</artifactId>
        <version>1.4.7.RELEASE</version>
    </dependency>
    <!--加入eureka依賴，負責注冊與發現-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-eureka</artifactId>
        <version>1.4.6.RELEASE</version>
    </dependency>
    <!--實體類-->
    <dependency>
        <groupId>org.example</groupId>
        <artifactId>springcloud-api</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>
    <!--web啟動器-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!--熱部署-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
    </dependency>
</dependencies>
</project>

1.2、配置eureka，實作負載均衡

application.yaml 配置eureka，消費者可以随機的從3個eureka注冊中心消費服務

server:
  port: 80

#eureka配置
eureka:
  client:
    register-with-eureka: false #消費者不向eureka中心注冊自己，隻消費不提供服務，生産者才負責提供服務
    service-url:   #消費者可以随機的到這3個eureka注冊中心消費，達到負載均衡的效果
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/

1.3、配置類添加ribbon的負載均衡注解

package com.lian.springcloud.config;

import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration
public class ConfigureBean {

    //配置負載均衡實作RestTemplate,ribbon的作用
    @LoadBalanced  //ribbon，基于用戶端實作負載均衡
    @Bean
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
}

1.4、controller層配置 String REST_URL_PREFIX

package com.lian.springcloud.controller;

import com.lian.springcloud.pojo.Dept;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.client.RestTemplate;

import java.util.List;

@RestController
public class DeptConsumerController {

    /**
     * 1、消費者，不應該有service層
     * 2、RestTemplate 供我們直接調用即可，注冊到Spring容器中，由配置類注入spring容器
     *  （ url，實體：用map封裝，Class<T> responseType ）
     */
    @Autowired
    RestTemplate restTemplate;

    //未加Ribbon之前，用戶端通路的是固定的某個端口，這樣會導緻機器壓力較大，不能給多台機器合理配置設定任務量
    //private static final String REST_URL_PREFIX = "http://localhost:8001";

    /**
     * 用戶端通路的是某一個服務裡面的多個随機的端口，根據IRule類，可根據權重等值來進行輪詢，達到負載均衡的作用
     */
    private static final String REST_URL_PREFIX = "http://SPRINGCLOUD-PROVIDER-DEPT";

    @RequestMapping("/consumer/dept/get/{id}")
    public Dept get(@PathVariable("id") Long id){
        return restTemplate.getForObject(REST_URL_PREFIX+"/dept/get/"+id, Dept.class);
    }

    @RequestMapping("/consumer/dept/list")
    public List<Dept> list(){
        return restTemplate.getForObject(REST_URL_PREFIX+"/dept/list",List.class);
    }

    @RequestMapping("/consumer/dept/add")
    public boolean add(Dept dept){
        return restTemplate.postForObject(REST_URL_PREFIX+"/dept/add",dept,Boolean.class);
    }
}

1.5、主啟動啟動

package com.lian.springcloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@EnableEurekaClient
@SpringBootApplication
public class DeptConsumer_80 {
    public static void main(String[] args) {
        SpringApplication.run(DeptConsumer_80.class,args);
    }
}

2、使用Ribbon實作負載均衡

SpringCloud06：Ribbon實作負載均衡1、負載均衡和Ribbon案例2、使用Ribbon實作負載均衡

1、建立3個相同的資料庫，這裡我直接複制第一個資料庫示範

CREATE TABLE `dept1` (
  `deptno` int(11) NOT NULL AUTO_INCREMENT,
  `dname` varchar(255) DEFAULT NULL,
  `dbsource` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`deptno`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;

insert into dept (deptno,dname,dbsource) VALUES (1,'開發部','db01');
insert into dept (deptno,dname,dbsource) VALUES (1,'策劃部','db01');
insert into dept (deptno,dname,dbsource) VALUES (1,'美術部','db01');
insert into dept (deptno,dname,dbsource) VALUES (1,'招聘部','db01');

SpringCloud06：Ribbon實作負載均衡1、負載均衡和Ribbon案例2、使用Ribbon實作負載均衡

2、建立3個生産者

複制生産者8001，生成生産者8002和8003，修改資料庫名和端口名、執行個體id名、主啟動類即可

2.1、導入pom依賴

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springcloud-provider-dept-8001</artifactId>

    <dependencies>
        <!--我們需要拿到實體類，是以需要配置 api 子產品-->
        <dependency>
            <groupId>org.example</groupId>
            <artifactId>springcloud-api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--druid-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
        </dependency>
        <!--logback日志門面-->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-core</artifactId>
        </dependency>
        <!--mybatis的springboot啟動器-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
        <!--springboot的測試-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-test</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--jetty，當做應用伺服器，和tomcat類似-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jetty</artifactId>
        </dependency>
        <!--熱部署工具-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
        <!--加入eureka依賴-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
            <version>1.4.6.RELEASE</version>
        </dependency>
        <!-- actuator 完善監控資訊-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
    </dependencies>
</project>

2.2、複制resources

SpringCloud06：Ribbon實作負載均衡1、負載均衡和Ribbon案例2、使用Ribbon實作負載均衡

2.2.1、application.yaml

修改端口号、資料庫名、instance-id

server:
  port: 8001

#mybatis的配置
mybatis:
  config-location: classpath:mybatis/mybatis-config.xml  #mybatis核心配置檔案
  mapper-locations: classpath:mybatis/mapper/*.xml
  type-aliases-package: com.lian.springcloud.pojo

#spring的配置
spring:
  application:
    name: springcloud-provider-dept  #3個服務名稱一緻，但請求不同
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: org.gjt.mm.mysql.Driver
    url: jdbc:mysql://localhost:3306/db?useUnicode=true&characterEncoding=utf-8
    username: root
    password: root

#eureka的配置，服務注冊到哪裡
eureka:
  client:
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
  instance:
    instance-id: springcloud-provider-dept8001   #修改eureka頁面的status描述
    fetch-registry: false

#info配置
info:
  app.name: lian-springcloud
  company.name: msb

2.2.2、複制mybatis包

mybatis-config.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <settings>
        <!--開啟二級緩存-->
        <setting name="cacheEnabled" value="true"/>
    </settings>

</configuration>

DeptMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.lian.springcloud.dao.DeptDao">

    <insert id="addDept" parameterType="com.lian.springcloud.pojo.Dept">
        insert into dept (dname,dbsource) values (#{dname},#{dbsource})
    </insert>

    <select id="queryById" parameterType="long" resultType="com.lian.springcloud.pojo.Dept">
        select * from dept where deptno = #{deptno}
    </select>

    <select id="queryAll" resultType="com.lian.springcloud.pojo.Dept">
        select * from Dept
    </select>

</mapper>

2.3、複制java目錄下的包

SpringCloud06：Ribbon實作負載均衡1、負載均衡和Ribbon案例2、使用Ribbon實作負載均衡

2.3.1、dao層

package com.lian.springcloud.dao;

import com.lian.springcloud.pojo.Dept;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

import java.util.List;

/**
 * @Repository 托管給spring容器
 * @Mapper 作用有3個：
 *         1、把mapper這個DAO交給Spring管理
 *         2、不再寫mapper映射檔案
 *         3、編譯之後會生成相應的接口實作類
 */
@Repository
@Mapper
public interface DeptDao {

    boolean addDept(Dept dept);

    Dept queryById(Long id);

    List<Dept> queryAll();
}

2.3.2、DeptService接口

package com.lian.springcloud.service;

import com.lian.springcloud.pojo.Dept;

import java.util.List;

public interface DeptService {

    boolean addDept(Dept dept);

    Dept queryById(Long id);

    List<Dept> queryAll();
}

2.3.3、DeptServiceImpl實作類

package com.lian.springcloud.service;

import com.lian.springcloud.dao.DeptDao;
import com.lian.springcloud.pojo.Dept;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class DeptServiceImpl implements DeptService{

    @Autowired
    private DeptDao deptDao;
    
    @Override
    public boolean addDept(Dept dept) {
        return deptDao.addDept(dept);
    }
    
    @Override
    public Dept queryById(Long id) {
        return deptDao.queryById(id);
    }

    @Override
    public List<Dept> queryAll() {
        return deptDao.queryAll();
    }
}

2.3.4、controller層

package com.lian.springcloud.controller;

import com.lian.springcloud.pojo.Dept;
import com.lian.springcloud.service.DeptService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

import java.util.List;
//通過restful服務
@Controller
public class DeptController {
    @Autowired
    private DeptService deptService;

    //擷取微服務資訊
    @Autowired
    private DiscoveryClient client;

    @GetMapping("/dept/list")
    @ResponseBody
    public List<Dept> queryAllDepts(){
        return deptService.queryAll();
    }

    @GetMapping("/dept/get/{id}")
    @ResponseBody
    public Dept queryById(@PathVariable("id") Long id){
        return deptService.queryById(id);
    }

    @PostMapping("/dept/add")
    @ResponseBody
    public void addDept(Dept dept){
        deptService.addDept(dept);
    }

    //注冊進來的微服務，擷取一些消息
    @GetMapping("/dept/discovery")
    public Object discover(){
        //擷取微服務清單的清單
        List<String> services = client.getServices();
        System.out.println(services);
        //得到一個具體的微服務資訊，通過具體的微服務id，applicationname
        List<ServiceInstance> instances = client.getInstances("SPRINGCLOUD-PROVIDER-DEPT");
        for (ServiceInstance instance : instances) {
            System.out.println(
                    instance.getHost()+"\t"+
                    instance.getPort()+"\t"+
                    instance.getUri()+"\t"+
                    instance.getServiceId()+"\t"
            );
        }
        return this.client;
    }
}

2.3.5、主啟動類

類名修改為8002和8003

package com.lian.springcloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
/**
 * 主啟動類
 * 因為是maven項目，不是spring initialize項目，需要自己寫主啟動類
 *
 */
@EnableDiscoveryClient  //服務發現
@EnableEurekaClient  //eureka是cs架構，配置此注解，在服務啟動後，會自動注冊到eureka服務端
@SpringBootApplication
public class DeptProvider_8001 {
    public static void main(String[] args) {
        SpringApplication.run(DeptProvider_8001.class,args);
    }
}

3個eureka注冊中心都有這3個生産者提供的服務

SpringCloud06：Ribbon實作負載均衡1、負載均衡和Ribbon案例2、使用Ribbon實作負載均衡

ribbon的預設算法就是輪詢

SpringCloud06：Ribbon實作負載均衡1、負載均衡和Ribbon案例2、使用Ribbon實作負載均衡

3、自定義負載均衡算法

負載均衡算法有以下幾種，預設是輪詢

SpringCloud06：Ribbon實作負載均衡1、負載均衡和Ribbon案例2、使用Ribbon實作負載均衡

3.1、IRule類

public interface IRule{

    public Server choose(Object key);
    
    public void setLoadBalancer(ILoadBalancer lb);
    
    public ILoadBalancer getLoadBalancer();    
}

3.2、示範負載均衡—随機算法操作

自定義的負載均衡算法元件會覆寫預設的元件

3.2.1、消費者80在config類，将myRule預設輪詢bean注入spring容器

package com.lian.springcloud.config;

import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RandomRule;
import com.netflix.ribbon.Ribbon;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration
public class ConfigureBean {

    //配置負載均衡實作RestTemplate,ribbon的作用

    /**
     * IRule
     * RoundRobinRule 輪詢，預設
     * RandomRule 随機
     * AvailabilityFilteringRule：會先過濾掉，跳閘，通路故障的服務，對剩下的進行輪詢
     * RetryRule：會先按照輪詢擷取服務，如果服務擷取失敗，則會在指定的時間内進行，重試
     */
    @LoadBalanced  //ribbon，基于用戶端實作負載均衡
    @Bean
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
	
	//負載均衡随機案例
    @Bean
    public IRule myRule(){
        return new RandomRule();
    }
}

或在消費者主啟動類上配置Ribbon的随機算法操作（推薦）

3.2.2、建立LianRule 類

package com.lian.springcloud.rule;

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

@Configuration
public class LianRule {

    @Bean
    public IRule LianRule(){
        return new RandomRule();
    }
}

3.2.3、主啟動類配置@RibbonClient注解

package com.lian.springcloud;

import com.lian.springcloud.rule.MyRule;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.ribbon.RibbonClient;

@EnableEurekaClient
@SpringBootApplication
/**
 * name是要負載均衡的服務名，服務名下有多個生産者提供的服務，采用MyRule負載均衡算法，此處的負載均衡算法是随機
 * 在微服務啟動的時候就能加載我們自定義的Ribbon類，實作負載均衡算法
 */
@RibbonClient(name = "springcloud-provider-dept",configuration = LianRule.class)
public class DeptConsumer_80 {
    public static void main(String[] args) {
        SpringApplication.run(DeptConsumer_80.class,args);
    }
}

3.3、示範自定義的負載均衡算法

消費者80目錄結構圖

SpringCloud06：Ribbon實作負載均衡1、負載均衡和Ribbon案例2、使用Ribbon實作負載均衡

3.3.1、建立LianRule類

IRule接口中查詢發現有了我們自定義的負載均衡算法方法

SpringCloud06：Ribbon實作負載均衡1、負載均衡和Ribbon案例2、使用Ribbon實作負載均衡

package com.lian.springcloud.rule;

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

@Configuration
public class LianRule {

    @Bean
    public IRule myRule(){
        return new LianRandomRule();
    }
}

3.3.2、建立LianRandomRule類

package com.lian.springcloud.rule;

import com.netflix.client.config.IClientConfig;
import com.netflix.loadbalancer.AbstractLoadBalancerRule;
import com.netflix.loadbalancer.ILoadBalancer;
import com.netflix.loadbalancer.Server;

import java.util.List;
import java.util.concurrent.ThreadLocalRandom;

public class LianRandomRule extends AbstractLoadBalancerRule {

    /**
     * 需求：
     * 在生産者提供的3個服務中8001、8002、8003，每個服務，通路5次
     * total = 0，預設=0，如果=5，我們指向下一個服務節點
     * index=0，預設0，如果total=5，index+1
     */
    //被調用的次數
    private int total = 0;
    //目前是誰在提供服務
    private int currentIndex = 0;

    public Server choose(ILoadBalancer lb, Object key) {
        if (lb == null) {
            return null;
        }
        Server server = null;

        while (server == null) {
            if (Thread.interrupted()) {
                return null;
            }
            //擷取活着的服務
            List<Server> upList = lb.getReachableServers();
            //擷取全部的服務
            List<Server> allList = lb.getAllServers();

            int serverCount = allList.size();
            if (serverCount == 0) {

                return null;
            }

            //生成全部服務個數的區間随機數
            //int index = chooseRandomInt(serverCount);
            //從活着的服務中随機擷取一個
            //server = upList.get(index);

            //-----------------------自定義----------------------------
            
            //如果目前的服務被調用次數小于5次
            if (total < 5){
                //就從活着的服務中繼續調用目前的服務
                server = upList.get(currentIndex);
                total++;
            }else{
                //新服務被調用的次數是0
                total=0;
                //切換成下一個服務
                currentIndex++;
                //因為隻有3個服務，下标為0、1、2，如果新服務的下标超過活着的服務數3，
                if (currentIndex >= upList.size()){
                    //就再次切換到第0個服務
                    currentIndex=0;
                }
                //從活着的服務中擷取指定的服務進行操作
                server = upList.get(currentIndex);
            }

            //---------------------------------------------------

            if (server == null) {

                Thread.yield();
                continue;
            }

            if (server.isAlive()) {
                return (server);
            }

            server = null;
            Thread.yield();
        }

        return server;

    }

    protected int chooseRandomInt(int serverCount) {
        return ThreadLocalRandom.current().nextInt(serverCount);
    }

	@Override
	public Server choose(Object key) {
		return choose(getLoadBalancer(), key);
	}

	@Override
	public void initWithNiwsConfig(IClientConfig clientConfig) {
		
	}
}

3.3.3、ConfigureBean 類不改變

package com.lian.springcloud.config;

import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration
public class ConfigureBean {

    //配置負載均衡實作RestTemplate,ribbon的作用

    /**
     * IRule
     * RoundRobinRule 輪詢
     * RandomRule 随機
     * AvailabilityFilteringRule：會先過濾掉，跳閘，通路故障的服務，對剩下的進行輪詢
     * RetryRule：會先按照輪詢擷取服務，如果服務擷取失敗，則會在指定的時間内進行，重試
     */
    @LoadBalanced  //ribbon，基于用戶端實作負載均衡
    @Bean
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }

//    @Bean
//    public IRule myRule(){
//        return new RandomRule();
//    }
}

3.3.4、DeptConsumerController 類不改變

package com.lian.springcloud.controller;

import com.lian.springcloud.pojo.Dept;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.client.RestTemplate;

import java.util.List;

@RestController
public class DeptConsumerController {

    /**
     * 1、消費者，不應該有service層
     * 2、RestTemplate 供我們直接調用即可，注冊到Spring容器中，由配置類注入spring容器
     *  （ url，實體：用map封裝，Class<T> responseType ）
     */
    @Autowired
    RestTemplate restTemplate;

    //未加Ribbon之前，用戶端通路的是固定的某個端口，這樣會導緻機器壓力較大，不能給多台機器合理配置設定任務量
    //private static final String REST_URL_PREFIX = "http://localhost:8001";

    /**
     * 用戶端通路的是某一個服務裡面的多個随機的端口，根據IRule類，可根據權重等值來進行輪詢，達到負載均衡的作用
     */
    private static final String REST_URL_PREFIX = "http://SPRINGCLOUD-PROVIDER-DEPT";

    @RequestMapping("/consumer/dept/get/{id}")
    public Dept get(@PathVariable("id") Long id){
        return restTemplate.getForObject(REST_URL_PREFIX+"/dept/get/"+id, Dept.class);
    }

    @RequestMapping("/consumer/dept/list")
    public List<Dept> list(){
        return restTemplate.getForObject(REST_URL_PREFIX+"/dept/list",List.class);
    }

    @RequestMapping("/consumer/dept/add")
    public boolean add(Dept dept){
        return restTemplate.postForObject(REST_URL_PREFIX+"/dept/add",dept,Boolean.class);
    }
}

3.3.5、主啟動類 DeptConsumer_80

package com.lian.springcloud;

import com.lian.springcloud.rule.LianRule;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.ribbon.RibbonClient;

/**
 * name是要負載均衡的服務名，服務名下有多個生産者提供的服務，采用MyRule負載均衡算法，此處的負載均衡算法是随機
 * 在微服務啟動的時候就能加載我們自定義的Ribbon類，實作負載均衡算法
 */
@EnableEurekaClient
@SpringBootApplication
@RibbonClient(name = "SPRINGCLOUD-PROVIDER-DEPT",configuration = LianRule.class)
public class DeptConsumer_80 {
    public static void main(String[] args) {
        SpringApplication.run(DeptConsumer_80.class,args);
    }
}

3.3.6、application.yaml 不改變

server:
  port: 80

#Eureka配置
eureka:
  client:
    register-with-eureka: false  #不向eureka注冊自己
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/

3.3.7、pom依賴不改變

<dependencies>
        <!--實體類-->
        <dependency>
            <groupId>org.example</groupId>
            <artifactId>springcloud-api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <!--web啟動器-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--熱部署-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
        <!--Ribbon-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-ribbon</artifactId>
            <version>1.4.7.RELEASE</version>
        </dependency>
        <!--eureka-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
            <version>1.4.6.RELEASE</version>
        </dependency>
    </dependencies>

SpringCloud06：Ribbon實作負載均衡1、負載均衡和Ribbon案例2、使用Ribbon實作負載均衡

SpringCloud06：Ribbon實作負載均衡1、負載均衡和Ribbon案例2、使用Ribbon實作負載均衡

1、負載均衡和Ribbon案例

1.1、将ribbon和eureka配置到用戶端

1.2、配置eureka，實作負載均衡

1.3、配置類添加ribbon的負載均衡注解

1.4、controller層配置 String REST_URL_PREFIX

1.5、主啟動啟動

2、使用Ribbon實作負載均衡

1、建立3個相同的資料庫，這裡我直接複制第一個資料庫示範

2、建立3個生産者

2.1、導入pom依賴

2.2、複制resources

2.2.1、application.yaml

2.2.2、複制mybatis包

2.3、複制java目錄下的包

2.3.1、dao層

2.3.2、DeptService接口

2.3.3、DeptServiceImpl實作類

2.3.4、controller層

2.3.5、主啟動類

3、自定義負載均衡算法

3.1、IRule類

3.2、示範負載均衡—随機算法操作

3.2.1、消費者80在config類，将myRule預設輪詢bean注入spring容器

3.2.2、建立LianRule 類

3.2.3、主啟動類配置@RibbonClient注解

3.3、示範自定義的負載均衡算法

3.3.1、建立LianRule類

3.3.2、建立LianRandomRule類

3.3.3、ConfigureBean 類不改變

3.3.4、DeptConsumerController 類不改變

3.3.5、主啟動類 DeptConsumer_80

3.3.6、application.yaml 不改變

3.3.7、pom依賴不改變

繼續閱讀