Spring Cloud 之 Ribbon

---

前言

Spring Cloud Netflix Ribbon 是Spring Cloud Netflix 子项目的核心组件之一，主要给服务间调用及API网关转发提供负载均衡的功能；

Spring Cloud Netflix Ribbon虽然只是一个工具类框架，它不像服务注册中心、配置中心、API网关那样需要独立部署，但是它几乎存在于每一个Spring Cloud构建的微服务和基础设施中。

微服务间的调用，API网关的请求转发等内容，实际上都是通过Ribbon来实现的，包括Feign，也是基于Ribbon实现的工具。所以，对Spring Cloud Netflix Ribbon的理解和使用，对于我们使用Spring Cloud来构建微服务非常重要。

一、理论部分

1、Spring Cloud Ribbon的使用

通过Spring Cloud Ribbon的封装，我们在微服务架构中使用客户端负载均衡调用非常简单，只需要如下两步：

• 服务提供者只需要启动多个服务实例并注册到一个注册中心或是多个相关联的服务注册中心 。

• 服务消费者直接通过调用被@LoadBalanced注解修饰过的RestTemplate来实现面向服务的接口调用。

这样，我们就可以将服务提供者的高可用以及服务消费者的负载均衡调用一起实现了

1.2、Ribbon的常用配置

全局配置

ribbon:
  ConnectTimeout: 1000 #服务请求连接超时时间（毫秒）
  ReadTimeout: 3000 #服务请求处理超时时间（毫秒）
  OkToRetryOnAllOperations: true #对超时请求启用重试机制
  MaxAutoRetriesNextServer: 1 #切换重试实例的最大个数
  MaxAutoRetries: 1 # 切换实例后重试最大次数
  NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule #修改负载均衡算法

指定服务进行配置
与全局配置的区别就是ribbon节点挂在服务名称下面，如下是对ribbon-service调用user-service时的单独配置。

user-service:
  ribbon:
    ConnectTimeout: 1000 #服务请求连接超时时间（毫秒）
    ReadTimeout: 3000 #服务请求处理超时时间（毫秒）
    OkToRetryOnAllOperations: true #对超时请求启用重试机制
    MaxAutoRetriesNextServer: 1 #切换重试实例的最大个数
    MaxAutoRetries: 1 # 切换实例后重试最大次数
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule #修改负载均衡算法

1.3、Ribbon的负载均衡策略

所谓的负载均衡策略，就是当A服务调用B服务时，此时B服务有多个实例，这时A服务以何种方式来选择调用的B实例，ribbon可以选择以下几种负载均衡策略。

• com.netflix.loadbalancer.RandomRule：从提供服务的实例中以随机的方式；
• com.netflix.loadbalancer.RoundRobinRule：以线性轮询的方式，就是维护一个计数器，从提供服务的实例中按顺序选取，第一次选第一个，第二次选第二个，以此类推，到最后一个以后再从头来过；
• com.netflix.loadbalancer.RetryRule：在RoundRobinRule的基础上添加重试机制，即在指定的重试时间内，反复使用线性轮询策略来选择可用实例；
• com.netflix.loadbalancer.WeightedResponseTimeRule：对RoundRobinRule的扩展，响应速度越快的实例选择权重越大，越容易被选择；
• com.netflix.loadbalancer.BestAvailableRule：选择并发较小的实例；
• com.netflix.loadbalancer.AvailabilityFilteringRule：先过滤掉故障实例，再选择并发较小的实例；
• com.netflix.loadbalancer.ZoneAwareLoadBalancer：采用双重过滤，同时过滤不是同一区域的实例和故障实例，选择并发较小的实例。

二、实践部分

1、创建一个ribbon-user-service模块

用于给Ribbon提供服务调用。

1.1 添加依赖

<?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>eureka</artifactId>
        <groupId>com.hjl</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>ribbon-service</artifactId>

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

    </dependencies>

</project>

1.2 编写用户实体类

package com.hjl.ribbon_service.entity;

/**
 * TODO：
 *
 * @Version 1.0
 * @Author HJL
 * @Date 2021/12/28 13:28
 */
public class User {

    private Long id;
    private String username;
    private String password;

    public User() {
    }

    public User(Long id, String username, String password) {
        this.id = id;
        this.username = username;
        this.password = password;
    }

    public Long getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

1.3 编写统一返回前端的响应类

package com.hjl.ribbon_service.common;

/**
 * TODO：
 *
 * @Version 1.0
 * @Author HJL
 * @Date 2021/12/28 13:29
 */
public class Result<T> {

    private T data;

    private String message;

    private int code;

    public Result() {
    }

    public Result(T data, String message, int code) {
        this.data = data;
        this.message = message;
        this.code = code;
    }

    public Result(String message, Integer code) {
        this(null, message, code);
    }

    public Result(T data) {
        this(data, "操作成功", 200);
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public String getMessage() {
        return message;
    }

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

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }
}

1.5 编写控制器

package com.hjl.ribbon_user.controller;

import com.hjl.ribbon_user.common.Result;
import com.hjl.ribbon_user.entity.User;
import com.hjl.ribbon_user.service.UserService;
import com.hjl.ribbon_user.service.impl.UserServiceImpl;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * TODO：
 *
 * @Version 1.0
 * @Author HJL
 * @Date 2021/12/28 13:30
 */
@RestController
@RequestMapping("/user")
public class UserController {

    private static final Logger LOGGER = LoggerFactory.getLogger(UserController.class);

    @Autowired
    private UserService userService;

    @PostMapping("/insert")
    public Result insert(@RequestBody User user) {
        userService.insert(user);
        return new Result("操作成功", 200);
    }

    @GetMapping("/{id}")
    public Result<User> getUser(@PathVariable Long id) {
        User user = userService.getUser(id);
        LOGGER.info("根据id获取用户信息，用户名称为：{}",user.getUsername());
        return new Result<User>(user);
    }

    @GetMapping("/listUsersByIds")
    public Result<List<User>> listUsersByIds(@RequestParam List<Long> ids) {
        List<User> userList= userService.listUsersByIds(ids);
        LOGGER.info("根据ids获取用户信息，用户列表为：{}",userList);
        return new Result<List<User>>(userList);
    }

    @GetMapping("/getByUsername")
    public Result<User> getByUsername(@RequestParam String username) {
        User user = userService.getByUsername(username);
        return new Result<User>(user);
    }

    @PostMapping("/update")
    public Result update(@RequestBody User user) {
        userService.update(user);
        return new Result("操作成功", 200);
    }

    @PostMapping("/delete/{id}")
    public Result delete(@PathVariable Long id) {
        userService.delete(id);
        return new Result("操作成功", 200);
    }

}

1.6 编写Mapper

package com.hjl.ribbon_user.mapper;

import com.hjl.ribbon_user.entity.User;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;

/**
 * TODO：
 *
 * @Version 1.0
 * @Author DELL
 * @Date 2021/12/28 14:01
 */
@Mapper
public interface UserMapper {

    @Insert("insert into user (id,name,password) value(#{id},#{username},#{password})")
    void insert(@Param("user") User user);

    @Select("select id,username,password from user where id= #{id}")
    User getUser(Long id);

	...
}

1.7 编写业务层接口及实现类

接口

package com.hjl.ribbon_user.service;

import com.hjl.ribbon_user.entity.User;

import java.util.List;

/**
 * TODO：
 *
 * @Version 1.0
 * @Author DELL
 * @Date 2021/12/28 13:50
 */
public interface UserService {

    public void insert(User user);

    public User getUser(Long id);

    List<User> listUsersByIds(List<Long> ids);

    User getByUsername(String name);

    void update(User user);

    void delete(Long id);


}

实现类

package com.hjl.ribbon_user.service.impl;

import com.hjl.ribbon_user.entity.User;
import com.hjl.ribbon_user.mapper.UserMapper;
import com.hjl.ribbon_user.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * TODO：
 *
 * @Version 1.0
 * @Author HJL
 * @Date 2021/12/28 13:49
 */
@Service
public class UserServiceImpl implements UserService {


    @Autowired
    UserMapper userMapper;

    @Override
    public void insert(User user) {
        userMapper.insert(user);
    }

    @Override
    public User getUser(Long id) {
        return userMapper.getUser(id);
//        return null;
    }

    @Override
    public List<User> listUsersByIds(List<Long> ids) {
        return null;
    }

    @Override
    public User getByUsername(String name) {
        return null;
    }

    @Override
    public void update(User user) {

    }

    @Override
    public void delete(Long id) {

    }
}

1.8 编写启动类RibbonUserServiceApplication

package com.hjl.ribbon_user;

//import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScans;

/**
 * TODO：
 *
 * @Version 1.0
 * @Author HJL
 * @Date 2021/12/28 13:14
 */
@EnableEurekaClient
@SpringBootApplication
public class RibbonUserServiceApplication {

    public static void main(String[] args) {
        SpringApplication.run(RibbonUserServiceApplication.class,args);
    }
}

1.9 编写配置文件application.properties

配置文件为：

#端口号
server.port=1005

#应用名称
spring.application.name=user-service

#实例ID
eureka.instance.instance-id=${spring.application.name}:${spring.cloud.client.ip-address}:${server.port}

eureka.client.register-with-eureka=true
eureka.client.fetch-registry=true

#client.service-url.defaultZone指定注册中心地址
eureka.client.service-url.defaultZone=http://root:root@localhost:1001/eureka,http://root:root@localhost:1010/eureka

#用户数据库配置
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/mydb?serverTimezone=UTC&useUnicode=true&characterEncoding=UTF-8&userSSL=false&autoReconnect=true
spring.datasource.username=root
spring.datasource.password=123456

2、创建一个ribbon-service服务

2.1 编写Ribbon配置类

package com.hjl.ribbon_service.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;

/**
 * TODO：
 *
 * @Version 1.0
 * @Author HJL
 * @Date 2021/12/28 13:38
 */
@Configuration
public class RibbonConfig {

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

}

2.2 编写控制器

package com.hjl.ribbon_service.controller;

import com.hjl.ribbon_service.common.Result;
import com.hjl.ribbon_service.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.client.RestTemplate;

/**
 * TODO：
 *
 * @Version 1.0
 * @Author HJL
 * @Date 2021/12/28 13:40
 */
@RestController
@RequestMapping("/user")
public class UserRibbonController {

    @Autowired
    private RestTemplate restTemplate;

    @Value("${service-url.user-service}")
    private String userServiceUrl;

    @GetMapping("/{id}")
    public Result getUser(@PathVariable Long id) {
        return restTemplate.getForObject(userServiceUrl + "/user/{1}", Result.class, id);
    }

    @GetMapping("/getByUsername")
    public Result getByUsername(@RequestParam String username) {
        return restTemplate.getForObject(userServiceUrl + "/user/getByUsername?username={1}", Result.class, username);
    }

    @GetMapping("/getEntityByUsername")
    public Result getEntityByUsername(@RequestParam String username) {
        ResponseEntity<Result> entity = restTemplate.getForEntity(userServiceUrl + "/user/getByUsername?username={1}", Result.class, username);
        if (entity.getStatusCode().is2xxSuccessful()) {
            return entity.getBody();
        } else {
            return new Result("操作失败", 500);
        }
    }

    @PostMapping("/insert")
    public Result insert(@RequestBody User user) {
        return restTemplate.postForObject(userServiceUrl + "/user/insert", user, Result.class);
    }

    @PostMapping("/update")
    public Result update(@RequestBody User user) {
        return restTemplate.postForObject(userServiceUrl + "/user/update", user, Result.class);
    }

    @PostMapping("/delete/{id}")
    public Result delete(@PathVariable Long id) {
        return restTemplate.postForObject(userServiceUrl + "/user/delete/{1}", null, Result.class, id);
    }

}

2.3 编写启动类RibbonServiceApplication

package com.hjl.ribbon_service;

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

/**
 * TODO：
 *
 * @Version 1.0
 * @Author HJL
 * @Date 2021/12/28 13:43
 */

@EnableEurekaClient
@SpringBootApplication
public class RibbonServiceApplication {

    public static void main(String[] args) {
        SpringApplication.run(RibbonServiceApplication.class,args);
    }
}

2.4 编写配置文件

server.port=1006

spring.application.name=ribbon-service

eureka.client.register-with-eureka=true
eureka.client.fetch-registry=true

eureka.client.service-url.defaultZone=http://root:root@localhost:1001/eureka,http://root:root@localhost:1010/eureka

service-url.user-service=http://user-service

3、启动服务

3.1 启动ribbon-user-service 服务

另复制一份配置文件启动另一个端口1007；

3.2 启动ribbon-service服务

在eureka服务中已经可以看到成功注册；

4、测试

多次访问http://127.0.0.1:1006/user/1，可以看到ribbon-user-service服务的两个端口1005、1007依次处理请求；



说明负载均衡功能已成功运行生效。

总结

在微服务架构中，很多服务都会部署多个，其他服务去调用该服务的时候，如何保证负载均衡是个不得不去考虑的问题。负载均衡可以增加系统的可用性和扩展性，当我们使用RestTemplate来调用其他服务时，Ribbon可以很方便的实现负载均衡功能。