SpringCloud（三）Ribbon和Feign的了解与使用

1.Ribbon：负载均衡及Ribbon

Ribbon是什么？

SpringCloudRibbon是基于NetflixRibbon实现的一套==客户端负载均衡的工具==
简单的说，Ribbon是Netflix发布的开源项目，主要功能是提供客户端的软件负载均衡算法，将Netflix的中间层服务连接在一起。Ribbon的客户端组件提供一系列完整的配置项，如：连接超时、重试等等。简单的说，就是在配置文件中列出LoadBalancer（简称LB：负载均衡）后面所有的机器，Ribbon会自动的帮助你基于某种规则（如：简单轮询，随机连接等等）去连接这些机器。我们也很容易使用Ribbon实现自定义的负载均衡算法。

Ribbon能干嘛？

LB，即负载均衡（Load Balance），在微服务或分布式集群中经常用的一种应用。
负载均衡简单的说就是将用户的请求平摊的分配到服务器上，从而达到系统的HA（高可用）。
常见的负载均衡软件有Nginx、Lvs等等。
Dubbo，SpringCloud中均给我们提供了负载均衡，SpringCloud的负载均衡算法可以自动以。
负载均衡简单分类：
- 集中式LB
  - 即在服务的消费方和提供方之间使用独立的LB设施，如Nginx（反向代理服务器），由该设施负责把访问请求通过某种策略转发至服务的提供方！
- 进程式LB
  - 将LB逻辑集中到消费方，消费方从服务注册中心获知哪些地址可用，然后自己再从这些地址中选出一个合适的服务器。
  - ==Ribbon==就属于进程内LB，它只是一个类库，集成消费方进程，消费方通过它来获取到服务提供方的地址。
Ribbon 和整合以后，客户端可以直接调用，不用关心IP地址

通过Ribbon实现负载均衡

为了消费者真实的感受到服务端的切换，向80端口消费者模块中pom.xml文件中引入Eureka、Ribbon依赖

<!--Ribbon-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-ribbon</artifactId>
    <version>1.4.6.RELEASE</version>
</dependency>
<!--Eureka-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-eureka</artifactId>
    <version>1.4.6.RELEASE</version>
</dependency>

修改ConfigBean.java配置文件，添加了@LoadBalance

@Configuration
public class ConfigBean {

    /**
     * 配置负载均衡实现RestTemplate
     * 添加@LoadBalanced
     * 基于Ribbon
     */
    @Bean
    @LoadBalanced
    public RestTemplate getRestTemplate() {
        return new RestTemplate();
    }

}

修改DeptConsumerController.java文件

@RestController
public class DeptConsumerController {

    /**
     * 理解：消费者不应该有service层
     * RestTemplate 供我们直接调用就可以了！注册到Spring中
     * (url, 实体:Map, Class<T> responseType)
     * 什么方式拿，去哪拿，拿什么类型东西
     * 提供多种便捷访问远程http服务的方法
     * 简单的restful服务模板
     */
    @Autowired
    private RestTemplate restTemplate;

    // 通过Ribbon实现负载均衡时，链接地址应该是变量，通过服务名访问
    //private static final String REST_URL_PREFIX = "http://localhost:8001";
    private static final String REST_URL_PREFIX = "http://SPRINGCLOUD-PROVIDER-DEPT";

    /**
     * 客户端添加一个部门
     * @param dept 部门对象
     * @return 添加结果
     */
    @RequestMapping("/consumer/dept/add")
    public boolean add(Dept dept) {
        return restTemplate.postForObject(REST_URL_PREFIX + "/dept/add", dept, Boolean.class);
    }

    /**
     * 通过部门id获取部门信息
     * @param id 部门id
     * @return 部门信息
     */
    @RequestMapping("/consumer/dept/get/{id}")
    public Dept get(@PathVariable("id") Long id) {
        return restTemplate.getForObject(REST_URL_PREFIX + "/dept/get/" + id, Dept.class);
    }

    /**
     * 查询所有部门
     * @return 部门列表
     */
    @RequestMapping("/consumer/dept/list")
    public List<Dept> list() {
        return restTemplate.getForObject(REST_URL_PREFIX + "/dept/list", List.class);
    }
}

由于引入Eureka，需要在80端口主启动类中添加：@EnableEurekaClient
接下来配置服务端
新增数据库：db02

DROP DATABASE IF EXISTS `db02`;
CREATE DATABASE `db02`;
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

DROP TABLE IF EXISTS `dept`;
CREATE TABLE `dept`  (
  `d_no` bigint(20) NOT NULL AUTO_INCREMENT,
  `d_name` varchar(60) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  `db_source` varchar(60) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  PRIMARY KEY (`d_no`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 8 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci COMMENT = '部门表' ROW_FORMAT = Dynamic;

INSERT INTO `dept` VALUES (1, '开发部', 'db02');
INSERT INTO `dept` VALUES (2, '人事部', 'db02');
INSERT INTO `dept` VALUES (3, '财务部', 'db02');
INSERT INTO `dept` VALUES (4, '市场部', 'db02');
INSERT INTO `dept` VALUES (5, '运维部', 'db02');
INSERT INTO `dept` VALUES (6, '信息部', 'db02');
INSERT INTO `dept` VALUES (7, '游戏部', 'db02');

新增数据库：db03

DROP DATABASE IF EXISTS `db02`;
CREATE DATABASE `db02`;
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

DROP TABLE IF EXISTS `dept`;
CREATE TABLE `dept`  (
  `d_no` bigint(20) NOT NULL AUTO_INCREMENT,
  `d_name` varchar(60) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  `db_source` varchar(60) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  PRIMARY KEY (`d_no`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 8 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci COMMENT = '部门表' ROW_FORMAT = Dynamic;

INSERT INTO `dept` VALUES (1, '开发部', 'db03');
INSERT INTO `dept` VALUES (2, '人事部', 'db03');
INSERT INTO `dept` VALUES (3, '财务部', 'db03');
INSERT INTO `dept` VALUES (4, '市场部', 'db03');
INSERT INTO `dept` VALUES (5, '运维部', 'db03');
INSERT INTO `dept` VALUES (6, '信息部', 'db03');
INSERT INTO `dept` VALUES (7, '游戏部', 'db03');

需要在创建两个module：springcloud-provider-dept-8002、springcloud-provider-dept-8003
分别引入pom.xml依赖

<dependencies>
    <!--添加监控信息-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
    <!--Eureka-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-eureka</artifactId>
        <version>1.4.6.RELEASE</version>
    </dependency>
    <!--需要拿到实体类,要配置api-module-->
    <dependency>
        <groupId>org.example</groupId>
        <artifactId>springcloud-api</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>
    <!--junit-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <scope>test</scope>
    </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>
    <!--springboot启动器-->
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
    </dependency>
    <!--test-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-test</artifactId>
    </dependency>
    <!--web启动器-->
    <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>
</dependencies>

8002端口的application.yml（端口号、数据库连接名、Eureka的默认描述信息）

server:
  port: 8002

# mybatis配置
mybatis:
  type-aliases-package: com.example.springcloud.pojo
  config-location: classpath:mybatis/mybatis-config.xml
  mapper-locations: classpath:mybatis/mapper/*.xml

# spring配置
spring:
  application:
    # 三个服务名称一致
    name: springcloud-provider-dept
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driverClassName: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/db02?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
    username: root
    password: root

# Eureka的配置，服务注册到哪里
eureka:
  client:
    service-url:
      # 服务发布地址
      defaultZone: http://localhost:7001/eureka/,http://localhost:7002/eureka/,http://localhost:7003/eureka/
  instance:
    # 修改Eureka的默认描述信息
    instance-id: springcloud-provider-dept8002

8003端口的application.yml（端口号、数据库连接名、Eureka的默认描述信息）

server:
  port: 8003

# mybatis配置
mybatis:
  type-aliases-package: com.example.springcloud.pojo
  config-location: classpath:mybatis/mybatis-config.xml
  mapper-locations: classpath:mybatis/mapper/*.xml

# spring配置
spring:
  application:
    # 三个服务名称一致
    name: springcloud-provider-dept
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driverClassName: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/db03?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
    username: root
    password: root

# Eureka的配置，服务注册到哪里
eureka:
  client:
    service-url:
      # 服务发布地址
      defaultZone: http://localhost:7001/eureka/,http://localhost:7002/eureka/,http://localhost:7003/eureka/
  instance:
    # 修改Eureka的默认描述信息
    instance-id: springcloud-provider-dept8003

其余全部复制8001端口服务文件（注意修改主启动类名）
接下来依次启动7001、7002、7003、8001、8002、8003、80，七个端口服务
多次刷新访问
- 访问路径：http://localhost/consumer/dept/list
- 注意后面数据库来源
- 如果发生变化，配置生效

2. Ribbon：自定义负载均衡算法

自定义Ribbon客户端不能和主启动类在同级文件夹中
- 例：主启动类在com.example.springcloud
- 警告：自定义轮询算法如果和主启动类在同一文件夹中，将会被自动覆盖。
需要在com.example文件夹下创建新的文件夹：myrule
- 和springcloud文件夹同级
在myrule文件夹中创建MyRandomRule.java

public class MyRandomRule extends AbstractLoadBalancerRule {

    public MyRandomRule() {
    }

    // 每台机器访问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;
        } else {
            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 = this.chooseRandomInt(serverCount);
                // 从活着的服务中随机获取一个
                //server = upList.get(index);

                //-===============自定义轮询算法================
                if (total < 4) {
                    server = upList.get(currentIndex);
                    total++;
                } else {
                    total = 0;
                    currentIndex++;
                    if (currentIndex > upList.size() - 1) {
                        currentIndex = 0;
                    }
                    // 从活着的服务中心，获取指定的服务来进行操作
                    server = upList.get(currentIndex);
                }
                //-==========================================

                if (server != null) {
                    if (server.isAlive()) {
                        return server;
                    }

                    server = null;
                }
                Thread.yield();
            }

            return server;
        }
    }

    public Server choose(Object key) {
        return this.choose(this.getLoadBalancer(), key);
    }

    public void initWithNiwsConfig(IClientConfig clientConfig) {
    }
}

在myrule文件夹中创建MyRibbonRule.java

@Configuration
public class MyRibbonRule {

    @Bean
    public IRule myRule() {
        // 默认轮询，现在自定义自己的
        return new MyRandomRule();
    }
}

在主启动类中添加注解：@RibbonClient(name = "SPRINGCLOUD-PROVIDER-DEPT", configuration = MyRibbonRule.class)
- 参数：服务名，自定义Ribbon文件
重启80端口服务
访问请求地址，刷新五次后，切换服务端

3. Feign：使用接口方式调用服务

3.1 Feign介绍

Feign简介

Feign是声明式的web service客户端，它让微服务之间的调用变得更简单了，类似controller调用service。SpringCloud集成了Ribbon和Rureka，可在使用Feign时提供负载均衡的HTTP客户端。

只需要创建一个接口，然后添加注解即可！

Feign，主要是社区，很多开发人员是面向接口编程。调用微服务访问两种方法

微服务名字【Ribbon】
接口和注解【Feign】

Feign能干什么？

Feign主要是让编写Java Http客户端变得更容易
前面使用Ribbon + RestTemplate时，利用RestTemplate对Http请求的封装处理，形成了一套模板化的调用方法，但是在实际开发中，由于对服务依赖的调用可能不止一处，往往一个接口会被多处调用，所以通常都会针对每个微服务自行封装一些客户端类来包装这些依赖服务的调用。所以，Feign在此基础上做了进一步封装，由他来帮助我们定义和实现依赖服务接口的定义，==在Feign的实现下，我们只需要创建一个接口并使用注解的方式来配置它（类似于以前Mapper接口上标注@Mapper注解，现在是一个微服务接口上面标注一个Feign注解即可。）==即可完成对服务提供方的接口绑定，简化了使用SpringCloudRibbon时，自动封装服务调用客户端的开发量。

Feign集成了Ribbon

利用Ribbon维护了MicroServiceCloud-Dept的服务列表信息，并且通过轮询实现了客户端的负载均衡，而与Ribbon不同的是，通过Feign只需要定义服务绑定接口且以声明式的方法，优雅而且简单的实现了服务调用。

3.2 使用步骤

module：springcloud-api的pom.xml文件中添加依赖

<!--Feign-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-feign</artifactId>
    <version>1.4.6.RELEASE</version>
</dependency>

module：springcloud-api，创建service：DeptClientService

@Component
@FeignClient(value = "SPRINGCLOUD-PROVIDER-DEPT")
public interface DeptClientService {

    /**
     * 添加一个部门
     * @param dept 部门实体
     * @return 添加结果
     */
    @PostMapping("/dept/add")
    boolean addDepartment(Dept dept);

    /**
     * 通过id查部门
     * @param id 部门id
     * @return 部门信息
     */
    @GetMapping("/dept/get/{id}")
    Dept queryDeptById(@PathVariable("id") Long id);

    /**
     * 查询所有部门
     * @return 部门列表
     */
    @GetMapping("/dept/list")
    List<Dept> queryAllDept();

}

创建module：springcloud-consumer-dept-feign
pom.xml

<dependencies>
    <!--Feign-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-feign</artifactId>
        <version>1.4.6.RELEASE</version>
    </dependency>
    <!--Ribbon-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-ribbon</artifactId>
        <version>1.4.6.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>

ConfigBean.java

@Configuration
public class ConfigBean {

    /**
     * 配置负载均衡实现RestTemplate
     * 添加@LoadBalanced
     * 基于Ribbon
     */
    @Bean
    @LoadBalanced
    public RestTemplate getRestTemplate() {
        return new RestTemplate();
    }
}

DeptConsumerController.java

@RestController
public class DeptConsumerController {

    @Autowired
    private DeptClientService deptClientService;

    /**
     * 客户端添加一个部门
     *
     * @param dept 部门对象
     * @return 添加结果
     */
    @RequestMapping("/consumer/dept/add")
    public boolean add(Dept dept) {
        return deptClientService.addDepartment(dept);
    }

    /**
     * 通过部门id获取部门信息
     *
     * @param id 部门id
     * @return 部门信息
     */
    @RequestMapping("/consumer/dept/get/{id}")
    public Dept get(@PathVariable("id") Long id) {
        return deptClientService.queryDeptById(id);
    }

    /**
     * 查询所有部门
     *
     * @return 部门列表
     */
    @RequestMapping("/consumer/dept/list")
    public List<Dept> list() {
        return deptClientService.queryAllDept();
    }
}

主启动类：FeignDeptConsumer_80

@SpringBootApplication
@EnableEurekaClient
@EnableFeignClients(basePackages = {"com.example.springcloud"})
public class FeignDeptConsumer_80 {
    public static void main(String[] args) {
        SpringApplication.run(FeignDeptConsumer_80.class,args);
    }
}

application.yml

server:
  port: 80

# Eureka配置
eureka:
  client:
    # 不向Eureka注册自己
    register-with-eureka: false
    # 服务获取地址
    service-url:
      defaultZone: http://localhost:7001/eureka/,http://localhost:7002/eureka/,http://localhost:7003/eureka/

启动7001、7002、7003、8001、8002、8003、feign80
访问地址：http://localhost/consumer/dept/list
- 出现数据

总结：相对于Ribbon，Feign可读性更高，更符合日常开发习惯，但是，它是在Ribbon的基础上加了一层，所以性能会差一点点。