【SpringCloud框架之Eureka服务注册与发现】

布满荆棘的人生 2023-09-24 23:16 50阅读 0赞

本笔记内容为尚硅谷SpringCloud框架开发Eureka部分

**目录**

一、微服务架构编码构建

1、微服务cloud整体聚合父工程Project

创建步骤

2、创建一个公共Module

3、Rest微服务工程构建

1.cloud-provider-payment8001微服务提供者支付Module模块

2、热部署Devtools

3、cloud-consumer-order80微服务消费者订单Module模块

二、Eureka服务注册与发现

1、Eureka基础知识

2、单机Eureka构建步骤

1.生成eurekaServer端服务注册中心

2.EurekaClient端cloud-provider-payment8001

3.EurekaClient端cloud-consumer-order80

3、集群Eureka构建步骤

1.Eureka集群原理说明

2.EurekaServer集群环境构建步骤

3.支付服务提供者8001集群环境构建

4.负载均衡

5.actuator微服务信息完善

6.服务发现Discovery

7.Eureka自我保护

--------------------

# 一、微服务架构编码构建 #

--------------------

## 1、微服务cloud整体聚合父工程Project ##

### 创建步骤 ###

1. New Project

![4c18de98b4814bce8b3c666f9d27ec83.png][]

2. 聚合总父工程名字

![0edf700e3d8c476882f075e0e107db99.png][]

3. Maven选版本

![9b033686bfff456d94752bcf97490160.png][]

4. 工程名字

![40449437ec3b4226a1e91eac59b00cd1.png][]

5. 字符编码

![34239ef3a9d441199c4fcc1e6115b3b4.png][]

6. 注解生效激活

![98ae6c2947534c188abe5de244100b2a.png][]

7. java编译版本选8

![b45a7afdf6a046f78130670af48810b8.png][]

8. File Type过滤

![b1ee5a9a978342c0b44e0ba19aa08f90.png][]

**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.springcloud</groupId>
        <artifactId>mscloud03</artifactId>
        <version>1.0-SNAPSHOT</version>
        <packaging>pom</packaging>
     
    
        
        <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.16</druid.version>
            <mybatis.spring.boot.version>1.3.0</mybatis.spring.boot.version>
        </properties>
     
    
        
        <dependencyManagement>
            <dependencies>
                
                <dependency>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-dependencies</artifactId>
                    <version>2.2.2.RELEASE</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
                
                <dependency>
                    <groupId>org.springframework.cloud</groupId>
                    <artifactId>spring-cloud-dependencies</artifactId>
                    <version>Hoxton.SR1</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
                
                <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>
                    <optional>true</optional>
                </dependency>
            </dependencies>
        </dependencyManagement>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                    <configuration>
                        <fork>true</fork>
                        <addResources>true</addResources>
                    </configuration>
                </plugin>
            </plugins>
        </build>
    
    </project>

父工程创建完成执行**mvn:install**将父工程发布到仓库方便子工程继承

**mysql驱动说明**

> com.mysql.jdbc.Driver和mysql-connector-java 5一起用。
> 
> com.mysql.cj.jdbc.Driver和mysql-connector-java 6 一起用。
> 
> com.mysql.cj.jdbc.Driver是mysql-connector-java 6 中的特性，相比mysql-connector-java 5 多了一个时区：serverTimezone，把数据源配置的驱动改一下就好了
> 
> org.gjt.mm.mysql.Driver是当时最好的MySQL JDBC，但不是MySQL公司的，然后MySQL将MM的JDBC驱动 收为官方的JDBC驱动，所以将驱动的package也改了，但还保留了org.gjt.mm.mysql.Driver这个路径的引用，也就是你使用新版的JDBC驱动时还可以通过这个来引用，打开下载的新版JDBC驱动的jar文件可以看到，只有一个文件的目录是org.gjt.mm.mysql，就是为了兼容而设计的。

## 2、创建一个公共Module ##

--------------------

**1.新建一个Module：cloud-api-commons**

**2.POM**

**3.entities包下**

Payment实体

package com.atguigu.springcloud.entities;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    import java.io.Serializable;
    
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class Payment implements Serializable
    {
        private Long id;
        private String serial;
    }

CommonResult通用封装类

package com.atguigu.springcloud.entities;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class CommonResult<T>
    {
        private Integer code;
        private String  message;
        private T data;
    
        public CommonResult(Integer code, String message)
        {
            this(code,message,null);
        }
    }

4.maven命令clean install

![df9f46858b7a4067b3b4c99ab55a9731.png][]

在要用到的模块引用依赖即可

<dependency>
        <groupId>com.atguigu.springcloud</groupId>
        <artifactId>cloud-api-commons</artifactId>
        <version>${project.version}</version>
    </dependency>

## 3、Rest微服务工程构建 ##

--------------------

### 1.cloud-provider-payment8001微服务提供者支付Module模块 ###

步骤

新建Module:cloud-provider-payment8001

**改POM**

**写YML**

**新建主启动类**

package com.atguigu.springcloud;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    /**
     * @auther zzyy
     * @create 2020-01-27 19:50
     */
    @SpringBootApplication
    public class PaymentMain8001
    {
        public static void main(String[] args)
        {
            SpringApplication.run(PaymentMain8001.class,args);
        }
    }

**业务类**

1. 建表SQL

CREATE TABLE `payment` (
    
      `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'ID',
    
      `serial` varchar(200) DEFAULT '',
    
      PRIMARY KEY (`id`)
    
    ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8

2. dao

接口PaymentDao

package com.atguigu.springcloud.dao;
    
    import com.atguigu.springcloud.entities.Payment;
    import org.apache.ibatis.annotations.Mapper;
    
    @Mapper  //import org.apache.ibatis.annotations.Mapper;
    public interface PaymentDao
    {
        public int create(Payment payment);
    
        public Payment getPaymentById(@Param("id") Long id);
    }

mybaits的映射文件PaymentMapper.xml (src\\main\\resources\\mapper\\PaymentMapper.xml)

<?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
    
    <mapper namespace="com.atguigu.springcloud.dao.PaymentDao">
    
        <resultMap id="BaseResultMap" type="com.atguigu.springcloud.entities.Payment">
            <id column="id" property="id" jdbcType="BIGINT"/>
            <result column="serial" property="serial" jdbcType="VARCHAR"/>
        </resultMap>
    
        <insert id="create" parameterType="Payment" useGeneratedKeys="true" keyProperty="id">
            INSERT INTO payment(SERIAL) VALUES(#{serial});
        </insert>
    
        <select id="getPaymentById" parameterType="Long" resultMap="BaseResultMap" >
            SELECT * FROM payment WHERE id=#{id};
        </select>
    
    </mapper>

3.service

接口PaymentService

package com.atguigu.springcloud.service;
    
    import com.atguigu.springcloud.entities.Payment;
    import org.apache.ibatis.annotations.Param;
    
    public interface PaymentService
    {
        public int create(Payment payment);
    
        public Payment getPaymentById(@Param("id") Long id);
    
    }

实现类PaymentServiceImpl.java

package com.atguigu.springcloud.service.impl;
    
    import com.atguigu.springcloud.dao.PaymentDao;
    import com.atguigu.springcloud.entities.Payment;
    import com.atguigu.springcloud.service.PaymentService;
    import org.springframework.stereotype.Service;
    
    import javax.annotation.Resource;
    
    
    @Service
    public class PaymentServiceImpl implements PaymentService
    {
        @Resource
        private PaymentDao paymentDao;
    
    
        @Override
        public int create(Payment payment)
        {
            return paymentDao.create(payment);
        }
    
        @Override
        public Payment getPaymentById(Long id)
        {
            return paymentDao.getPaymentById(id);
        }
    }

4.controller

package com.atguigu.springcloud.controller;
    
    import com.atguigu.springcloud.entities.CommonResult;
    import com.atguigu.springcloud.entities.Payment;
    import com.atguigu.springcloud.service.PaymentService;
    import com.sun.media.jfxmedia.logging.Logger;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.web.bind.annotation.*;
    
    import javax.annotation.Resource;
    
    /**
     * @auther zzyy
     * @create 2020-01-27 21:17
     */
    @RestController
    @Slf4j
    public class PaymentController
    {
        @Resource
        private PaymentService paymentService;
    
        @PostMapping(value = "/payment/create")
        public CommonResult create(@RequestBody Payment payment)
        {
            int result = paymentService.create(payment);
            log.info("*****插入操作返回结果:" + result);
    
            if(result > 0)
            {
                return new CommonResult(200,"插入数据库成功",result);
            }else{
                return new CommonResult(444,"插入数据库失败",null);
            }
        }
    
        @GetMapping(value = "/payment/get/{id}")
        public CommonResult<Payment> getPaymentById(@PathVariable("id") Long id)
        {
            Payment payment = paymentService.getPaymentById(id);
            log.info("*****查询结果:{}",payment);
            if (payment != null) {
                return new CommonResult(200,"查询成功",payment);
            }else{
                return new CommonResult(444,"没有对应记录,查询ID: "+id,null);
            }
        }
    }

![535605b909f6413b9b10fa1d34946134.png][]

### 2、热部署Devtools ###

--------------------

添加依赖

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>runtime</scope>
        <optional>true</optional>
    </dependency>

下段配置我们粘贴进聚合父类总工程的pom.xml里

<build>
        <finalName>你自己的工程名字</finalName>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <fork>true</fork>
                    <addResources>true</addResources>
                </configuration>
            </plugin>
        </plugins>
    </build>

设置IDEA

![059052158b9145f2adc5e4e2dd425437.png][]

![b7150e341e2243c0ba38ff53159b6a07.png][]

最后重启生效

### 3、cloud-consumer-order80微服务消费者订单Module模块 ###

--------------------

**1.新建cloud-consumer-order80**

**2.POM**

**3.写YML**

server:
      port: 80

**4.新建主启动类**

package com.atguigu.springcloud;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    @SpringBootApplication
    public class MainApp80
    {
        public static void main(String[] args)
        {
            SpringApplication.run(MainApp80.class,args);
        }
    }

**5.业务类**

RestTemplate

> RestTemplate提供了多种便捷访问远程Http服务的方法， 是一种简单便捷的访问restful服务模板类，是Spring提供的用于访问Rest服务的客户端模板工具集
> 
> 官网地址
> 
> https://docs.spring.io/spring-framework/docs/5.2.2.RELEASE/javadoc-api/org/springframework/web/client/RestTemplate.html
> 
> 使用
> 
> 使用restTemplate访问restful接口非常的简单粗暴无脑。
> 
> (url, requestMap, ResponseBean.class)这三个参数分别代表 
> 
> REST请求地址、请求参数、HTTP响应转换被转换成的对象类型。

**6.config配置类ApplicationContextConfig**

package com.atguigu.springcloud.config;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.client.RestTemplate;
    
    @Configuration
    public class ApplicationContextConfig
    {
        @Bean
        public RestTemplate restTemplate()
        {
            return new RestTemplate();
        }
    }

**7.Controller类**

package com.atguigu.springcloud.controller;
    
    import com.atguigu.springcloud.entities.CommonResult;
    import com.atguigu.springcloud.entities.Payment;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RestController;
    import org.springframework.web.client.RestTemplate;
    
    @RestController
    public class OrderController
    {
    
        public static final String PaymentSrv_URL = "http://localhost:8001";
    
        @Autowired
        private RestTemplate restTemplate;
    
        @GetMapping("/consumer/payment/create") //客户端用浏览器是get请求，但是底层实质发送post调用服务端8001
        public CommonResult create(Payment payment)
        {
            return restTemplate.postForObject(PaymentSrv_URL + "/payment/create",payment,CommonResult.class);
        }
    
    
        @GetMapping("/consumer/payment/get/{id}")
        public CommonResult getPayment(@PathVariable Long id)
        {
            return restTemplate.getForObject(PaymentSrv_URL + "/payment/get/"+id, CommonResult.class, id);
        }
    }

![86c858cb5de74568916eaf474564e742.png][]

![9a84040e87b64fc59cc3246bd40acc18.png][]

# 二、Eureka服务注册与发现 #

--------------------

## 1、Eureka基础知识 ##

> 什么是服务治理　　
> 
>  Spring Cloud 封装了 Netflix 公司开发的 Eureka 模块来实现服务治理
> 
>  在传统的rpc远程调用框架中，管理每个服务与服务之间依赖关系比较复杂，管理比较复杂，所以需要使用服务治理，管理服务于服务之间依赖关系，可以实现服务调用、负载均衡、容错等，实现服务发现与注册。

> 什么是服务注册与发现
> 
>  Eureka采用了CS的设计架构，Eureka Server 作为服务注册功能的服务器，它是服务注册中心。而系统中的其他微服务，使用 Eureka的客户端连接到 Eureka Server并维持心跳连接。这样系统的维护人员就可以通过 Eureka Server 来监控系统中各个微服务是否正常运行。
> 
>  在服务注册与发现中，有一个注册中心。当服务器启动的时候，会把当前自己服务器的信息 比如 服务地址通讯地址等以别名方式注册到注册中心上。另一方（消费者|服务提供者），以该别名的方式去注册中心上获取到实际的服务通讯地址，然后再实现本地RPC调用RPC远程调用框架核心设计思想：在于注册中心，因为使用注册中心管理每个服务与服务之间的一个依赖关系(服务治理概念)。在任何rpc远程框架中，都会有一个注册中心(存放服务地址相关信息(接口地址))

![54ad422a3f574a2c984394f36becf272.png][]

> Eureka包含两个组件：Eureka Server和Eureka Client
> 
> Eureka Server提供服务注册服务
> 
> 各个微服务节点通过配置启动后，会在EurekaServer中进行注册，这样EurekaServer中的服务注册表中将会存储所有可用服务节点的信息，服务节点的信息可以在界面中直观看到。
> 
> EurekaClient通过注册中心进行访问
> 
> 是一个Java客户端，用于简化Eureka Server的交互，客户端同时也具备一个内置的、使用轮询(round-robin)负载算法的负载均衡器。在应用启动后，将会向Eureka Server发送心跳(默认周期为30秒)。如果Eureka Server在多个心跳周期内没有接收到某个节点的心跳，EurekaServer将会从服务注册表中把这个服务节点移除（默认90秒）

## 2、单机Eureka构建步骤 ##

--------------------

### 1.生成eurekaServer端服务注册中心 ###

步骤

**建Module**：cloud-eureka-server7001

**改POM**

**写YML**

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

**主启动**

package com.atguigu.springcloud;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
    
    @SpringBootApplication
    @EnableEurekaServer
    public class EurekaMain7001
    {
        public static void main(String[] args)
        {
            SpringApplication.run(EurekaMain7001.class,args);
        }
    }

测试[http://localhost:7001/][http_localhost_7001]

No application available 没有服务被发现O(∩\_∩)O因为没有注册服务进来当然不可能有服务被发现

![cb20181f0ff04ed18ce9d5b2953f3a52.png][]

###  ###

### 2.EurekaClient端cloud-provider-payment8001 ###

--------------------

将注册进EurekaServer成为服务提供者provider

**建Module:**cloud-provider-payment8001

**改POM**

**写YML**

server:
      port: 8001
    
    spring:
      application:
        name: cloud-payment-service
      datasource:
        type: com.alibaba.druid.pool.DruidDataSource            # 当前数据源操作类型
        driver-class-name: org.gjt.mm.mysql.Driver              # mysql驱动包
        url: jdbc:mysql://localhost:3306/db2019?useUnicode=true&characterEncoding=utf-8&useSSL=false
        username: root
        password: 123456
    
    eureka:
      client:
        #表示是否将自己注册进EurekaServer默认为true。
        register-with-eureka: true
        #是否从EurekaServer抓取已有的注册信息，默认为true。单节点无所谓，集群必须设置为true才能配合ribbon使用负载均衡
        fetchRegistry: true
        service-url:
          defaultZone: http://localhost:7001/eureka
    
    
    mybatis:
      mapperLocations: classpath:mapper/*.xml
      type-aliases-package: com.atguigu.springcloud.entities    # 所有Entity别名类所在包

**主启动**

package com.atguigu.springcloud;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
    
    /**
     * @auther zzyy
     * @create 2020-01-27 19:50
     */
    @SpringBootApplication
    @EnableEurekaClient
    public class PaymentMain8001
    {
        public static void main(String[] args)
        {
            SpringApplication.run(PaymentMain8001.class,args);
        }
    }

**测试**

先要启动EurekaServer

访问[http://localhost:7001/][http_localhost_7001]

![b34d17a553484206bd62dc16a6f41b54.png][]

微服务注册名配置说明

![f121e0e4d0424388811b2b620eec5bcd.png][]

自我保护机制

![cc0bceef5c1746738875eb0699216027.png][]

###  ###

### 3.EurekaClient端cloud-consumer-order80 ###

--------------------

将注册进EurekaServer成为服务消费者consumer

**建Module**：cloud-consumer-order80

**POM**

**YML**

server:
      port: 80
    
    spring:
        application:
            name: cloud-order-service
    
    eureka:
      client:
        #表示是否将自己注册进EurekaServer默认为true。
        register-with-eureka: true
        #是否从EurekaServer抓取已有的注册信息，默认为true。单节点无所谓，集群必须设置为true才能配合ribbon使用负载均衡
        fetchRegistry: true
        service-url:
          defaultZone: http://localhost:7001/eureka

**主启动**

package com.atguigu.springcloud;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
    
    @SpringBootApplication
    @EnableEurekaClient
    public class OrderMain80
    {
        public static void main(String[] args)
        {
            SpringApplication.run(OrderMain80.class,args);
        }
    }

**测试**

> 先要启动EurekaServer，7001服务
> 
> 再要启动服务提供者provider，8001服务

eureka服务器

![75ed44d4367b44ae8fec32240409655f.png][]

[http://localhost/consumer/payment/get/31][http_localhost_consumer_payment_get_31]

**注意**：YML层次缩进和空格不能少

##  ##

## 3、集群Eureka构建步骤 ##

--------------------

### 1.Eureka集群原理说明 ###

--------------------

![c41135b44d874750b0bc109705a31b89.png][]

###  ###

### 2.EurekaServer集群环境构建步骤 ###

--------------------

参考cloud-eureka-server7001

**新建Module**:cloud-eureka-server7002

**改POM**

**修改映射配置**

![c705f79c1a9e4d7bb85ec4541453dd9a.png][]

**写YML(以前单机)**

![a4fd437dc78f457c9d97a9c1162757e2.png][]

7001现在

server:
      port: 7001
    
    eureka:
      instance:
        hostname: eureka7001.com #eureka服务端的实例名称
      client:
        register-with-eureka: false     #false表示不向注册中心注册自己。
        fetch-registry: false     #false表示自己端就是注册中心，我的职责就是维护服务实例，并不需要去检索服务
        service-url:
          defaultZone: http://eureka7002.com:7002/eureka/

7002现在

server:
      port: 7002
    
    eureka:
      instance:
        hostname: eureka7002.com #eureka服务端的实例名称
      client:
        register-with-eureka: false     #false表示不向注册中心注册自己。
        fetch-registry: false     #false表示自己端就是注册中心，我的职责就是维护服务实例，并不需要去检索服务
        service-url:
          defaultZone: http://eureka7001.com:7001/eureka/

**主启动**

package com.atguigu.springcloud;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
    
    @SpringBootApplication
    @EnableEurekaServer
    public class EurekaMain7002
    {
        public static void main(String[] args)
        {
            SpringApplication.run(EurekaMain7002.class,args);
        }
    }

**将支付服务8001微服务发布到上面2台Eureka集群配置中:YML**

**defaultZone:** http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka *\# 集群版*

![e7e2fe0a513344d9b19f765a806eb6e0.png][]

**将订单服务80微服务发布到上面2台Eureka集群配置中:YML**

> **eureka:  
> client:**  
> *\#**表示是否将自己注册进**EurekaServer**默认为**true**。*  
> **register-with-eureka: true**  
> *\#**是否从**EurekaServer**抓取已有的注册信息，默认为**true**。单节点无所谓，集群必须设置为**true**才能配合**ribbon**使用负载均衡*  
> **fetchRegistry: true  
> service-url:**  
> *\#defaultZone: http://localhost:7001/eureka*  
> **defaultZone:** http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka *\#* *集群版*

![a94a2b88748e4addbe46d55c07880e28.png][]

**测试**

> 先要启动EurekaServer，7001/7002服务
> 
> 再要启动服务提供者provider，8001
> 
> 再要启动消费者，80
> 
> [访问：http://localhost/consumer/payment/get/31][http_localhost_consumer_payment_get_31]

###  ###

### 3.支付服务提供者8001集群环境构建 ###

--------------------

参考cloud-provider-payment8001

**新建**cloud-provider-payment8002

**改POM**

**写YML**

**defaultZone:** http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka *\#* *集群版*

![3481177dd05c47c783748026fbd967c7.png][]

**主启动**

package com.atguigu.springcloud;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
    
    @SpringBootApplication
    @EnableEurekaClient
    public class PaymentMain8002
    {
        public static void main(String[] args)
        {
            SpringApplication.run(PaymentMain8002.class,args);
        }
    }

**业务类**

直接从8001粘

**修改Controller**

**8001**

package com.atguigu.springcloud.controller;
    
    import com.atguigu.springcloud.entities.CommonResult;
    import com.atguigu.springcloud.entities.Payment;
    import com.atguigu.springcloud.service.PaymentService;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.web.bind.annotation.*;
    
    import javax.annotation.Resource;
    
    @RestController
    @Slf4j
    public class PaymentController
    {
        @Value("${server.port}")
        private String serverPort;
    
        @Resource
        private PaymentService paymentService;
    
        @PostMapping(value = "/payment/create")
        public CommonResult create(@RequestBody Payment payment)
        {
            int result = paymentService.create(payment);
            log.info("*****插入操作返回结果:" + result);
    
            if(result > 0)
            {
                return new CommonResult(200,"插入成功,返回结果"+result+"\t 服务端口："+serverPort,payment);
            }else{
                return new CommonResult(444,"插入失败",null);
            }
        }
    
        @GetMapping(value = "/payment/get/{id}")
        public CommonResult<Payment> getPaymentById(@PathVariable("id") Long id)
        {
            Payment payment = paymentService.getPaymentById(id);
            log.info("*****查询结果:{}",payment);
            if (payment != null) {
                return new CommonResult(200,"查询成功"+"\t 服务端口："+serverPort,payment);
            }else{
                return new CommonResult(444,"没有对应记录,查询ID: "+id,null);
            }
        }
    }

**8002**

package com.atguigu.springcloud.controller;
    
    import com.atguigu.springcloud.entities.CommonResult;
    import com.atguigu.springcloud.entities.Payment;
    import com.atguigu.springcloud.service.PaymentService;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.web.bind.annotation.*;
    
    import javax.annotation.Resource;
    
    @RestController
    @Slf4j
    public class PaymentController
    {
        @Value("${server.port}")
        private String serverPort;
    
        @Resource
        private PaymentService paymentService;
    
        @PostMapping(value = "/payment/create")
        public CommonResult create(@RequestBody Payment payment)
        {
            int result = paymentService.create(payment);
            log.info("*****新增结果:" + result);
    
            if(result > 0)
            {
                return new CommonResult(200,"插入成功,返回结果"+result+"\t 服务端口："+serverPort,payment);
            }else{
                return new CommonResult(444,"插入失败",null);
            }
        }
    
        @GetMapping(value = "/payment/get/{id}")
        public CommonResult<Payment> getPaymentById(@PathVariable("id") Long id)
        {
            Payment payment = paymentService.getPaymentById(id);
            log.info("*****查询结果:{}",payment);
            if (payment != null) {
                return new CommonResult(200,"查询成功"+"\t 服务端口："+serverPort,payment);
            }else{
                return new CommonResult(444,"没有对应记录,查询ID: "+id,null);
            }
        }
    }

###  ###

### 4.负载均衡 ###

--------------------

消费者cloud-consumer-order80  
**OrderController访问不能写死**

//public static final String PaymentSrv_URL = "http://localhost:8001";
        // 通过在eureka上注册过的微服务名称调用
        public static final String PaymentSrv_URL = "http://CLOUD-PAYMENT-SERVICE";

使用**@LoadBalanced**注解赋予**RestTemplate**负载均衡的能力

**ApplicationContextBean**

@Configuration
    public class ApplicationContextBean
    {
        @Bean
        @LoadBalanced //使用@LoadBalanced注解赋予RestTemplate负载均衡的能力
        public RestTemplate getRestTemplate()
        {
            return new RestTemplate();
        }
    }

![3816572164e04e9bbf10253ff43d7e0b.png][]

###  ###

### 5.actuator微服务信息完善 ###

--------------------

**主机名称:服务名称修改**

![62e27a9eaef64169aa104a7e2347be74.png][]

修改cloud-provider-payment8001：**YML**

instance:
        instance-id: payment8001

![50b9cc68327449a7823f47d1e5e16488.png][]

**访问信息有IP信息提示**

没有IP显示

修改cloud-provider-payment8001：**YML**

prefer-ip-address: true     #访问路径可以显示IP地址

### ![a92ec9cf3e6445e19ecdf909c1a8a02c.png][]    ###

### 6.服务发现Discovery ###

--------------------

对于注册进eureka里面的微服务，可以通过服务发现来获得该服务的信息

**修改cloud-provider-payment8001的Controller**

@Resource
        private DiscoveryClient discoveryClient;
    
    
    @GetMapping(value = "/payment/discovery")
        public Object discovery()
        {
            //查看有Eureka有什么服务
            List<String> services = discoveryClient.getServices();
            for (String element : services) {
                System.out.println(element);
            }
            //查看CLOUD-PAYMENT-SERVICE名称下有什么实例
            List<ServiceInstance> instances = discoveryClient.getInstances("CLOUD-PAYMENT-SERVICE");
            for (ServiceInstance element : instances) {
                System.out.println(element.getServiceId() + "\t" + element.getHost() + "\t" + element.getPort() + "\t"
                        + element.getUri());
            }
            return this.discoveryClient;
        }

**8001主启动类**

@SpringBootApplication
    @EnableEurekaClient
    @EnableDiscoveryClient //服务发现
    public class PaymentMain8001
    {
        public static void main(String[] args)
        {
            SpringApplication.run(PaymentMain8001.class,args);
        }
    }

![d5de45bd89db440b8777a10acda9412d.png][]

###  ###

### 7.Eureka自我保护 ###

--------------------

**故障现象**

![2458ed5328bb4135b7a7b711167f6d36.png][]

**导致原因**

> *为什么会产生Eureka自我保护机制？*
> 
> 为了防止EurekaClient可以正常运行，但是 与 EurekaServer网络不通情况下，EurekaServer不会立刻将EurekaClient服务剔除
> 
> *什么是自我保护模式？*
> 
> 默认情况下，如果EurekaServer在一定时间内没有接收到某个微服务实例的心跳，EurekaServer将会注销该实例（默认90秒）。但是当网络分区故障发生(延时、卡顿、拥挤)时，微服务与EurekaServer之间无法正常通信，以上行为可能变得非常危险了——因为微服务本身其实是健康的，此时本不应该注销这个微服务。Eureka通过“自我保护模式”来解决这个问题——当EurekaServer节点在短时间内丢失过多客户端时（可能发生了网络分区故障），那么这个节点就会进入自我保护模式。

![0cad3b373ef64625ae03012327c4bfa1.png][]

**怎么禁止自我保护**

注册中心eureakeServer端7001

修改YML

使用eureka.server.enable-self-preservation = false 可以禁用自我保护模式

![bce1a582a30b4db3a4763cd3c5595705.png][]

关闭效果

![e56055140646442bbfc952ccfba2fe5c.png][]

生产者客户端eureakeClient端8001

#心跳检测与续约时间
    #开发时设置小些，保证服务关闭后注册中心能即使剔除服务
      instance:
      #Eureka客户端向服务端发送心跳的时间间隔，单位为秒(默认是30秒)
        lease-renewal-interval-in-seconds: 1
      #Eureka服务端在收到最后一次心跳后等待时间上限，单位为秒(默认是90秒)，超时将剔除服务
        lease-expiration-duration-in-seconds: 2

![4ac8646a75e44cff9ee076ecff272f80.png][]

![0beda5602973453f9db6dd96a3f95cf9.png][]

[4c18de98b4814bce8b3c666f9d27ec83.png]: https://img-blog.csdnimg.cn/4c18de98b4814bce8b3c666f9d27ec83.png
[0edf700e3d8c476882f075e0e107db99.png]: https://img-blog.csdnimg.cn/0edf700e3d8c476882f075e0e107db99.png
[9b033686bfff456d94752bcf97490160.png]: https://img-blog.csdnimg.cn/9b033686bfff456d94752bcf97490160.png
[40449437ec3b4226a1e91eac59b00cd1.png]: https://img-blog.csdnimg.cn/40449437ec3b4226a1e91eac59b00cd1.png
[34239ef3a9d441199c4fcc1e6115b3b4.png]: https://img-blog.csdnimg.cn/34239ef3a9d441199c4fcc1e6115b3b4.png
[98ae6c2947534c188abe5de244100b2a.png]: https://img-blog.csdnimg.cn/98ae6c2947534c188abe5de244100b2a.png
[b45a7afdf6a046f78130670af48810b8.png]: https://img-blog.csdnimg.cn/b45a7afdf6a046f78130670af48810b8.png
[b1ee5a9a978342c0b44e0ba19aa08f90.png]: https://img-blog.csdnimg.cn/b1ee5a9a978342c0b44e0ba19aa08f90.png
[df9f46858b7a4067b3b4c99ab55a9731.png]: https://img-blog.csdnimg.cn/df9f46858b7a4067b3b4c99ab55a9731.png
[535605b909f6413b9b10fa1d34946134.png]: https://img-blog.csdnimg.cn/535605b909f6413b9b10fa1d34946134.png
[059052158b9145f2adc5e4e2dd425437.png]: https://img-blog.csdnimg.cn/059052158b9145f2adc5e4e2dd425437.png
[b7150e341e2243c0ba38ff53159b6a07.png]: https://img-blog.csdnimg.cn/b7150e341e2243c0ba38ff53159b6a07.png
[86c858cb5de74568916eaf474564e742.png]: https://img-blog.csdnimg.cn/86c858cb5de74568916eaf474564e742.png
[9a84040e87b64fc59cc3246bd40acc18.png]: https://img-blog.csdnimg.cn/9a84040e87b64fc59cc3246bd40acc18.png
[54ad422a3f574a2c984394f36becf272.png]: https://img-blog.csdnimg.cn/54ad422a3f574a2c984394f36becf272.png
[http_localhost_7001]: http://localhost:7001/
[cb20181f0ff04ed18ce9d5b2953f3a52.png]: https://img-blog.csdnimg.cn/cb20181f0ff04ed18ce9d5b2953f3a52.png
[b34d17a553484206bd62dc16a6f41b54.png]: https://img-blog.csdnimg.cn/b34d17a553484206bd62dc16a6f41b54.png
[f121e0e4d0424388811b2b620eec5bcd.png]: https://img-blog.csdnimg.cn/f121e0e4d0424388811b2b620eec5bcd.png
[cc0bceef5c1746738875eb0699216027.png]: https://img-blog.csdnimg.cn/cc0bceef5c1746738875eb0699216027.png
[75ed44d4367b44ae8fec32240409655f.png]: https://img-blog.csdnimg.cn/75ed44d4367b44ae8fec32240409655f.png
[http_localhost_consumer_payment_get_31]: http://localhost/consumer/payment/get/31
[c41135b44d874750b0bc109705a31b89.png]: https://img-blog.csdnimg.cn/c41135b44d874750b0bc109705a31b89.png
[c705f79c1a9e4d7bb85ec4541453dd9a.png]: https://img-blog.csdnimg.cn/c705f79c1a9e4d7bb85ec4541453dd9a.png
[a4fd437dc78f457c9d97a9c1162757e2.png]: https://img-blog.csdnimg.cn/a4fd437dc78f457c9d97a9c1162757e2.png
[e7e2fe0a513344d9b19f765a806eb6e0.png]: https://img-blog.csdnimg.cn/e7e2fe0a513344d9b19f765a806eb6e0.png
[a94a2b88748e4addbe46d55c07880e28.png]: https://img-blog.csdnimg.cn/a94a2b88748e4addbe46d55c07880e28.png
[3481177dd05c47c783748026fbd967c7.png]: https://img-blog.csdnimg.cn/3481177dd05c47c783748026fbd967c7.png
[3816572164e04e9bbf10253ff43d7e0b.png]: https://img-blog.csdnimg.cn/3816572164e04e9bbf10253ff43d7e0b.png
[62e27a9eaef64169aa104a7e2347be74.png]: https://img-blog.csdnimg.cn/62e27a9eaef64169aa104a7e2347be74.png
[50b9cc68327449a7823f47d1e5e16488.png]: https://img-blog.csdnimg.cn/50b9cc68327449a7823f47d1e5e16488.png
[a92ec9cf3e6445e19ecdf909c1a8a02c.png]: https://img-blog.csdnimg.cn/a92ec9cf3e6445e19ecdf909c1a8a02c.png
[d5de45bd89db440b8777a10acda9412d.png]: https://img-blog.csdnimg.cn/d5de45bd89db440b8777a10acda9412d.png
[2458ed5328bb4135b7a7b711167f6d36.png]: https://img-blog.csdnimg.cn/2458ed5328bb4135b7a7b711167f6d36.png
[0cad3b373ef64625ae03012327c4bfa1.png]: https://img-blog.csdnimg.cn/0cad3b373ef64625ae03012327c4bfa1.png
[bce1a582a30b4db3a4763cd3c5595705.png]: https://img-blog.csdnimg.cn/bce1a582a30b4db3a4763cd3c5595705.png
[e56055140646442bbfc952ccfba2fe5c.png]: https://img-blog.csdnimg.cn/e56055140646442bbfc952ccfba2fe5c.png
[4ac8646a75e44cff9ee076ecff272f80.png]: https://img-blog.csdnimg.cn/4ac8646a75e44cff9ee076ecff272f80.png
[0beda5602973453f9db6dd96a3f95cf9.png]: https://img-blog.csdnimg.cn/0beda5602973453f9db6dd96a3f95cf9.png