Eureka（服务注册中心）

1、Eureka（服务注册中心）的基本介绍

1.1、服务注册中心的基本介绍

服务注册中心是用于管理微服务提供者的注册与发现的组件。在分布式微服务架构中，服务注册中⼼用于存储服务提供者的地址信息、服务发布相关的属性信息，消费者通过主动查询和被动通知的方式获取服务提供者的地址信息，不再需要通过硬编码⽅式得到提供者的地址信息。

对于任何⼀个微服务，原则上都应存在或者⽀持多个提供者(provider)，这是由微服务的分布式属性决定的。所以为了⽀持弹性扩缩容特性，微服务的同一个提供者的数量和分布往往是动态变化的，也是无法预先确定的。这个时候就需要服务注册中心来管理微服务提供者的注册与发现了。服务注册中心本质上就是为了解耦服务提供者和服务消费者。

 

1.2、Eureka注册中心

Eureka是SpringCloud的核心模块之一，Eureka是一个基于RestFul的服务，用于定位服务，以实现云端中间层服务注册、服务发现和故障转移。服务注册与发现对与微服务来说是非常重要的，有了服务发现与注册，只需要使用服务的标识符，就可以访问到服务，而不需要修改服务调用的配置文件了，功能类似于 Dubbo的注册中心，比如Zookeeper。

Eureka架构中的三个核心角色：

• 服务注册中心（Eureka 服务端，即Eureka  Server）：Eureka的服务端应用，提供服务注册和发现功能
• 服务提供者（Eureka 客户端，即Eureka  client）：提供服务的应用，可以是SpringBoot应用，也可以是其它任意技术实现，只要对外提供的是Rest风格服务即可
• 服务消费者（Eureka 客户端，即Eureka  client）：消费应用从注册中心获取服务列表，从而得知每个服务方的信息，知道去哪里调用服务方。

Eureka包含两个组件：Eureka Server和Eureka Client。Eureka客户端就是指我们的开发的服务，包括服务提供者和消费者。

Eureka Server提供服务注册服务，各个节点启动后，会在Eureka Server中进行注册，这样EurekaServer中的服务注册表中将会存储所有可用服务节点的信息，服务节点的信息可以在界面中直观的看到。

Eureka Client是一个java客户端，用于简化与Eureka Server的交互，客户端同时也就是一个内置的、使用轮询(round-robin)负载算法的负载均衡器。

1.2.1、Eureka的运行机制

Eureka 的整个运行机制大致如下：

• 注册：Eureka client 一次次反复连接eureka，直到注册成功为止。
• 拉取或订阅：消费者会把注册中心的整个注册表都全部拉取过来缓存到本地，会每隔30秒拉取一次注册表，更新注册信息，最终服务消费者会基于服务列表做负载均衡，选中一个微服务后发起远程调用服务。
• 心跳：消费提供者每30秒发送一次心跳，Eureka 在每次收不到心跳后就会记一个数，如果3次没有收到心跳 eureka 会删除这个服务（将地址从注册表中删除）
• 自我保护模式：特殊情况，由于网络不稳定15秒内85%服务器出现心跳异常（一次收不到就算心跳一次），会保护所有的注册信息不删除，就算3次没有收到心跳的情况也不会删除，网络恢复后，可以自动退出保护模式，在开发测试期间，可以关闭保护模式。

服务提供方与Eureka之间通过“心跳”机制进行监控，当某个服务提供方出现问题，Eureka自然会把它从服务列表中剔除，这就实现了服务的自动注册、发现、状态监控。

原理图如下：

2、搭建一个Eureka Server

我们新建一个 springboot 项目，比如 springclouddemo 作为父工程，在该项目里建立 eureka-server 模块作为 Eureka 的服务端，建立 order-service 作为 Eureka 的客户端，在 springclouddemo 父工程里管理着子模块的依赖。

项目目录结构如下：

父工程 springclouddemo 实际只作为一个依赖管理，不需要一些代码模块，比如src、resource等目录可以删除。父工程的 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>

    <packaging>pom</packaging>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.5.RELEASE</version>
        <relativePath/>
    </parent>

    <groupId>com.example</groupId>
    <artifactId>springclouddemo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springclouddemo</name>
    <description>Demo project for Spring Boot</description>

    <modules>
        <module>eureka-server</module>
    </modules>

    <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>Hoxton.SR9</spring-cloud.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <!-- springCloud -->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.2.5.RELEASE</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>

搭建 Eureka server 实际只需引入 Eureka 的服务依赖，添加一些配置，然后给启动类加上 @EnableEurekaServer 注解即可，该注解标记了该服务是一个Eureka服务。

eureka-server 模块的 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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>com.example</groupId>
        <artifactId>springclouddemo</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>

    <artifactId>eureka-server</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <!--eureka服务端-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
            <!--<version>2.2.5.RELEASE</version>-->
        </dependency>
    </dependencies>

</project>

application.properties 配置如下：

spring.application.name=myeurekaserver

server.port=10086
# 表示是否将自己注册到Eureka Server，默认为true，即也会将本身自己的服务注册到Eureka Server中，可以设置为false
eureka.client.register-with-eureka=true
# 表示是否从Eureka Server获取注册信息，默认为true，可以设置为false
eureka.client.fetch-registry=true
# 设置与Eureka Server交互的地址
eureka.client.serviceUrl.defaultZone=http://localhost:${server.port}/eureka/

启动类代码如下：

package com.example.eurekaserver;

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

@EnableEurekaServer
@SpringBootApplication
public class EurekaServerApplication {

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

}

启动Eureka Server的入口，访问 http://localhost:10086/，即可看到类似以下页面：

红色提示信息：自我保护模式被关闭，在网络或其他问题的情况下可能不会保护实例失效。项目在开发阶段可关闭。 

Eureka 服务端照上述步骤已搭建好，实际上上面的 eureka server 自己本身也作为一个 eureka client 注册在了服务端，由此在页面上的已注册实例才可以看到  eureka server 本身。

2.1、搭建 Eureka client客户端并注册服务

下面在 springclouddemo 父工程下建立 order-service 模块作为 Eureka 的客户端。搭建 Eureka client 只需引入客户端依赖，添加相应配置，给启动类添加 @EnableEurekaClient 注解即可。

创建一个 springboot 项目 order-service，引入 eureka 客户端依赖，当然如果该项目需要操作数据库等还需要引入其他依赖，比如 mysql、mybatis。

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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>com.example</groupId>
        <artifactId>springclouddemo</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>

    <groupId>com.example</groupId>
    <artifactId>order-service</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>order-service</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.2.2</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

        <!--eureka服务端-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
            <version>2.2.5.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>com.example</groupId>
            <artifactId>feign-api</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
    </dependencies>

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

</project>

配置文件 application.yaml 如下：

server:
  port: 8081

spring:
  datasource:
    username: root
    password: 123456
    url: jdbc:mysql://localhost:3306/cloud_order?useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=UTC
    driver-class-name: com.mysql.jdbc.Driver
  application:
    name: eureka-provider #设置当前应用名称，在eureka中Aoolication显示，通过该名称可以获取路径

mybatis:
  mapper-locations: classpath:mapping/*Mapper.xml

eureka:
  client:
    service-url:  # eureka的地址信息
      defaultZone: http://127.0.0.1:10086/eureka

启动类代码如下：

package com.example.orderservice;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@SpringBootApplication
@EnableEurekaClient //启用eurekaclient，新版本可以不用加该注解
public class OrderServiceApplication {

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

}

启动该项目，在 eureka server的页面下就可以看到实例列表下新增了该项目，也就是该项目作为 eureka client 注册到了 eureka server 端。

2.2、Eureka client 调用另一服务

启动一个 web 服务后，我们可以通过 http://ip:port/xxx 的方式来调用该服务的接口，但是这样需要通过硬编码的方式写死需调用的服务的 ip 和端口号。当服务的提供者和消费者注册到同一个注册中心时，服务的消费者就可以拉取注册中心的服务列表，由此来给指定的服务发起请求。

假设有模块 order-service 和 user-service，两个模块都在注册中心注册了服务，即都是作为 eureka client，下面演示在 order-service 中调用 user-service的服务。

在 order-service 的启动类中创建 RestTemplate，并添加负载均衡注解，如下：

import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;import org.springframework.web.client.RestTemplate;

@SpringBootApplication
@EnableEurekaClient //启用eurekaclient，新版本可以省略
public class OrderServiceApplication {

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


    /**
     * 创建RestTemplate并注入Spring容器
     */
    @Bean
    @LoadBalanced  //负载均衡注解
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

上面通过添加 @LoadBalanced 注解即可实现负载均衡，即如果目标服务有多个服务器时，会负载均衡到目标服务器的其中一台中。

（实际上 RestTemplate 是用于发起http请求的，就算不是通过服务调用的方式发起，我们也可以通过该依赖来发起http请求）

通过注册中心服务调用跟普通的 http 请求调用方式差不多，只不过在调用时，可以将目标服务在注册中心注册的服务名来替换目标服务具体的 ip 和端口。如下：

import org.springframework.beans.factory.annotation.Autowired;import org.springframework.web.client.RestTemplate;

@Service
public class OrderService {

    @Autowired
    private RestTemplate restTemplate;

    public Order queryOrderById(Long orderId) {
        ...

        // 利用RestTemplate发起http请求
        // 目标服务的ip和端口无需写死，只需写上目标服务在注册中心注册的服务名即可。下面假设user-service模块在注册中心注册的服务名为userservice
        String url = "http://userservice/user/" + orderId;

        // 发送http get请求，实现远程调用服务
        User user = restTemplate.getForObject(url, User.class);
        
        ...
    }
}
    

上面通过写服务名而不是具体的 ip 来发出请求，实际上 spring 会自动帮助我们从 eureka-server 端，根据 userservice 这个服务名称来获取服务的实例列表，而后完成负载均衡。springcloud 默认的负载均衡策略是轮询。

3、Eureka调用服务的负载均衡原理（Ribbon 组件）

springcloud底层利用了一个名为Ribbon的组件来实现的负载均衡的功能。

Ribbon的底层采用了一个拦截器，拦截了RestTemplate发出的请求，对地址做了修改。用一幅图来总结一下：

基本流程如下：（ 这里模拟订单服务 order-service 需要请求用户服务 user-service ）

• 拦截我们的 RestTemplate 请求 http://userservice/user/1

• RibbonLoadBalancerClient 会从请求url中获取服务名称，也就是 userservice

• DynamicServerListLoadBalancer 根据 userservice 到 eureka 拉取服务列表

• eureka 返回列表，localhost:8081、localhost:8082

• IRule 利用内置负载均衡规则，从列表中选择一个，例如 localhost:8081

• RibbonLoadBalancerClient 修改请求地址，用 localhost:8081 替代userservice，得到http://localhost:8081/user/1，发起真实请求

具体原理可参考：https://www.cnblogs.com/chencan/p/16057356.html

3.1、负载均衡策略

springcloud 默认的负载均衡策略是轮询，但我们可以指定使用哪种策略。

负载均衡的规则都定义在IRule接口中，而IRule有很多不同的实现类：

不同规则的含义如下所示：

内置负载均衡规则类	规则描述
RoundRobinRule	简单轮询服务列表来选择服务器。它是Ribbon默认的负载均衡规则。
AvailabilityFilteringRule	对以下两种服务器进行忽略： （1）在默认情况下，这台服务器如果3次连接失败，这台服务器就会被设置为“短路”状态。短路状态将持续30秒，如果再次连接失败，短路的持续时间就会几何级地增加。 （2）并发数过高的服务器。如果一个服务器的并发连接数过高，配置了AvailabilityFilteringRule规则的客户端也会将其忽略。并发连接数的上限，可以由客户端的<clientName>.<clientConfigNameSpace>.ActiveConnectionsLimit属性进行配置。
WeightedResponseTimeRule	为每一个服务器赋予一个权重值。服务器响应时间越长，这个服务器的权重就越小。这个规则会随机选择服务器，这个权重值会影响服务器的选择。
ZoneAvoidanceRule （默认的）	以区域可用的服务器为基础进行服务器的选择。使用Zone对服务器进行分类，这个Zone可以理解为一个机房、一个机架等。而后再对Zone内的多个服务做轮询。
BestAvailableRule	忽略那些短路的服务器，并选择并发数较低的服务器。
RandomRule	随机选择一个可用的服务器。
RetryRule	重试机制的选择逻辑

3.2、指定使用的负载均衡策略

通过定义IRule实现可以修改负载均衡的规则，有两种方式：

方式一：在配置类中注册一个IRule组件，注册需要的规则。

比如在启动类（启动类实际也是一个配置类）中注册 IRule 组件，代码如下：

@SpringBootApplication
@EnableEurekaClient //启用eurekaclient，新版本可以省略
public class OrderServiceApplication {

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


    /**
     * 创建RestTemplate并注入Spring容器
     */
    @Bean
    @LoadBalanced  //负载均衡注解
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
    
     @Bean
    public IRule randomRule() {
        return new RandomRule();   //指定负载均衡策略为随机
    }
}

使用这种方式修改负载均衡策略是全局生效的，也就是该消费者即 order-service 往所有的服务发起请求时，使用的都是指定的随机策略。

方式二： 在服务消费者的配置文件如 application.yml 中设置负载均衡的策略，如下：

userservice: #指定给某个目标服务发起请求时的负载均衡规则，这里是目标服务的服务名称
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule  #负载均衡规则，这里指定的是随机访问

使用这种方式可针对具体某一个服务进行配置。上面的配置指定了只有往 userservice 服务发起服务调用时就使用随机策略。

可参考：https://www.cnblogs.com/chencan/p/16057356.html

3.3、Ribbon 的饥饿加载

Ribbon 默认是采用懒加载，即第一次访问时才会去创建LoadBalanceClient，这样的话在第一次调用另一服务时请求时间会很长。此时我们可以配置为饥饿加载，饥饿加载会在项目启动时就创建，这样可以降低第一次另一服务的耗时。

通过在服务消费者配置文件中添加下面配置开启饥饿加载：

ribbon:
  eager-load:
    enabled: true
    clients: userservice  #指定该服务需要进行饥饿加载的目标服务的服务名称

可参考：https://www.cnblogs.com/chencan/p/16057356.html