Spring Cloud中服务的发现与消费

负载均衡​​​​​​​

如何实现

服务的发现和消费实际上是两个行为，这两个行为要由不同的对象来完成：服务的发现由Eureka客户端来完成，而服务的消费由Ribbon来完成。Ribbo是一个基于HTTP和TCP的客户端负载均衡器，当我们将Ribbon和Eureka一起使用时，Ribbon会从Eureka注册中心去获取服务端列表，然后进行轮询访问以到达负载均衡的作用，服务端是否在线这些问题则交由Eureka去维护。OK，下面我们将通过一个简单的案例，来看看如何实现服务的发现与消费。

开启注册中心

这里的服务注册中心我们还是使用上篇文章中创建的eureka-server工程，为了测试方便，我这里直接启动一个单节点工程就OK了，启动结果如下：

注册服务

注册服务也和上篇文章一样，也使用provider工程，不同的是，这里我将provider工程打成一个jar包，然后用命令启动，启动两个实例，方便我一会观察负载均衡的效果。打成jar的过程很简单，双击package，然后在target目录下找到对应的jar，如下：

然后通过下面两行命令启动两个服务提供者的实例，如下：

java -jar provider-0.0.1-SNAPSHOT.jar --server.port=8080

java -jar provider-0.0.1-SNAPSHOT.jar --server.port=8081

此时，在服务注册中心我们可以看到有两个服务提供者注册成功了，如下：

OK,如此之后，服务提供者就准备好了，接下来实现服务消费者。

开发客户端

创建Spring Boot项目

首先创建一个Spring Boot项目，然后添加Eureka和Ribbon依赖，pom.xml文件如下：

<?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>org.sang</groupId>
    <artifactId>ribbon-consumer</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

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

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.6.RELEASE</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>
        <spring-cloud.version>Dalston.SR3</spring-cloud.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-ribbon</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

这里重点是添加了spring-cloud-starter-eureka和spring-cloud-starter-ribbon依赖。

配置启动入口类

入口类上我们需要做两件事：

1.亮明Eureka客户端身份  

首先在入口类上添加@EnableDiscoveryClient注解，表示该应用是一个Eureka客户端应用，这样该应用就自动具备了发现服务的能力。

2.提供RestTemplate的Bean  

RestTemplate可以帮助我们发起一个GET或者POST请求，这个我们在后文会详细解释，这里我们只需要提供一个RestTemplate  Bean就可以了，在提供Bean的同时，添加@LoadBalanced注解，表示开启客户端负载均衡。

OK，基于以上两点，我们的入口类如下：

@SpringBootApplication
@EnableDiscoveryClient
public class RibbonConsumerApplication {

    public static void main(String[] args) {
        SpringApplication.run(RibbonConsumerApplication.class, args);
    }
    @LoadBalanced
    @Bean
    RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

创建Controller

创建一个Controller类，并向Controller类中注入RestTemplate对象，同时在Controller中提供一个名为/ribbon-consumer的接口，在该接口中，我们通过刚刚注入的restTemplate来实现对HELLO-SERVICE服务提供的/hello接口进行调用（上篇文章中我们有详细介绍HELLO-SERVICE的实现）。在调用的过程中，我们的访问地址是HELLO-SERVICE，而不是一个具体的地址。OK，基于以上理解，我们的Controller如下：

@RestController
public class ConsumerController {
    @Autowired
    RestTemplate restTemplate;
    @RequestMapping(value = "/ribbon-consumer",method = RequestMethod.GET)
    public String helloController() {
        return restTemplate.getForEntity("http://HELLO-SERVICE/hello", String.class).getBody();
    }
}

配置服务注册中心的位置

最后我们需要在application.properties中配置服务注册中心的位置，如下：

spring.application.name=ribbon-consumer  
server.port=9000  
eureka.client.service-url.defaultZone=http://peer1:1111/eureka

注意服务消费者的端口号不要和前面的端口号冲突。

启动并测试

此时我们就可以启动我的客户端了，启动之后，我们首先在Eureka中看到了我的客户端，如下：

然后我们向localhost:9000/ribbon-consumer地址发起请求，就可以看到provider工程中/hello接口返回的Hello World，如下：

在前面启动了两个provider实例，看下面一张图：

上面那个日志是由端口号为8081的provider打印出来的，下面的日志是由端口号为8080的provider打印出来的，说明我们这里的负载均衡已经起作用了。此时我们观察客户端的日志，如下：

Ribbon输出了当前客户端维护的HELLO-SERVICE的服务列表情况，每一个provider的位置都展示出来，Ribbon就是按照这个列表进行轮询，进而实现基于客户端的负载均衡。同时这里的日志还输出了其他信息，比如各个实例的请求总数量，第一次连接信息，上一次连接信息以及总的请求失败数量等。

原文地址：https://mp.weixin.qq.com/s/GoIZdwt5gJje-ZWMBUoBPw