Eureka搭建微服务（一）

前言

本文将介绍使用Eureka搭建微服务的流程，一步一步的从零开始搭建，大概有以下搭建流程：
1、Rest微服务工程搭建
2、单机Eureka构建
3、集群Eureka构建步骤
通过这三个流程，这三个流程后者总是在前者的基础上，展示一个简单Eureka微服务的搭建过程。

1、Rest微服务工程搭建

1.1先创建一个父工程

先创建一个空的父工程

圈中的那三个modul，是后来创建的，刚创建的父工程是啥也没有，只有pom.xml文件

1.2修改xml

作为父工程，主要是用于统一管理maven依赖，统一版本号，也是便于管理我们建立的多个modul。这里，我们需要改动一下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.atguigu.cloud</groupId>
    <artifactId>springCloud2020</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--父工程打包为pom-->
    <packaging>pom</packaging>

    <!-- 统一管理jar包版本 -->
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <junit.version>4.12</junit.version>
        <log4j.version>1.2.17</log4j.version>
        <lombok.version>1.16.18</lombok.version>
        <mysql.version>5.1.47</mysql.version>
        <druid.version>1.1.21</druid.version>
        <mybatis.spring.boot.version>1.3.0</mybatis.spring.boot.version>
    </properties>

    <!-- 子模块继承之后，提供作用：锁定版本+子modlue不用写groupId和version  -->
    <dependencyManagement>
        <dependencies>
            <!--spring boot 2.2.2-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.2.2.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--spring cloud Hoxton.SR1-->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Hoxton.SR1</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--spring cloud alibaba 2.1.0.RELEASE-->
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>2.1.0.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql.version}</version>
            </dependency>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>${druid.version}</version>
            </dependency>
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>${mybatis.spring.boot.version}</version>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit.version}</version>
            </dependency>
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>${log4j.version}</version>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

</project>

需要注意的几点，要将打包方式改为pom。
还要明白一点< dependencyManagement> 和< /dependencies>的作用：maven使用dependencyManagement来提供一种管理依赖版本号的方式，在pom.xml中使用dependencyManagement元素，能让所有子项目中引入依赖时不需要显式的列出版本号。maven会沿着父子层次向上查找dependencyManagement，并使用其中声明的依赖版本号。
dependencyManagement里只是声明依赖，并不实现引入，因此子项目还需要显示的声明所需要的依赖
这样做的好处就是: 如果有多个子项目都引用同一样的依赖,则可以避免在每个使用的子项目里都声明一个版本号,这样想升级或切换到另一个版本时,只需在顶层父容器里更新,而不需要一个一个子项目的修改l;另外如果某个子项目需要另外的一个版本,只需声明version版本

1.3创建服务提供者

在父工程下创建一个module子项目，作为服务的提供者Cloud-provider-payment8001:

这个子项目比较简单，创建后的项目结构如上图，也只是平常的增删改查，没啥好说的。
yml配置：

server:
  port: 8001

  datasource:
    #当前数据源操作类型
    type: com.alibaba.druid.pool.DruidDataSource
    #mysql驱动包
    driver-class-name: org.gjt.mm.mysql.Driver
    url: jdbc:mysql://localhost:3306/cloud2020?useUnicode=true&characterEncoding=utf8&useSSL=false
    username: root
    password: 123456


mybatis:
  mapperLocations: classpath:mapper/*.xml
  #所有entity别名类所在包
  type-aliases-package: com.george.springcloud.entities

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">
    <parent>
        <artifactId>springCloud2020</artifactId>
        <groupId>com.atguigu.cloud</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>Cloud-provider-payment8001</artifactId>

    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-web -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>

        <!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-jdbc -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>com.atguigu.cloud</groupId>
            <artifactId>cloud-api-commons</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>

</project>

创建流程：创建module->改pom->创建yml->创建主启动类
测试结果：

1.4创建服务消费者

同样的创建流程：创建module->改pom->创建yml->创建主启动类

yml:

server:
  port: 80

pom.xml:

    
        springCloud2020
        com.atguigu.cloud
        1.0-SNAPSHOT
    
    4.0.0

    cloud-consumer-order80

    
        
            org.springframework.boot
            spring-boot-starter-web
        
        
            org.springframework.boot
            spring-boot-starter-actuator
        
        
            org.springframework.boot
            spring-boot-starter-test
            test
        
        
            org.projectlombok
            lombok
        
        
            com.atguigu.cloud
            cloud-api-commons
            1.0-SNAPSHOT
        
    

服务消费者，也比较简单，需要注意的以下几点：
需要创建的配置类：

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

将我们的RestTemplate注册到容器中，是spring为我们提供的一个调用微服务接口的模板方法，它就负责了调用我们的消费者。
使用如下：

@RestController
@Slf4j
public class OrderController {

    public static final String PAYMENT_URL = "http://localhost:8001";

    @Resource
    private RestTemplate restTemplate;

    @GetMapping(value = "/consumer/payment/create")
    public CommonResult<Payment> create(Payment payment) {
        return restTemplate.postForObject(PAYMENT_URL + "/payment/create", payment, CommonResult.class);
    }

    @GetMapping("/consumer/payment/get/{id}")
    public CommonResult<Payment> getPayment(@PathVariable("id") Long id) {
        return restTemplate.getForObject(PAYMENT_URL + "/payment/get/" + id, CommonResult.class);
    }

}

测试结果：

1.5公共包

为了防止大家误会，我也把这个子项目贴出来

这个项目只是存放了一些公共的实体类，供消费者和提供者使用，它不需要配置yml和启动类，只需要打包到仓库，在需要用的地方引入依赖即可。

小结

如此，第一个流程，就算是搭建好了。当前这个Rest微服务工程比较简单，但还与Eureka一点关系也没有，它是后面搭建的基础。
最后，补充一点，我们回头再看父工程的pom：

随着，我们子项目的创建，这里的module会越来越多，大家了解一下即可。

2、单机Eureka构建

接下来，我们在第一个流程的基础上引入Eureka，改造成一个简单的单机微服务。

Eureka的基础知识

什么是服务治理？
传统的rpc调用，管理每一个服务与服务之间的依赖的关系比较复杂，管理比较复杂，所以需要服务治理，管理服务与服务的依赖关系，可实现服务调用，负载均衡，容错等，实现服务的注册与注册

什么是服务的注册与发现？
eureka采用cs的设计架构，eureka作为服务的注册功能的服务器，他是服务注册的中心，而系统中的其他的微服务使用eureka的client连接到eureka server并维持心跳检测，
在服务的注册与发现中，有一个注册中心，当服务器启动的时候会把当前的自己的服务器的信息，比如服务器地址，通讯地址等以别名注册的方式注册到注册中心（key (别名)value（host:port））。另一方（消费者|服务提供者）以该别名的方式去注册中心获取到实际的通讯地址，然后在体现本地rpc调用rpc远程调用框架的核心设计思想：在于注册中心，因为使用注册中心管理每个服务与服务之间的依赖关系（服务治理理念）,在人格rpc远程框架中，都会有一个注册中心（存放服务器地址的相关信息）

1，启动eureka注册中心
2，启动服务提供者
3，服务提供者启动后将自身信息以别名的方式注册到eureka
4，消费者在需要调用接口的时候，使用服务别名去注册中心获取实际的rpc服务远程调用地址
5，消费者获取调用地址后底层使用利用HttpClient技术实现远程调用
6，消费者获取服务地址后会缓存到jvm内存中，默认每三十秒更新一次服务调用地址

eureka 的两个组件
eureka server:提供服务的注册服务，
eureka client:通过注册中心访问，是一个java客户端，客户端同时也具备一个内置的使用轮询（round-robin）负载算法的负载均衡器，在应用启动后，将会向eureka server发送心跳，默认周期30s，如果eureka server在多个心跳周期没有接收到某个节点的心跳，eureka将会从服务注册表中把这个服务移除（默认90s）

2.1EurekaServer端服务注册中心

由上述的基础知识，我们知道要实现微服务架构，就需要有一个服务注册中心。因此我们需要创建一个新的module，如下
cloud-eureka-server7001：

pom.xml:

    
        springCloud2020
        com.atguigu.cloud
        1.0-SNAPSHOT
    
    4.0.0

    cloud-eureka-server7001

    
        
            org.springframework.cloud
            spring-cloud-starter-netflix-eureka-server
        
        
        
            org.springframework.boot
            spring-boot-starter-web
        
        
            org.springframework.boot
            spring-boot-starter-actuator
        

        
            org.slf4j
            slf4j-api
        
        
            ch.qos.logback
            logback-classic
        
        
            ch.qos.logback
            logback-core
        


    

其中引入了eureka的依赖。

yml：

server:
  port: 7001


eureka:
  instance:
    #eureka服务端的实例名称
    hostname: localhost
  client:
    #false表示不向注册中心注册自己
    register-with-eureka: false
    #false表示自己端就是注册中心,职责是维护实例,并不需要检索服务
    fetch-registry: false
    service-url:
      #设置与Eureka Server 交互的地址查询服务和注册服务都需要依赖这个地址
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

主启动类：

@SpringBootApplication
@EnableEurekaServer
public class EurekaMain7001 {
    public static void main(String[] args) {
        SpringApplication.run(EurekaMain7001.class,args);
    }
}

需要加上开启eureka服务注册中心的注解。

测试：

这就已经搭好我们的服务注册中心了，可见当前服务注册中心未注册任何服务。

2.2改造服务提供者

为了将我们的服务提供者注册到服务中心，我们需要做以下改造。

修改pom，加入依赖：

            org.springframework.cloud
            spring-cloud-starter-netflix-eureka-client
        

注意，引入的是client端。
修改yml：

eureka:
  client:
    #是否将自己注册到注册中心, 默认true
    register-with-eureka: true
    #是否从EurekaServer抓取已有的注册信息,单机无所谓,集群必须设置为true配合ribbon使用负载均衡
    fetch-registry: true
    service-url:
      defaultZone: http://localhost:7001/eureka  #单机版

改造启动类

@SpringBootApplication
@EnableEurekaClient
public class PaymentMain8001 {
    public static void main(String[] args) {
        SpringApplication.run(PaymentMain8001.class, args);
    }
}

只是添加了一个注解@EnableEurekaClient

测试

可见，我们的服务已经注册进去了，服务名既是我们yml里配置的。

2.3改造服务消费者

同样的，我们也将我们的消费者注册到服务中心去。
改pom

       
            org.springframework.cloud
            spring-cloud-starter-netflix-eureka-client
        

改yml

eureka:
  client:
    #是否将自己注册到注册中心, 默认true
    register-with-eureka: true
    #是否从EurekaServer抓取已有的注册信息,单机无所谓,集群必须设置为true配合ribbon使用负载均衡
    fetch-registry: true
    service-url:
      defaultZone: http://localhost:7001/eureka  #单机版

主启动类
加上注解@EnableEurekaClient
改controller

//    public static final String PAYMENT_URL = "http://localhost:8001";
    public static final String PAYMENT_URL = "http://CLOUD-PAYMENT-SERVICE";

改为通过服务名，去查找服务。到这一步，还不能测试，如果运行了，我们会发现，报错：找不到服务，因为，80消费者根据服务名去服务中心查找服务时，消费者默认的认为被注册到服务中心的提供者是有多个（即是集群，即便你只注册了一个），所有还要加上一个配置如下
改ApplicationContextConfig
需要加上负载均衡的注解

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

负载均衡的默认策略是轮询，但当前注册中心只有一个消费者，所有无论怎么轮询都是它。
测试

2.4小结

以上就已经完成了，单机版的微服务搭建。

3、集群Eureka构建

为什么要搭建集群

因为服务注册中心，在微服务的整个架构来说，是最核心的也是最重要的，若是它出了故障，就会导致整个微服务架构系统崩溃，所有搭建集群是很有必要的，实现高可用。

搭建Eureka服务注册中心集群

为了在我们的电脑本机，实现集群搭建，我们要修改hosts文件的映射配置如下：

创建一个新的项目cloud-eureka-server7002：

与7001相似，只是端口号不同。
yml：

server:
  port: 7002


eureka:
  instance:
    #eureka服务端的实例名称
    hostname: eureka7002.com
  client:
    #false表示不向注册中心注册自己
    register-with-eureka: false
    #false表示自己端就是注册中心,职责是维护实例,并不需要检索服务
    fetch-registry: false
    service-url:
      #设置与Eureka Server 交互的地址查询服务和注册服务都需要依赖这个地址
      defaultZone: http://eureka7001.com:7002/eureka/

修改cloud-eureka-server7001的yml：

server:
  port: 7001


eureka:
  instance:
    #eureka服务端的实例名称
    hostname: eureka7001.com
  client:
    #false表示不向注册中心注册自己
    register-with-eureka: false
    #false表示自己端就是注册中心,职责是维护实例,并不需要检索服务
    fetch-registry: false
    service-url:
      #设置与Eureka Server 交互的地址查询服务和注册服务都需要依赖这个地址
      defaultZone: http://eureka7002.com:7002/eureka/

要注意这个配置defaultZone，它们是互相配置了彼此，实现互相注册，相互守望。这个配置是实现集群的要点。
测试

访问7001的服务中心，可以看到，它关联了7002。
到这里，我们就已经实现了服务中心的集群了。

搭建服务提供者集群

创建新的Cloud-provider-payment8002，内容与Cloud-provider-payment8001一致，只是端口号不同。
只需要修改两者的yml即可，yml配置是相同的：

eureka:
  client:
    #是否将自己注册到注册中心, 默认true
    register-with-eureka: true
    #是否从EurekaServer抓取已有的注册信息,单机无所谓,集群必须设置为true配合ribbon使用负载均衡
    fetch-registry: true
    service-url:
#      defaultZone: http://localhost:7001/eureka  #单机版
      defaultZone:  http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka

如此就行了。

小结

到这里，集群已经搭好了，已经实现了服务中心集群，提供者服务集群。

actuator微服务信息完善

这里介绍一下监视器页面的信息设置，我们看下图，服务对应的实例名显示了我们电脑的主机名，我们若想去掉可以添加一个配置

eureka:
  client:
    #是否将自己注册到注册中心, 默认true
    register-with-eureka: true
    #是否从EurekaServer抓取已有的注册信息,单机无所谓,集群必须设置为true配合ribbon使用负载均衡
    fetch-registry: true
    service-url:
#      defaultZone: http://localhost:7001/eureka  #单机版
      defaultZone:  http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka
   #定义实例名
  instance:
    instance-id: payment8001 #定义实例名
    prefer-ip-address: true #访问路径显示ip

eureka自我保护

概念

保护模式
主要用于一组客户端和Eureka Server之间网络存在网络分区场景下的保护，一旦进入保护的模式，Eureka Server 将会尝试保护其服务表的信息，不再删除服务注册表的数据，也就是不会注销任何微服务
导致原因： 某时刻某一个微服务不可用了，Eureka不会立刻清理，依旧会对该服务的信息进行保存，属于CAP里面的AP的分支

为什么会产生Eureka自我保护机制？
为了防止Eureka Client可以正常运行，但是与Eureka网络不通，Eureka不会立刻将Eureka服务剔除

什么是自我保护？
如果Eureka Server 在一定的时间没有接受到某个微服务实例的心跳，Eureka Server立刻将会注销该实例，默认90s，但是当网路分区发生故障的时候（卡顿，延时，拥挤），微服务无法与Eureka之间通信，其实微服务是健康的，此时不应该注销客户。

关闭自我保护

Eureka 服务注册中心的出产默认是开启自我保护机制的。
修改Eureka 服务注册中心的配置

server:
  port: 7002


eureka:
  instance:
    #eureka服务端的实例名称
    hostname: eureka7002.com
  client:
    #false表示不向注册中心注册自己
    register-with-eureka: false
    #false表示自己端就是注册中心,职责是维护实例,并不需要检索服务
    fetch-registry: false
    service-url:
      #设置与Eureka Server 交互的地址查询服务和注册服务都需要依赖这个地址
      defaultZone: http://eureka7001.com:7001/eureka/
  server:
    # 关闭自我保护机制，保证不可用服务被及时剔除.默认开启保护机制 true
    enable-self-preservation: false
    eviction-interval-timer-in-ms: 2000 #设置为2000ms内没接收到心跳，就将服务剔除

上述配置，就是将服务注册中心的自我保护机制关闭，并设置为2000ms内没接收到服务心跳，就将目标服务剔除。
修改Eureka 客户端的配置

eureka:
  client:
    #是否将自己注册到注册中心, 默认true
    register-with-eureka: true
    #是否从EurekaServer抓取已有的注册信息,单机无所谓,集群必须设置为true配合ribbon使用负载均衡
    fetch-registry: true
    service-url:
#      defaultZone: http://localhost:7001/eureka  #单机版
      defaultZone:  http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka
  instance:
    instance-id: payment8001 #定义实例名
    prefer-ip-address: true #访问路径显示ip
    #Eureka客户端向服务端发送心跳的时间间隔.单位为秒(默认30 秒)
    lease-renewal-interval-in-seconds: 1
    #Eureka服务端在收到最后一次心跳等待时间上限.单位为秒(默认90 秒),超时将剔除服务
    lease-expiration-duration-in-seconds: 2

上述配置，设置了Eureka客户端向服务端发送心跳的时间间隔.单位为秒(默认30 秒)，Eureka服务端在收到最后一次心跳等待时间上限.单位为秒(默认90 秒),超时将剔除服务。