失眠网 > 开启springcloud全家桶3：服务注册中心erueka原理与实践

开启springcloud全家桶3：服务注册中心erueka原理与实践

时间：2020-10-08 14:13:27

Erueka 概念

一、Erueka 组件

Eureka 由两个组件组成：Eureka 服务端和Eureka 客户端。

1.1、Eureka Server( 服务端)

Eureka Server( 服务端)就是注册中心

Eureka 服务端担任注册中心的角色，提供了服务的发现和注册功能。

1.2、Eureka Client (客户端)

Eureka Client (客户端) 是一个 java 客户端、用来简化与服务端的交互、作为轮询负载均衡器，并提供服务的故障切换支持。

Eureka 客户端分为Service Provider (服务提供者) 和Service Consumer (服务调用者)

Service Provider 服务提供者, 将自身的服务注册到Eureka Server, 同时通过心跳检查服务的运行状态

Service Consumer 服务调用者, 从Eureka Server 得到注册的服务列表,找到对应的服务地址在调用并使用

二、Erueka 工作原理

2.1 、Eureka Server：注册中心服务端

注册中心提供三个功能：服务注册、提供注册表、同步服务

2.1.1、服务注册

服务提供者启动时，会通过 Eureka Client 向 Eureka Server 注册信息，Eureka Server 会存储该服务的信息，Eureka Server 内部有二层缓存机制来维护整个注册表

2.1.2、提供注册表

服务消费者在调用服务时，如果 Eureka Client 没有缓存注册表的话，会从 Eureka Server 获取最新的注册表

2.1.3、同步服务

Eureka Client 通过注册、心跳机制和 Eureka Server 同步当前客户端的状态。

2.2、Eureka Client：注册中心客户端

服务的提供者，将自身注册到注册中心，服务提供者也是一个 Eureka Client。当 Eureka Client 向 Eureka Server 注册时，它提供自身的元数据，比如 IP 地址、端口，运行状况指示符 URL，主页等。

2.2.1、Register: 服务注册

2.2.2、Renew: 服务续约

Eureka Client 会每隔 30 秒发送一次心跳来续约。通过续约来告知 Eureka Server 该 Eureka Client 运行正常，没有出现问题。默认情况下，如果 Eureka Server 在 90 秒内没有收到 Eureka Client 的续约，Server 端会将实例从其注册表中删除，此时间可配置，一般情况不建议更改。

（微服务网络地址发生变更(例如实例增减或者IP端口发生变化等)，会重新注册到服务发现组件上，使用这种方式，可以避免因网络变化导致服务之间的通讯停止，服务消费者也无须人工的修改网络地址。）

2.2.3 、Eviction 服务剔除

当 Eureka Client 和 Eureka Server 不再有心跳时，Eureka Server 会将该服务实例从服务注册列表中删除，即服务剔除。

2.3.4、Cancel: 服务下线

Eureka Client 在程序关闭时向 Eureka Server 发送取消请求。发送请求后，该客户端实例信息将从 Eureka Server 的实例注册表中删除。该下线请求不会自动完成，它需要调用以下内容：

2.2.5GetRegisty: 获取注册列表信息

Eureka Client 从服务器获取注册表信息，并将其缓存在本地。客户端会使用该信息查找其他服务，从而进行远程调用。该注册列表信息定期（每30秒钟）更新一次。每次返回注册列表信息可能与 Eureka Client 的缓存信息不同，Eureka Client 自动处理。

如果由于某种原因导致注册列表信息不能及时匹配，Eureka Client 则会重新获取整个注册表信息。 Eureka Server 缓存注册列表信息，整个注册表以及每个应用程序的信息进行了压缩，压缩内容和没有压缩的内容完全相同。Eureka Client 和 Eureka Server 可以使用 JSON/XML 格式进行通讯。在默认情况下 Eureka Client 使用压缩 JSON 格式来获取注册列表的信息。

2.2.6、Remote Call: 远程调用

当 Eureka Client 从注册中心获取到服务提供者信息后，就可以通过 Http 请求调用对应的服务；服务提供者有多个时，Eureka Client 客户端会通过 Ribbon 自动进行负载均衡。

2.3、自我保护机制

默认情况下，如果 Eureka Server 在一定的 90s 内没有接收到某个微服务实例的心跳，会注销该实例。但是在微服务架构下服务之间通常都是跨进程调用，网络通信往往会面临着各种问题，比如微服务状态正常，网络分区故障，导致此实例被注销。

固定时间内大量实例被注销，可能会严重威胁整个微服务架构的可用性。为了解决这个问题，Eureka 开发了自我保护机制，那么什么是自我保护机制呢？

Eureka Server 在运行期间会去统计心跳失败比例在 15 分钟之内是否低于 85%，如果低于 85%，Eureka Server 即会进入自我保护机制。

Eureka Server 进入自我保护机制，会出现以下几种情况：

(1 Eureka 不再从注册列表中移除因为长时间没收到心跳而应该过期的服务

(2 Eureka 仍然能够接受新服务的注册和查询请求，但是不会被同步到其它节点上(即保证当前节点依然可用)

(3 当网络稳定时，当前实例新的注册信息会被同步到其它节点中

Eureka 自我保护机制是为了防止误杀服务而提供的一个机制。当个别客户端出现心跳失联时，则认为是客户端的问题，剔除掉客户端；当 Eureka 捕获到大量的心跳失败时，则认为可能是网络问题，进入自我保护机制；当客户端心跳恢复时，Eureka 会自动退出自我保护机制。

如果在保护期内刚好这个服务提供者非正常下线了，此时服务消费者就会拿到一个无效的服务实例，即会调用失败。对于这个问题需要服务消费者端要有一些容错机制，如重试，断路器等。

三、Erueka集群原理

/qwe86314/article/details/94552801

四、erueka 工作流程

/qwe86314/article/details/94552801

五、搭建 Erueka 工程

/Jomini/p/13407292.html

Eureka 工作原理

上节内容为大家介绍了，注册中心 Eureka 产品的使用，以及如何利用 Eureka 搭建单台和集群的注册中心。这节课我们来继续学习 Eureka，了解它的相关概念、工作流程机制等。

Eureka 作为 Spring Cloud 体系中最核心、默认的注册中心组件，研究它的运行机制，有助于我们在工作中更好地使用它。

Eureka 核心概念

回到上节的服务注册调用示意图，服务提供者和服务的消费者，本质上也是 Eureka Client 角色。整体上可以分为两个主体：Eureka Server 和 Eureka Client。

Eureka Server：注册中心服务端

注册中心服务端主要对外提供了三个功能：

服务注册

服务提供者启动时，会通过 Eureka Client 向 Eureka Server 注册信息，Eureka Server 会存储该服务的信息，Eureka Server 内部有二层缓存机制来维护整个注册表

提供注册表

服务消费者在调用服务时，如果 Eureka Client 没有缓存注册表的话，会从 Eureka Server 获取最新的注册表

同步状态

Eureka Client 通过注册、心跳机制和 Eureka Server 同步当前客户端的状态。

Eureka Client：注册中心客户端

Eureka Client 是一个 Java 客户端，用于简化与 Eureka Server 的交互。Eureka Client 会拉取、更新和缓存 Eureka Server 中的信息。因此当所有的 Eureka Server 节点都宕掉，服务消费者依然可以使用缓存中的信息找到服务提供者，但是当服务有更改的时候会出现信息不一致。

Renew: 服务续约

服务续约的两个重要属性

服务续约任务的调用间隔时间，默认为30秒

eureka.instance.lease-renewal-interval-in-seconds=30

服务失效的时间，默认为90秒。

eureka.instance.lease-expiration-duration-in-seconds=90

Eviction 服务剔除

当 Eureka Client 和 Eureka Server 不再有心跳时，Eureka Server 会将该服务实例从服务注册列表中删除，即服务剔除。

Cancel: 服务下线

DiscoveryManager.getInstance().shutdownComponent()；

GetRegisty: 获取注册列表信息

获取服务是服务消费者的基础，所以必有两个重要参数需要注意：

# 启用服务消费者从注册中心拉取服务列表的功能

eureka.client.fetch-registry=true

# 设置服务消费者从注册中心拉取服务列表的间隔

eureka.client.registry-fetch-interval-seconds=30

Remote Call: 远程调用

自我保护机制

固定时间内大量实例被注销，可能会严重威胁整个微服务架构的可用性。为了解决这个问题，Eureka 开发了自我保护机制，那么什么是自我保护机制呢？

Eureka Server 在运行期间会去统计心跳失败比例在 15 分钟之内是否低于 85%，如果低于 85%，Eureka Server 即会进入自我保护机制。

Eureka Server 触发自我保护机制后，页面会出现提示：

Eureka Server 进入自我保护机制，会出现以下几种情况：

(1 Eureka 不再从注册列表中移除因为长时间没收到心跳而应该过期的服务

(2 Eureka 仍然能够接受新服务的注册和查询请求，但是不会被同步到其它节点上(即保证当前节点依然可用)

(3 当网络稳定时，当前实例新的注册信息会被同步到其它节点中

通过在 Eureka Server 配置如下参数，开启或者关闭保护机制，生产环境建议打开：

eureka.server.enable-self-preservation=true

Eureka 集群原理

再来看看 Eureka 集群的工作原理。我们假设有三台 Eureka Server 组成的集群，第一台 Eureka Server 在北京机房，另外两台 Eureka Server 在深圳和西安机房。这样三台 Eureka Server 就组建成了一个跨区域的高可用集群，只要三个地方的任意一个机房不出现问题，都不会影响整个架构的稳定性。

从图中可以看出 Eureka Server 集群相互之间通过 Replicate 来同步数据，相互之间不区分主节点和从节点，所有的节点都是平等的。在这种架构中，节点通过彼此互相注册来提高可用性，每个节点需要添加一个或多个有效的 serviceUrl 指向其他节点。

如果某台 Eureka Server 宕机，Eureka Client 的请求会自动切换到新的 Eureka Server 节点。当宕机的服务器重新恢复后，Eureka 会再次将其纳入到服务器集群管理之中。当节点开始接受客户端请求时，所有的操作都会进行节点间复制，将请求复制到其它 Eureka Server 当前所知的所有节点中。

另外 Eureka Server 的同步遵循着一个非常简单的原则：只要有一条边将节点连接，就可以进行信息传播与同步。所以，如果存在多个节点，只需要将节点之间两两连接起来形成通路，那么其它注册中心都可以共享信息。每个 Eureka Server 同时也是 Eureka Client，多个 Eureka Server 之间通过 P2P 的方式完成服务注册表的同步。

Eureka Server 集群之间的状态是采用异步方式同步的，所以不保证节点间的状态一定是一致的，不过基本能保证最终状态是一致的。

Eureka 分区

Eureka 提供了 Region 和 Zone 两个概念来进行分区，这两个概念均来自于亚马逊的 AWS:

region：可以理解为地理上的不同区域，比如亚洲地区，中国区或者深圳等等。没有具体大小的限制。根据项目具体的情况，可以自行合理划分 region。

zone：可以简单理解为 region 内的具体机房，比如说 region 划分为深圳，然后深圳有两个机房，就可以在此 region 之下划分出 zone1、zone2 两个 zone。

上图中的 us-east-1c、us-east-1d、us-east-1e 就代表了不同的 Zone。Zone 内的 Eureka Client 优先和 Zone 内的 Eureka Server 进行心跳同步，同样调用端优先在 Zone 内的 Eureka Server 获取服务列表，当 Zone 内的 Eureka Server 挂掉之后，才会从别的 Zone 中获取信息。

Eurka 保证 AP

Eureka Server 各个节点都是平等的，几个节点挂掉不会影响正常节点的工作，剩余的节点依然可以提供注册和查询服务。而 Eureka Client 在向某个 Eureka 注册时，如果发现连接失败，则会自动切换至其它节点。只要有一台 Eureka Server 还在，就能保证注册服务可用(保证可用性)，只不过查到的信息可能不是最新的(不保证强一致性)。

Eurka 工作流程

了解完 Eureka 核心概念，自我保护机制，以及集群内的工作原理后，我们来整体梳理一下 Eureka 的工作流程：

1、Eureka Server 启动成功，等待服务端注册。在启动过程中如果配置了集群，集群之间定时通过 Replicate 同步注册表，每个 Eureka Server 都存在独立完整的服务注册表信息

2、Eureka Client 启动时根据配置的 Eureka Server 地址去注册中心注册服务

3、Eureka Client 会每 30s 向 Eureka Server 发送一次心跳请求，证明客户端服务正常

4、当 Eureka Server 90s 内没有收到 Eureka Client 的心跳，注册中心则认为该节点失效，会注销该实例

5、单位时间内 Eureka Server 统计到有大量的 Eureka Client 没有上送心跳，则认为可能为网络异常，进入自我保护机制，不再剔除没有上送心跳的客户端

6、当 Eureka Client 心跳请求恢复正常之后，Eureka Server 自动退出自我保护模式

7、Eureka Client 定时全量或者增量从注册中心获取服务注册表，并且将获取到的信息缓存到本地

8、服务调用时，Eureka Client 会先从本地缓存找寻调取的服务。如果获取不到，先从注册中心刷新注册表，再同步到本地缓存

9、Eureka Client 获取到目标服务器信息，发起服务调用

10、Eureka Client 程序关闭时向 Eureka Server 发送取消请求，Eureka Server 将实例从注册表中删除

这就是Eurka基本工作流程

总结

讲了 Eureka 核心概念、Eureka 自我保护机制和 Eureka 集群原理。通过分析 Eureka 工作原理，我可以明显地感觉到 Eureka 的设计之巧妙，通过一些列的机制，完美地解决了注册中心的稳定性和高可用性。

Eureka 为了保障注册中心的高可用性，容忍了数据的非强一致性，服务节点间的数据可能不一致， Client-Server 间的数据可能不一致。比较适合跨越多机房、对注册中心服务可用性要求较高的使用场景。

前言

1，什么是Eureka，什么是服务注册与发现

Spring Boot作为目前最火爆的web框架。那么它与Eureka又有什么关联呢？

Eureka是Netflix开源的一个RESTful服务，主要用于服务的注册发现。

Eureka由两个组件组成：Eureka服务器和Eureka客户端。Eureka服务器用作服务注册服务器。

Eureka客户端是一个java客户端，用来简化与服务器的交互、作为轮询负载均衡器，并提供服务的故障切换支持。

Netflix在其生产环境中使用的是另外的客户端，它提供基于流量、资源利用率以及出错状态的加权负载均衡。

2，先创建一个Eureka-Server服务注册中心

这里需要用到spring-cloud的Eureka模块，他是一个服务的注册和发现模块

如图我们先new一个Spring-boot工程引入Eureka Server

Next>>>>Finish完成

我们来看看构建好的Eureka-Server的pom.xml代码

<?xml version="1.0" encoding="UTF-8"?><project xmlns="/POM/4.0.0" xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.eureka</groupId><artifactId>server</artifactId><version>0.0.1-SNAPSHOT</version><packaging>jar</packaging><name>server</name><description>Demo project for Spring Boot</description><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.0.2.RELEASE</version><relativePath/> </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>Finchley.RC2</spring-cloud.version></properties><dependencies><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-netflix-eureka-server</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-autoconfigure</artifactId></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><repositories><repository><id>spring-milestones</id><name>Spring Milestones</name><url>https://repo.spring.io/milestone</url><snapshots><enabled>false</enabled></snapshots></repository></repositories></project>

我们看到这里与普通的Spring-boot项目不同的是，这里引用了一个Eureka-Server包。

那么我们怎么使用它呢，怎么启动它呢？

这里只需要启动一个注解就可以啦，我们在Spring-Boot工程的启动类上加>>>>>>

@EnableEurekaServer

代码如下：

package com.eureka.server;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;import org.flix.eureka.server.EnableEurekaServer;/*** 启动一个服务注册中心*/@EnableEurekaServer@SpringBootApplicationpublic class ServerApplication {

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

}

差点忘了，我们还需要配置application.yml

Eureka是一个高可用的组件，每一个实例注册之后需要向注册中心发送心跳包，在默认情况下erureka server也是一个eureka client ,必须要指定一个 server。

eureka server的配置文件appication.yml：

server:port: 8081 #服务注册中心端口号eureka:instance:hostname: 127.0.0.1 #服务注册中心IP地址client:registerWithEureka: false #是否向服务注册中心注册自己fetchRegistry: false #是否检索服务serviceUrl: #服务注册中心的配置内容，指定服务注册中心的位置defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

我们来启动一下吧

我们在浏览器上输入http://127.0.0.1:8081

我们可以看到它的可视化界面

细心的朋友会发现，这里没有发现服务？？？Noinstance available

why？因为我们还没有服务向注册中心注册服务，所以找不到啊。

3，先创建一个Eureka-Client客户端也就是服务提供者

客户端在向注册中心它会提供一些元数据，例如主机和端口，URL，主页等。Eureka server 从每个client实例接收心跳消息。如果心跳超时，则通常将该实例从注册server中删除。

创建客户端和服务端差不多，只是启动注解有点不一样，还有yml配置文件

Next>>>Finish完成啦

打开会发现pom.xml其实和Server注册中心的类似

<?xml version="1.0" encoding="UTF-8"?><project xmlns="/POM/4.0.0" xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.eureka</groupId><artifactId>provider</artifactId><version>0.0.1-SNAPSHOT</version><packaging>jar</packaging><name>provider</name><description>Demo project for Spring Boot</description><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.0.2.RELEASE</version><relativePath/> </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>Finchley.RC2</spring-cloud.version></properties><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-server</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><repositories><repository><id>spring-milestones</id><name>Spring Milestones</name><url>https://repo.spring.io/milestone</url><snapshots><enabled>false</enabled></snapshots></repository></repositories></project>

怎么证明它是Client呢

很简单

在Spring-boot的启动类上通过注解@EnableEurekaClient 表明自己是一个eurekaclient.

package com.eureka.provider;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;import org.flix.eureka.EnableEurekaClient;import org.springframework.web.bind.annotation.GetMapping;import org.springframework.web.bind.annotation.RequestParam;import org.springframework.web.bind.annotation.ResponseBody;import org.springframework.web.bind.annotation.RestController;import java.util.HashMap;import java.util.Map;/*** Eureka客户端*/@RestController@EnableEurekaClient@SpringBootApplicationpublic class ProviderApplication {public static void main(String[] args) {SpringApplication.run(ProviderApplication.class, args);}/*** 假如这个客户端要提供一个getUser的方法* @return*/@GetMapping(value = "/getUser")@ResponseBodypublic Map<String,Object> getUser(@RequestParam Integer id){Map<String,Object> data = new HashMap<>();data.put("id",id);data.put("userName","admin");data.put("from","provider-A");return data;}}

虽然加好了@EnableEurekaClient，总感觉差点什么，对了，配置文件yml

eureka:client:serviceUrl: #注册中心的注册地址defaultZone: http://127.0.0.1:8081/eureka/server:port: 8082 #服务端口号spring:application:name: service-provider #服务名称--调用的时候根据名称来调用该服务的方法

我们来启动看看吧

我们看到这个客户端已经向注册中心注册服务了，那么我们打开Eureka-server

我们看到我们启动的服务是不是加进去了呢

我们看到我们的服务是不是加进去了呢。

那么有人会问，那一大堆飙红的什么意思啊。因为注册的服务都是高可用的，这里只检测到一个服务，产生的预警，不影响使用，等下我们启动多个实例就不会了。

我们先来测试下客户端的方法是否可用

显然是没有问题，那么我们提供好了服务，sei来消费呢？

下面我们就来建立一个消费者

为了更简单易懂，我还是一步一步出图吧。

来，贴上pom.xml

<?xml version="1.0" encoding="UTF-8"?><project xmlns="/POM/4.0.0" xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion>

<groupId>com.eureka</groupId>

<artifactId>consumer</artifactId>

<version>0.0.1-SNAPSHOT</version>

<packaging>jar</packaging>

<name>consumer</name>

<description>Demo project for Spring Boot</description>

<parent>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-parent</artifactId>

<version>2.0.2.RELEASE</version>

<relativePath/> 

</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>Finchley.RC2</spring-cloud.version>

</properties>

<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-server</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>

<repositories>

<repository>

<id>spring-milestones</id>

<name>Spring Milestones</name>

<url>https://repo.spring.io/milestone</url>

<snapshots>

<enabled>false</enabled>

</snapshots>

</repository>

</repositories>

</project>

主要是启动类，里面内容就丰富啦，都在注释里

package com.eureka.consumer;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

import org.springframework.cloud.client.loadbalancer.LoadBalanced;

import org.flix.eureka.EnableEurekaClient;

import org.springframework.context.annotation.Bean;

import org.springframework.web.bind.annotation.GetMapping;

import org.springframework.web.bind.annotation.RequestParam;

import org.springframework.web.bind.annotation.ResponseBody;

import org.springframework.web.bind.annotation.RestController;

import org.springframework.web.client.RestTemplate;

import java.util.HashMap;

import java.util.Map;

/**

* Eureka客户端-消费者

*/

@RestController

@EnableEurekaClient

@SpringBootApplication

public class ConsumerApplication {

@Autowired

RestTemplate restTemplate;

public static void main(String[] args) {

SpringApplication.run(ConsumerApplication.class, args);

}

/**

* 实例化RestTemplate

* @return

*/

@LoadBalanced

@Bean

public RestTemplate rest() {

return new RestTemplate();

}

/**

* Rest服务端使用RestTemplate发起http请求,然后得到数据返回给前端----gotoUser是为了区分getUser怕小伙伴晕头

* @param id

* @return

/

@GetMapping(value = "/gotoUser")

@ResponseBody

public Map<String,Object> getUser(@RequestParam Integer id){

Map<String,Object> data = new HashMap<>();

/**

小伙伴发现没有，地址居然是http://service-provider

* 居然不是http://127.0.0.1:8082/

* 因为他向注册中心注册了服务，服务名称service-provider,我们访问service-provider即可

*/

data = restTemplate.getForObject("http://service-provider/getUser?id="+id,Map.class);

return data;

}

配置文件

eureka:client:serviceUrl: #注册中心的注册地址defaultZone: http://127.0.0.1:8081/eureka/server:port: 8083 #服务端口号spring:application:name: service-consumer #服务名称--调用的时候根据名称来调用该服务的方法

我们启动看看效果吧

看看我们的提供者和消费者是不是都进来了

那么我们看看我们消费者的方法是否可用

哈哈，是不是很神奇

下面介绍个更神奇的东西--实现微服务负载均衡

我们把服务提供者复制一个工程出来，我们再做下小小的修改，看看是否能实现负载均衡。

我们需要修改两个文件

一个是启动类，改了哪些呢？看看就晓得咯

package com.eureka.provider;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

import org.flix.eureka.EnableEurekaClient;

import org.springframework.web.bind.annotation.GetMapping;

import org.springframework.web.bind.annotation.RequestParam;

import org.springframework.web.bind.annotation.ResponseBody;

import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;

import java.util.Map;

/**

* Eureka客户端

*/

@RestController

@EnableEurekaClient

@SpringBootApplication

public class ProviderApplication {

public static void main(String[] args) {

SpringApplication.run(ProviderApplication.class, args);

}

/**

* 假如这个客户端要提供一个getUser的方法

* @return

*/

@GetMapping(value = "/getUser")

@ResponseBody

public Map<String,Object> getUser(@RequestParam Integer id){

Map<String,Object> data = new HashMap<>();

data.put("id",id);

data.put("userName","admin");

data.put("from","provider-B");//改这里是为了让大家更能理解它负载均衡的机制

return data;

}

还有就是yml配置文件

eureka:client:serviceUrl: #注册中心的注册地址defaultZone: http://127.0.0.1:8081/eureka/server:port: 8088 #服务端口号--该端口不要冲突spring:application:name: service-provider #服务名称--调用的时候根据名称来调用该服务的方法--名字绝对不能改，改了就访问不到了

我们来启动一下吧

看看Eureka-server后台的效果ServerAServerB

这个叫做Service-provider是不是有两个实例啊

那么，我们分别访问一下，看看效果怎么样

看到了吗，8082端口，from是provider-A，8088端口，from是provider-B.

那么我们访问消费者的服务器看看会出现什么样的情况呢飞机直达

一开始是from A,你刷新一下，诶？变成 from B了。

说明这个时候两台提供者在交替工作，从而达到了一个负载均衡的作用。

来来来，我给你画个图

每个微服务都是一个Eureka-Client，我们把每个app（SpringBootApplication）都向注册中心注册一个服务。

有时候，某个服务的工作量比较大的时候，我们可以多注册几个同名称的微服务，从而让他们交替工作，减轻单个服务的压力。

如果觉得《开启springcloud全家桶3：服务注册中心erueka原理与实践》对你有帮助，请点赞、收藏，并留下你的观点哦！