spring boot 2.0.3+spring cloud （Finchley）2、搭建负载均衡Ribbon （Eureka+Ribbon+RestTemplate）

Ribbon是Netflix公司开源的一个负载均衡组件，将负载均衡逻辑封装在客户端中，运行在客户端的进程里。

本例子是在搭建好eureka的基础上进行的，可参考spring boot 2.0.3+spring cloud （Finchley）1、搭建Eureka 以及构建高可用Eureka Server集群

在eureka-client工程中添加一个API接口，来提供服务，新建一个类HiController

@RestController
public class HiController {

    @Value("${server.port}")
    String port;

    @GetMapping("/hi")
    public String Home(@RequestParam String name){
        return "hi "+name+",i am from port:"+port;
    }
}

启动eureka-server，端口8761.启动两个eureka-client实例，端口分别为8762和8763，浏览器访问http://localhost:8761/，显示两个实例已成功注册

启动多个实例的方法为：打开Run|Edit Configurations 选中spring boot下EurekaClientApplication，去掉右边的勾选项Single instance only。在配置文件中设置不同的端口号，分别启动即可。

新建一个Module工程eureka-ribbon-client，作为服务消费者，通过RestTemplate来远程调用eureka-client服务API接口的"/hi"，消费服务。

在pom文件中引入相关依赖，包括主maven工程的pom文件，eureka client起步依赖，由于已经引入了eureka的依赖会自动导入ribbon的起步依赖，web的起步依赖（已在主maven工程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">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.cralor</groupId>
    <artifactId>eureka-ribbon-client</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>eureka-ribbon-client</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>com.cralor</groupId>
        <artifactId>chap6-3-ribbon</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <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-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

在配置文件中做相关配置

server:
  port: 8764
spring:
  application:
    name: eureka-ribbon-client
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/

启动类默认即可。

@SpringBootApplication
public class EurekaRibbonClientApplication {

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

写一个RESTful API接口，调用eureka－client的API接口“/hi”，即消费服务。由于eureka-client为两个实例（端口8762、8763），在调用时希望做到轮流访问这两个实例，这时需要将RestTemplate和Ribbon结合进行负载均衡。只需要在程序的IOC容器中注入一个restTemplate的Bean，并加上@LoadBalanced注解，此时RestTemplate就结合了Ribbon开启了负载均衡功能。

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

编写一个RibbonService类，在该类的hi()方法用restTemplate调用eureka-client的API接口，uri上不需要使用硬编码（如IP地址），只需写服务名eureka-client即可

@Service
public class RibbonService {
    @Autowired
    RestTemplate restTemplate;
    public String hi(String name){
        return restTemplate.getForObject("http://eureka-client/hi?name="+name,String.class);
    }
}

编写一个RibbonController类

@RestController
public class RibbonController {
    @Autowired
    private RibbonService ribbonService;

    @GetMapping("/hi")
    public String hi(@RequestParam(required = false,defaultValue = "cralor") String name){
        return ribbonService.hi(name);
    }   
}

启动eureka-ribbon-client工程，访问http://localhost:8761，显示服务已注册

在浏览器多次访问http://localhost:8764/hi?name=cralor，浏览器会轮流显示如下

                    

 此时负载均衡器已经起了作用。

 LoadBalancerClient  简介

 负载均衡的核心类为LoadBalancerClient,LoadBalancerClient可以获取负载均衡服务提供者的实例信息，在RibbonController中重写一个接口“/testRibbon”，通过LoadBalancerClient去选择一个eureka-client的实例

@RestController
public class RibbonController {

    ...//略
    @Autowired
    private LoadBalancerClient loadBalancer;

    @GetMapping("/testRibbon")
    public String testRibbon(){
        ServiceInstance instance=loadBalancer.choose("eureka-client");
        return instance.getHost()+":"+instance.getPort();
    }
}

重启工程，多次访问http://localhost:8764/testRibbon，浏览器会轮流显示

localhost:8762

localhost:8763

可见LoadBalancerClient的choose("eureka-client")方法可以轮流得到eureka-client的两个实例。

查看官方文档可知，负载均衡器LoadBalancerClient是从eureka client获取服务注册列表信息的，并将该信息缓存了一份，在调用choose()方法时，根据负载均衡策略选择一个服务实例的信息，从而维护了负载均衡。LoadBalancerClient可以不从eureka client获取注册列表信息，这时需要自己维护一份信息。

新建一个工程ribbon-client，同eureka-ribbon-client类似，在配置文件中通过ribbon. eureka. enabled为false来禁止调用eureka client获取注册列表信息，有一个程序名为stores的服务，有两个不同Url地址（example.com和google.com）的服务实例，通过stores. ribbon.listOfServers来配置这些服务实例的Url

server:
  port: 8767
ribbon:
  eureka:
    enabled: false
stores:
  ribbon:
    listOfServers: example.com,google.com

新建一个RestController类

@RestController
public class RibbonController {
    @Autowired
    private LoadBalancerClient loadBalancer;

    @GetMapping("/testRibbon")
    public String testRibbon(){
        ServiceInstance instance=loadBalancer.choose("stores");
        return instance.getHost()+":"+instance.getPort();
    }
}

启动工程，多次访问http://localhost:8767/testRibbon，浏览器会交替显示如下内容

              

现在可以知道，在Ribbon中的负载均衡客户端为LoadBalancerClient 。在spring cloud项目中，负载均衡器Ribbon会默认从Eureka Client 的服务注册列表中获取服务的信息，并缓存一份，根据缓存的信息，通过LoadBalancerClient来选择不同的服务实例，从而实现负载均衡，如果禁止Ribbon从Eureka获取注册列表信息，则需要自己去维护一份服务注册列表信息。根据自己维护的信息，Ribbon也可以实现负载均衡。

 案例代码地址：https://github.com/cralor7/springcloud