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依赖不改变

继续阅读