SpringCloud（1）基础 Eureka ZooKeeper Consul CAP

最新推荐文章于 2023-11-29 16:30:00 发布
最新推荐文章于 2023-11-29 16:30:00 发布
阅读量303 收藏
点赞数
分类专栏： SpringCloud 文章标签： SpringCloud
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chengqingshihuishui/article/details/117248889
版权

前言：现在主流springcloud是springcloud alibaba。本篇都是讲的都是已过时的技术。但springcloud alibaba里面的新技术都是在本篇的老技术基础上加以更新。

后文：SpringCloud（2）Ribbon OpenFeign Hystrix 服务降级 熔断 HystrixDashboard GateWay Config Bus Stream Sleuth

          SpringCloud（3）CloudAlibaba Nacos Sentinel Seata 

1、微服务简介

1.1 微服务与springcloud

https://blog.csdn.net/chengqingshihuishui/article/details/110788281

简单来说：springcloud又是各个springboot项目的框架，就是把前面做的各个springboot项目高效率整合起来

springcloud官网：https://spring.io/cloud

1.2 springcloud简介

（1）官方设计理念图

每个microservices就是一个springboot项目

（2）上图理念对应的具体技术实现

特别注意：打X的就是已经停止维护，不再更新的过时技术。本文主要讲的就是这些过时技术。下一章SpringCloud Alibaba 会讲替代这些过时技术的新技术，需要这节的知识做铺垫。

 

（3）技术部分抽离出来，如下图：

上图的技术，学完了，SpringCloud就学完了。再次说明上图技术都是过期的，学的目的是用来铺垫后面的SpringCloud alibaba。

总结（下图即是这篇文章要讲的具体技术）：

  • 服务注册中心：EUREKA

  • 服务负载均衡与调用：NETFLIX OSS RIBBON

  • 服务负载与调用：NETTFLIX

  • 服务熔断降级：HYSTRIX

  • 服务网关：Zuul

  • 服务分布式配置：SpringCloud Config

  • 服务开发：SpingBoot

2、微服务构建

2.1 SpringCloud版本选型 （需要搭配springboot）

    以官网为主：https://spring.io/projects/spring-cloud

    下图是截取的SpringCloud 和 springboot的版本对应关系。（本教程SpringCloud用的是Hoxton版，因此需要springboot是2.2.x以上）

    官网也已经明说了，SpringCloud老版本的Dalston, Edgware, Finchley, and Greenwich 已经到达终点，再也不支持，所以不能用了。

2.2 环境搭建

2.2.1 父工程创建

      父工程也是一个springboot工程，直接用idea的 springboot Initializr即可快速搭建好父工程。但是视频课里面的老师非要用传统maven工程来搭建springboot项目，那就按照老师的来吧，免得弄错了。

特别注意：

  • 字符编码 - Settings - File encoding    （选择好UTF-8 避免乱码）
  • 注解生效激活 - Settings - Annotation Processors    （写代码的时候会有很多福利）
  • File Type过滤 - Settings - File Type   （隐藏那些不需要操作的乱七八糟的文件夹比如.idea之类的）

以上自行百度怎么操作。

（1）父工程POM文件（最外层工程）

父pom主要用于管理 所有微服务 都要用的依赖。 微服务自己个性化需要的依赖，不用放入父pom

如果不熟悉，复习maven：https://blog.csdn.net/chengqingshihuishui/article/details/110453732

特别需要看一看 <dependencyManagement>标签。（父项目专属）

 

<?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</groupId>
    <artifactId>LearnCloud</artifactId>
    <version>1.0.0-SNAPSHOT</version>
    <packaging>pom</packaging><!-- 这里添加，注意不是jar或war -->
    
    <!-- 统一管理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.16</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>
                <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>

复习maven重点：

（1）dependencyManagement
​    在pom.xml文件中使用了之前没有用过的 dependencyManagement，其通常用在项目中对顶层的父POM中，它能让其所有子项目引用一个依赖而不用显式的列出版本号。此外，dependencyManagement 只是声明依赖，并不实现引入，子项目如果不声明依赖，则不会从父项目中继承下来。

父项目

<dependencyManagement>
    <dependencies>
        <dependency>
        <groupId>mysq1</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.2</version>
        </dependency>
    <dependencies>
</dependencyManagement>

子项目

在子项目里就可以添加mysql-connector时可以不指定版本号

<dependencies>
    <dependency>
    <groupId>mysq1</groupId>
    <artifactId>mysql-connector-java</artifactId>
    </dependency>
</dependencies>

     Maven会沿着父子层次向上走，直到找到一个拥有dependencyManagement元素的项目，然后它就会使用这个dependencyManagement元素中指定的版本号。这样做的好处就是：如果有多个子项目都引用同一样依赖，则可以避免在每个使用的子项目里都声明一个版本号，这样当想升级或切换到另一个版本时，只需要在顶层父容器里更新，而不需要一个一个子项目的修改；另外如果某个子项目需要另外的一个版本，只需要声明version就可。

特别说明：

① dependencyManagement里只是声明依赖，并不实现引入，因此子项目需要显示的声明需要用的依赖。
② 如果不在子项目中声明依赖，是不会从父项目中继承下来的；只有在子项目中写了该依赖项,并且没有指定具体版本，才会从父项目中继承该项，并且version和scope都读取自父pom。
③ 如果子项目中指定了版本号，那么会使用子项目中指定的jar版本。

（2）maven跳过单元测试

由于SpringCloud是若干springboot项目（微服务）的集合，老老实实走maven的整个流程（清理-编译-测试-打包）会非常非常浪费时间。主要就是测试浪费时间，因此本教程跳过了单元测试环节。

跳过测试的方法：如上图，IDEA右侧旁的Maven插件有Toggle ' Skip Tests' Mode按钮（闪电），这样maven可以跳过单元测试

（3）父工程发布

    父工程创建完成执行mvn : install将父工程发布到仓库方便子工程依赖。

2.3 支付子工程（这里先演示传统SpringBoot项目，不带cloud的）

创建微服务模块套路：

  1. 建Module
  2. 改POM
  3. 写YML
  4. 主启动
  5. 业务类

2.3.1 支付子工程（Module）创建

（1）在父工程上右键New->Module

这样创建，idea会帮你在父pom.xml中写好 Module标签

（2）改POM（支付子工程POM）

① 子工程需要写一个parent标签（就像父工程需要写module标签）

② 写工程名（artifactId）即可，groupId 和 version 会从父项目继承

 

（3）支付子工程完整的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">
    <parent>
        <artifactId>LearnCloud</artifactId>
        <groupId>com.atguigu</groupId>
        <version>1.0.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>cloud-provider-payment8001</artifactId>

    <dependencies>
        <!--包含了sleuth+zipkin-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-zipkin</artifactId>
        </dependency>
        <!--eureka-client-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
            <!-- 引入自己定义的api通用包，可以使用Payment支付Entity -->
        <!--
        <dependency>
            <groupId>com.atguigu.springcloud</groupId>
            <artifactId>cloud-api-commons</artifactId>
            <version>${project.version}</version>
        </dependency>
        -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>
        <!--mysql-connector-java-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--jdbc-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

</project>

2.3.2 写application.yml

总工程\microservicecloud-config-dept-client-8001（module）\src\main\resources 下的 application.yml

server:
	port: 8001   #这个支付微服务所在的端口
spring:
	application:
		name: cloud-payment-service  #这个支付微服务的服务名（将会进入注册中心的名字）

#以下是数据库相关配置，用的时候可以自行百度最新版

	datasource:
    # 当前数据源操作类型
    type: com.alibaba.druid.pool.DruidDataSource
    # mysql驱动类
    driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://localhost:3306/cloud?useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=GMT%2B8
    username: root
    password: 123456
mybatis:			
    mapper-locations: classpath*:mapper/*.xml
   	type-aliases-package: com.atguigu.springcloud.entities

特别说明：每一步具体配置方法，最好都能去官网手册上找到依据。关于最后一个type-aliases-package（mybatis去扫描实体所在的文件夹）

保留问题：如果将实体类已经抽取出来放到了另一个微服务里，这里mybatis该如何搜索那个实体类

2.3.3 主启动类

总工程\cloud-provider-payment8001（Module）\src\main\java\com\atguigu\springcloud 目录下，创建主启动类PaymentMain8001

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

2.3.4 编写业务类

（1）创建一个mysql数据库

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=utf8mb4

（2）实体类Entities

该 实体类 完美对应 （6.1）的 数据表

暂时把实体类放在该Module下，后面会把实体类也独立成一个微服务

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Payment implements Serializable
{
    private Long id;
    private String serial;
}

（3）JSON封装CommonResult（传给前端）

@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);
    }
}

说明：需要自己专门写一个没有data的构造器，其他都可以交给@Data自动生成

（4）DAO层

总工程\cloud-provider-payment8001（Module）\src\main\java\com\atguigu\springcloud\dao

        @Mapper
        public interface PaymentDao {

            public int create(Payment payment);

            public Payment getPaymentById(@Param("id") Long id);

        }

（5）MyBatis映射文件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">

    <insert id="create" parameterType="Payment" useGeneratedKeys="true" keyProperty="id">
        insert into payment(serial)  values(#{serial});
    </insert>
    
    <resultMap id="BaseResultMap" type="com.atguigu.springcloud.entities.Payment">
        <id column="id" property="id" jdbcType="BIGINT"/>
        <id column="serial" property="serial" jdbcType="VARCHAR"/>
    </resultMap>

    <select id="getPaymentById" parameterType="Long" resultMap="BaseResultMap">
        select * from payment where id=#{id};
    </select>

</mapper>

路径：resources/mapper/PaymentMapper.xml

（6）service层

总工程\cloud-provider-payment8001（Module）\src\main\java\com\atguigu\springcloud\service   下面的 PaymentService.java

package com.atguigu.springcloud.service;


public interface PaymentService{
    public int create(Payment payment);

    public Payment getPaymentById(@Param("id") Long id);
}

（7）接口的实现类 PaymentServiceImpl.java

总工程\cloud-provider-payment8001（Module）\src\main\java\com\atguigu\springcloud\service\PaymentServiceImpl.java   下面的 PaymentServiceImpl.java

package com.atguigu.springcloud.service.impl;

@Service
public class PaymentServiceImpl implements PaymentService{

    @Resource
    private PaymentDao paymentDao;

    public int create(Payment payment){
        return paymentDao.create(payment);
    }

    public Payment getPaymentById(Long id){
        return paymentDao.getPaymentById(id);
    }
}

（8）Controller层

总工程\cloud-provider-payment8001（Module）\src\main\java\com\atguigu\springcloud\controller 下的PaymentController.java

@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);

        if(payment != null)
        {
            return new CommonResult(200,"查询成功,serverPort:  "+serverPort,payment);
        }else{
            return new CommonResult(444,"没有对应记录,查询ID: "+id,null);
        }
    }
}

备注：@RequestBody，即接收前端传过来的json，并把json转换成java能够识别的对象payment

*扩展：热部署小工具

只要检测到代码改动，就会自动重启，帮程序员省去总是手动重启项目的时间。但是

注意：开发时使用，生产环境关闭

（1）添加热部署依赖

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

（2）去pom.xml中添加maven插件

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

（3）IDEA中设置好热部署功能

① File -> Settings(New Project Settings->Settings for New Projects) ->Complier

下面项勾选

  • Automatically show first error in editor
  • Display notification on build completion
  • Build project automatically
  • Compile independent modules in parallel

② Update the value of

键入Ctrl + Shift + Alt + / ，打开Registry，勾选：

  • compiler.automake.allow.when.app.running
  • actionSystem.assertFocusAccessFromEdt
     

③ 重启IDEA

2.4 消费者订单子工程（模块）

2.4.1 消费者订单子工程创建

在父工程上右键New->Module（和前面一模一样）

2.4.2 改该工程的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>LearnCloud</artifactId>
    <groupId>com.atguigu</groupId>
    <version>1.0.0-SNAPSHOT</version>
  </parent>
  <modelVersion>4.0.0</modelVersion>

  <artifactId>cloud-consumer-order80</artifactId>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>

    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-devtools</artifactId>
      <scope>runtime</scope>
      <optional>true</optional>
    </dependency>
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <optional>true</optional>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
    </dependency>
  </dependencies>
</project>

2.4.3 写yml配置文件

server:
  port: 80

该工程（微服务）占的端口号是80

2.4.4 主启动类


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

2.4.5 编写业务类

（1）实体类

     复制pay模块的实体类,entity类和CommonResult类

说明：这个订单子工程的实体类和前面支付子工程的实体类一模一样，如果这个项目还有很多其他微服务也要用这个实体类，代码就会非常冗余。因此可以将公共的实体类抽取出来，作为一个单独的微服务

（2）service和dao

​      订单子工程作为消费者类没有service和dao,而是需要调用pay模块的方法，并且这里还没有微服务的远程调用,那么如果要调用另外一个模块,则需要使用基本的api调用，可以使用RestTemplate调用pay模块。

说明：RestTemplate类似JdbcTemplate，JdbcTemplate操作数据库和java程序的数据交换，这个RestTemplate操作微服务之间的数据交换。同理，jdbcTemplate会被高级框架mybatis封装，这个RestTemplate后面也会被Openfeign封装，但是学点底层原理也没得坏处

*RestTemplate

       这个类，spring3.0以后自带的类（用于HTTP请求），已经给你写好了。我们要做的就是用spring注解的方式（配置类）创建这个类的对象（也可以用古老的xml方式创建）

@Configuration
public class ApplicationContextConfig {

    @Bean
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }

}

（3）controller

@Slf4j
@RestController
public class OrderController {

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

    @Resource
    private RestTemplate restTemplate; //装配好刚刚创建的restTemplate

    @GetMapping("/consumer/payment/create")
    public CommonResult<Payment> create(@RequestBody Payment payment){

    //通过restTemplate(HTTP协议)将对象（这个工程里面的payment）传输（post）给指定URL

        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);
    }
}

getForObject方法：https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/client/RestTemplate.html#getForObject-java.lang.String-java.lang.Class-java.lang.Object...-

postForObject本质上是将对象放入HttpEntity中，然后将对象POST给一个url。直接形参放java对象也行，因为底层会完成java对象到HttpEntity 的自动转换。

形参分别是传输的URL，传输的Object，和返回值的类型。这里返回类型是CommonResult<payment>，还记得前面专门在CommonResult实体类中写了一个只有两个参数的构造器吗

（4）测试：

同时运行cloud-consumer-order80与cloud-provider-payment8001两工程

  • 浏览器 - http://localhost/consumer/payment/get/1

扩展：IDEA中快速开启Dashboard

        一个一个大工程里面微服务几十个，一个一个启动，就太浪费时间了。理论上IDEA感应到多个微服务，就会自动出现Run Dashboard窗口。但是有时候IDEA没感应到，如何自己开启呢？

修改方式：

打开工程路径下的.idea文件夹的workspace.xml

在<component name="RunDashboard">中修改或添加以下代码：

<option name="configurationTypes">
	<set>
		<option value="SpringBootApplicationConfigurationType"/>
    </set>
</option>

2.5 cloud-api-commons 子工程

       前面说过   订单子工程 和 支付子工程 都有一个共同的实体类Payment 和 CommonResult。如果这个项目未来还有更多的微服务需要这些实体类，每个微服务都写一次，代码会非常冗余。因此，专门写一个cloud-api-commons 子工程 来存放所有微服务的重复代码（一般就是存放工程所需要的实体类）

2.5.1 创建cloud-api-commons  子工程（Module）

公共父类上New—Module

2.5.2 改POM

		<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.3.7</version>
        </dependency>

注：hutol是一个第三方的Java工具类库，详情参考：文档

2.5.3 将前面两个子工程的实体类放入 这个公共类中。并删除那两个模块中的实体类

总工程\cloud-api-commons（模块）\src\main\java\com\atguigu\springcloud\entities

2.6.3 将该项目用maven打包发布

2.6.4 另外两个项目，引入该项目的依赖

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

猜想：不写version，应该也行吧

3、Eureka服务注册中心

3.1 服务治理

        在传统的RPC远程调用框架中，管理每个服务与服务之间依赖关系比较复杂，管理比较复杂，所以需要使用服务治理，管理服务于服务之间依赖关系，可以实现服务调用、负载均衡、容错等，实现服务发现与注册。

    Spring Cloud封装了Netflix 公司开发的Eureka模块来实现服务治理。

重点说明：Eureka已经停止维护，已过时。这里重点学习设计理念。

3.2 服务注册与发现

        Eureka采用了C/S的设计架构，Eureka Sever作为服务注册功能的服务器，它是服务注册中心。而系统中的其他微服务，使用Eureka的客户端连接到 Eureka Server并维持心跳连接。这样系统的维护人员就可以通过Eureka Server来监控系统中各个微服务是否正常运行。

（1）Eureka包含了两个组件：

① Eureka Server（服务端）：提供注册服务，各个微服务节点会在其中进行注册。

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

② Eureka Client（客户端）：

     它是一个Java客户端，用于简化Eureka Server的交互，客户端同时也具备一个内置的、使用轮询(round-robin)负载算法的负载均衡器。在应用启动后，将会向Eureka Server发送心跳(默认周期为30秒)。如果Eureka Server在多个心跳周期内没有接收到某个节点的心跳，EurekaServer将会从服务注册表中把这个服务节点移除（默认90秒)

（2）工作过程：

       在服务注册与发现中，当服务器启动的时候，会把当前自己服务器的信息比如服务地址通讯地址等以别名方式注册到注册中心上。另一方(消费者服务提供者)，以该别名的方式去注册中心上获取到实际的服务通讯地址，然后再实现本地RPC调用RPC远程调用框架核心设计思想:在于注册中心，因为使用注册中心管理每个服务与服务之间的一个依赖关系(服务治理概念)。在任何RPC远程框架中，都会有一个注册中心存放服务地址相关信息(接口地址)

3.3 Eureka Server子工程（Module）

该工程运行以后，注册中心就有了

（1）创建名为cloud-eureka-server7001的子工程（Module）

父工程上，右键—New Module

（2）修改pom.xml

① eureka服务器依赖

		<!-- eureka-server -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
		<!-- 其他依赖 -->

 ② 完整pom


    <parent>
        <artifactId>LearnCloud</artifactId>
        <groupId>com.atguigu.springcloud</groupId>
        <version>1.0.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>cloud-eureka-server7001</artifactId>

    <dependencies>
        <!--eureka-server-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
        <!-- 引入自己定义的api通用包，可以使用Payment支付Entity -->
        <dependency>
            <groupId>com.atguigu.springcloud</groupId>
            <artifactId>cloud-api-commons</artifactId>
            <version>${project.version}</version>
        </dependency>
        <!--boot web actuator-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <!--一般通用配置-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
    </dependencies>

</project>

（3）改yml配置文件

server:
  port: 7001

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

（4）主启动类

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

说明：主启动类需要一个@EnableEurekaServer，来启动EurekaServer

（5）测试运行
成功启动该工程后。

浏览器输入http://localhost:7001/回车，会查看到Spring Eureka服务主页。

3.4 其他微服务（子工程）注册进eureka

前言：并不是什么微服务都要注册进去，无关的工程不需要注册进去

3.4.1 支付微服务（前文2.3支付子工程cloud-provider-payment8001）入驻EurekaServer

支付微服务是服务提供方，即Provider

（1）修改POM

在原POM中，添加eureka-client（客户端依赖）

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

（2）修改YML配置文件

spring:
  application:
    name: cloud-payment-service  #注册中心显示的微服务应用名


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

（3）修改主启动类（就添加一个eureka客户端注解）


@SpringBootApplication
@EnableEurekaClient//<-----添加该注解
public class PaymentMain001 {

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

（4）测试：

Step1：启动cloud-provider-payment8001和cloud-eureka-server7001工程。

Step2：浏览器输入 - http://localhost:7001/   主页内就可以看到注册好的微服务。微服务名就是yml配置文件中的应用名

3.4.2 订单微服务cloud-consumer-order80（前文2.4消费子工程） 入驻进EurekaServer

订单微服务cloud-consumer-order80是服务消费方，即consumer

（1）修改POM

在原POM文件上添加eureka-client客户端

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

（2）修改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

（3）主启动类添加@EnableEurekaClient注解


@SpringBootApplication
@EnableEurekaClient//<--- 添加该标签
public class OrderMain80
{
    public static void main( String[] args ){
        SpringApplication.run(OrderMain80.class, args);
    }
}

（4）测试

① 启动cloud-provider-payment8001、cloud-eureka-server7001和cloud-consumer-order80这三工程。

② 浏览器输入 http://localhost:7001 , 在主页的Instances currently registered with Eureka将会看到cloud-provider-payment8001、cloud-consumer-order80两个工程名。

3.5 Eureka集群原理说明

问题:微服务RPC远程服务调用最核心的是什么

解答：高可用，试想你的注册中心只有一个only one，万一它出故障了，会导致整个为服务环境不可用。

解决办法：搭建Eureka注册中心集群，实现负载均衡+故障容错。

互相注册，相互守望。

3.5.1 Eureka集群环境构建

（1）创建cloud-eureka-server7002工程，过程参考  前文3.3 EurekaServer子工程

（2）修改本机Hosts文件

由于是本机去访问这个eureka的域名，ip地址最开始是在本机host文件中找域名映射。

找到C:\Windows\System32\drivers\etc路径下的hosts文件，修改映射配置添加进hosts文件

127.0.0.1 eureka7001.com
127.0.0.1 eureka7002.com

这样在本机浏览器地址栏输入eureka7001.com，就会跳转到ip地址127.0.0.1

（4）修改前文3.3 EurekaServer子工程（7001子工程）的YML配置文件

重点是重新配置defaultZone，指向其他eureka

server:
  port: 7001

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

（5）修改cloud-eureka-server7002配置文件

重点还是让7002指向配置中心7001

server:
  port: 7002

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

特别说明：如果有2台以上集群，defaultZone里面的多个注册中心地址，用逗号隔开即可

（6）测试  启动7001,7002即可

3.5.2 订单微服务 和  支付微服务   注解进 Eureka集群

就是分别修改微服务中的yml配置文件里面的defaultZone

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

3.5.3 测试：

（1）先要启动EurekaServer，7001/7002服务

（2）再要启动服务提供者provider，8001

（3）再要启动消费者，80

（4）浏览器输入 - http://localhost/consumer/payment/get/1

3.6 Provider（支付微服务）集群

根据这张图，provider也需要集群，才能体现服务的高可用。如果只有一个provider，一旦挂掉，服务就凉凉了。

3.6.1 新建cloud-provider-payment8002 支付子工程（微服务）

参考前文2.3 支付子工程cloud-provider-payment8001  完成以下工作

① 新建8002工程 Module

② 改POM

③ 写YML   （端口号要写自己的8002）

④ 主启动类

⑤ 业务类（除了controller）

3.6.2 修改支付子工程8001/8002的Controller，添加serverPort

感觉这步的目的，就是给客户端回复一个哪个具体端口插入数据成功

@RestController
@Slf4j
public class PaymentController{

    @Value("${server.port}")
    private String serverPort;//添加serverPort

    @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,"插入数据库成功,serverPort: "+serverPort/*添加到此处*/, result);
        }else{
            return new CommonResult(444,"插入数据库失败",null);
        }
    }
}

代码就是把yaml文件中的server.port弄出来，包装后，反馈给前端

3.6.3 负载均衡

现在已经有2个provider了，订单子工程（消费者）是调用哪个provider进行服务呢？默认使用负载均衡算法（轮询）.

备注：负载均衡是由Ribbion提供的（后文会讲Ribbion），先提前用一下

（1）@LoadBalanced注解给RestTemplate类的对象提供负载均衡能力

进入订单子工程的配置类，重新创建RestTemplate对象

@Configuration
public class ApplicationContextConfig {

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

}

（2）重新写订单子工程的controller

重点是修改URL，写微服务名称（YML中的spring.application.name），不能写微服务地址http://localhost:8001（写地址就写死了，没法在不同微服务之间切换了）

@Slf4j
@RestController
public class OrderController {
    
    @Resource //装配好带负载均衡的restTemplate
    private RestTemplate restTemplate;
    //public static final String PAYMENT_URL = "http://localhost:8001";
    public static final String PAYMENT_URL = "http://CLOUD-PAYMENT-SERVICE";
    
    ...
}

（3）负载均衡测试：

先要启动EurekaServer，7001/7002服务

再要启动服务提供者provider，8001/8002服务

浏览器输入 - http://localhost/consumer/payment/get/31

结果：负载均衡效果达到，8001/8002端口交替出现

总结：

3.7 隐藏微服务ip

为了避免暴露信息以及方便管理，可以修改服务主机名和ip在eureka的web上显示

修改cloud-provider-payment8001，cloud-provider-payment8002 两个微服务

eureka:
  ...
  instance:
    instance-id: payment8002
    prefer-ip-address: true #添加此处

eureka.instance.instance-id ：该配置的值，替代原来的ip

隐藏了ip，有时候，程序员自己需要知道ip，再查，不方便。因此

eureka.instance.prefer-ip-address： 该配置设置为ture以后，会有ip信息提示（就是将鼠标指针移至payment8001，payment8002名下，会有IP地址提示）

修改之后

eureka主页将显示payment8001，payment8002代替原来显示的IP地址，同时左下角会有ip提示（就是将鼠标指针移至payment8001，payment8002名下，会有IP地址提示）

3.8 服务发现Discovery

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

这里以微服务cloud-provider-payment8001为例

（1）修改Controller

@RestController
@Slf4j
public class PaymentController{
	...
    //首先注入DiscoverClient服务发现客户端
    @Resource 
    private DiscoveryClient discoveryClient;

    ...

    @GetMapping(value = "/payment/discovery")
    public Object discovery()
    {
        //获取服务列表
        List<String> services = discoveryClient.getServices();
        for (String element : services) {
            log.info("*****element: "+element);
        }
        //获取具体服务下的实例列表
        List<ServiceInstance> instances = discoveryClient.getInstances("CLOUD-PAYMENT-SERVICE");
        for (ServiceInstance instance : instances) {
            log.info(instance.getServiceId()+"\t"+instance.getHost()+"\t"+instance.getPort()+"\t"+instance.getUri());
        }

        return this.discoveryClient;
    }
}

备注：根本就没通过xml或者配置类就装配了discoveryClient对象，可见这个对象SpringCloud加载的时候，就给你创建好了

（2）修改主启动类（就是添加一个@EnableDiscoveryClient注解）

@SpringBootApplication
@EnableEurekaClient
@EnableDiscoveryClient//添加该注解
public class PaymentMain001 {

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

（3）测试：

先要启动EurekaSeryer

再启动8001主启动类，需要稍等一会儿

浏览器输入http://localhost:8001/payment/discovery

浏览器输出：

{"services":["cloud-payment-service"],"order":0}

控制台输出：

*****element: cloud-payment-service
CLOUD-PAYMENT-SERVICE	192.168.199.218	8001	http://192.168.199.218:8001

3.9 Eureka自我保护

3.9.1 保护模式简介

     保护模式主要用于一组客户端和Eureka Server之间存在网络分区场景下的保护。一旦进入保护模式，Eureka Server将会尝试保护其服务注册表中的信息，不再删除服务注册表中的数据，也就是不会注销任何微服务。

     默认情况下，如果EurekaServer在一定时间内没有接收到某个微服务实例的心跳，EurekaServer将会注销该实例(默认90秒)。但是当网络分区故障发生(延时、卡顿、拥挤)时，微服务与EurekaServer之间无法正常通信，以上行为可能变得非常危险了——因为微服务本身其实是健康的，此时本不应该注销这个微服务。Eureka通过“自我保护模式”来解决这个问题——当EurekaServer节点在短时间内丢失过多客户端时(可能发生了网络分区故障)，那么这个节点就会进入自我保护模式。
   如果Eureka在server端在一定时间内(默认90秒)没有收到EurekaClient发送心跳包，便会直接从服务注册列表中剔除该服务，但是在短时间( 90秒中)内丢失了大量的服务实例心跳，这时候Eurekaserver会开启自我保护机制，不会剔除该服务（该现象可能出现在如果网络不通但是EurekaClient为出现宕机，此时如果换做别的注册中心如果一定时间内没有收到心跳会将剔除该服务，这样就出现了严重失误，因为客户端还能正常发送心跳，只是网络延迟问题，而保护机制是为了解决此问题而产生的)。
 

保护模式就是为了为了EurekaClient可以正常运行，防止与EurekaServer网络不通情况下，EurekaServer不会立刻将EurekaClient服务剔除，简而言之：某时刻某一个微服务不可用了，Eureka不会立刻清理，依旧会对该微服务的信息进行保存。

在自我保护模式中，Eureka Server会保护服务注册表中的信息，不再注销任何服务实例。

3.9.2 禁止自我保护

出厂默认，自我保护机制是开启的

（1）禁止方法：

  ①   进入Eureka Server7001/7002子工程（Eureka服务端）

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

eureka:
  ...
  server:
    #关闭自我保护机制，保证不可用服务被及时踢除
    enable-self-preservation: false
    #发送心跳间隔的时间
    eviction-interval-timer-in-ms: 2000

② 进入任一Eureka客户端（比如某支付子工程cloud-provider-payment8001  povider）

默认值：

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

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

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

（2）测试 禁止自我保护 

  • 先启动7001再启动8001

结果：先关闭8001，马上被删除了

3.10 Eureka停更说明

https://github.com/Netflix/eureka/wiki

遗憾的是：Eureka官方已经停止维护。可用ZooKeeper替代

4、支付服务注册进ZooKeeper

4.1 ZooKeeper简介

zookeeper是一个分布式协调工具，可以实现注册中心功能

复习ZooKeeper：https://blog.csdn.net/chengqingshihuishui/article/details/115466004

4.2 本项目需要注意的地方

先关闭Linux服务器防火墙，再启动zookeeper服务器

用到的Linux命令行：

  • systemctl stop firewalld关闭防火墙
  • systemctl status firewalld查看防火墙状态
  • ipconfig查看IP地址
  • ping查验结果

4.3 创建新的cloud-provider-payment8004 支付子工程

新的8004工程将注册进ZooKeeper注册中心

（1）创建Module

（2）修改pom （这里只写和前文payment  的pom.xml不同的地方）

		<!--SpringBoot整合Zookeeper客户端-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-zookeeper-discovery</artifactId>
            <exclusions>
                <!--先排除自带的zookeeper3.5.3-->
                <exclusion>
                    <groupId>org.apache.zookeeper</groupId>
                    <artifactId>zookeeper</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!--添加zookeeper3.6.1版本-->
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.6.1</version>

需要注意的是：SpringCloud自带了ZooKeeper，但是版本有点老。我们先排除自带的，然后再添加好最新的。

（3）修改YML配置文件

配置端口号、微服务名称、zookeeper地址

#8004表示注册到zookeeper服务器的支付服务提供者端口号
server:
  port: 8004

#服务别名----注册zookeeper到注册中心名称
spring:
  application:
    name: cloud-provider-payment
  cloud:
    zookeeper:
      connect-string: 127.0.0.1:2181 # 192.168.111.144:2181 #

（4）主启动类

添加@EnableDiscoveryClient

@SpringBootApplication
@EnableDiscoveryClient//该注解用于向使用consul或者zookeeper作为注册中心时注册服务
public class PaymentMain8004 {
    public static void main(String[] args) {
        SpringApplication.run(PaymentMain8004.class, args);
    }
}

（5）编写controller

随便写写就是了，以为必须有这么个东西

@RestController
@Slf4j
public class PaymentController{

    @Value("${server.port}")
    private String serverPort;

    @RequestMapping(value = "/payment/zk")
    public String paymentzk(){

        return "springcloud with zookeeper: "+serverPort+"\t"+ UUID.randomUUID().toString();
    }
}

（6）测试

  • 验证测试：浏览器 - http://localhost:8004/payment/zk

  • 验证测试2 ：接着用zookeeper客户端操作

[zk: localhost:2181(CONNECTED) 0] ls /
[services, zookeeper]
[zk: localhost:2181(CONNECTED) 1] ls /services/cloud-provider-payment
[a4567f50-6ad9-47a3-9fbb-7391f41a9f3d]
[zk: localhost:2181(CONNECTED) 2] get /services/cloud-provider-payment/a4567f50-6ad9-47a3-9fbb-7391f41a9f3d
{"name":"cloud-provider-payment","id":"a4567f50-6ad9-47a3-9fbb-7391f41a9f3d","address":"192.168.199.218","port":8004,"ss
lPort":null,"payload":{"@class":"org.springframework.cloud.zookeeper.discovery.ZookeeperInstance","id":"application-1","
name":"cloud-provider-payment","metadata":{}},"registrationTimeUTC":1612811116918,"serviceType":"DYNAMIC","uriSpec":{"pa
rts":[{"value":"scheme","variable":true},{"value":"://","variable":false},{"value":"address","variable":true},{"value":"
:","variable":false},{"value":"port","variable":true}]}}
[zk: localhost:2181(CONNECTED) 3]

以上json可以用专门的json工具格式化，格式化后结果：

{
    "name": "cloud-provider-payment", 
    "id": "a4567f50-6ad9-47a3-9fbb-7391f41a9f3d", 
    "address": "192.168.199.218", 
    "port": 8004, 
    "sslPort": null, 
    "payload": {
        "@class": "org.springframework.cloud.zookeeper.discovery.ZookeeperInstance", 
        "id": "application-1", 
        "name": "cloud-provider-payment", 
        "metadata": { }
    }, 
    "registrationTimeUTC": 1612811116918, 
    "serviceType": "DYNAMIC", 
    "uriSpec": {
        "parts": [
            {
                "value": "scheme", 
                "variable": true
            }, 
            {
                "value": "://", 
                "variable": false
            }, 
            {
                "value": "address", 
                "variable": true
            }, 
            {
                "value": ":", 
                "variable": false
            }, 
            {
                "value": "port", 
                "variable": true
            }
        ]
    }
}

注：我们在zk上注册的node是临时节点，当我们的服务一定时间内没有发送心跳那么zk就会将这个服务的node删除。（不像Eureka有自我保护机制，不删除）

4.4 创建新的订单服务子工程（Module）注册进zookeeper

（1）新建cloud-consumerzk-order80 Module

仿照前文2.4 cloud-consumer-order80 来完成以下：

（2）改POM

    <parent>
        <artifactId>LearnCloud</artifactId>
        <groupId>com.atguigu.springcloud</groupId>
        <version>1.0.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>cloud-consumerzk-order80</artifactId>

    <dependencies>
   
        <!-- SpringBoot整合zookeeper客户端 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-zookeeper-discovery</artifactId>
            <!--先排除自带的zookeeper-->
            <exclusions>
                <exclusion>
                    <groupId>org.apache.zookeeper</groupId>
                    <artifactId>zookeeper</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!--添加zookeeper3.6.1版本-->
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.6.1</version>
        </dependency>
    </dependencies>

</project>

（3）改YML

server:
  port: 80

#服务别名----注册zookeeper到注册中心名称
spring:
  application:
    name: cloud-consumer-order
  cloud:
    zookeeper:
      connect-string: 127.0.0.1:2181 # 192.168.111.144:2181 #

（4）主启动类

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

（5）用spring注解 创建RestTemplate()，同时添加负载均衡注解

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

（6）写controller

@RestController
@Slf4j
public class OrderZKController{
    public static final String INVOKE_URL = "http://cloud-provider-payment";

    @Resource
    private RestTemplate restTemplate;

    @GetMapping(value = "/consumer/payment/zk")
    public String paymentInfo(){
        String result = restTemplate.getForObject(INVOKE_URL+"/payment/zk",String.class);
        return result;
    }
}

（7）测试

运行ZooKeeper服务端，cloud-consumerzk-order80，cloud-provider-payment8004。

打开ZooKeeper客户端：

[zk: localhost:2181(CONNECTED) 0] ls /
[services, zookeeper]
[zk: localhost:2181(CONNECTED) 1] ls /services
[cloud-consumer-order, cloud-provider-payment]
[zk: localhost:2181(CONNECTED) 2]

浏览器访问：http://localhost/consumer/payment/zk

5、Consul注册中心

5.1 简介：

https://www.springcloud.cc/spring-cloud-consul.html

Consul是一套开源的分布式服务发现和配置管理系统，由HashiCorp 公司用Go语言开发。

提供了微服务系统中的服务治理、配置中心、控制总线等功能。这些功能中的每一个都可以根据需要单独使用，也可以一起使用以构建全方位的服务网格，总之Consul提供了一种完整的服务网格解决方案。 

它具有很多优点。包括：基于raft协议，比较简洁；支持健康检查，同时支持HTTP和DNS协议支持跨数据中心的WAN集群提供图形界面跨平台，支持Linux、Mac、Windows。

  • 服务发现 - 提供HTTP和DNS两种发现方式。
  • 健康监测 - 支持多种方式，HTTP、TCP、Docker、Shell脚本定制化
  • KV存储 - Key、Value的存储方式
  • 多数据中心 - Consul支持多数据中心
  • 可视化Web界面

5.2 安装并运行Consul

官网安装方法：https://learn.hashicorp.com/tutorials/consul/get-started-install

（1）下载好windows版本解压。

（2）在exe文件所在的目录，打开cmd

（3）常用指令

# 查看consul版本

consul -v

D:\Consul>consul -v
Consul v1.9.3
Revision f55da9306
Protocol 2 spoken by default, understands 2 to 3 (agent will automatically use protocol >2 when speaking to compatible agents)

# 开发者模式启动

consul agent -dev

（4）浏览器输入 http://localhost:8500/ - 打开Consul控制页。

5.3 创建新的支付子工程cloud-providerconsul-payment8006

依然仿照前面cloud-provider-payment8004子工程完成以下:

（1）创建Module

（2）修改pom   （只写不同的地方，主要是consul依赖）

    <parent>
        <artifactId>LearnCloud</artifactId>
        <groupId>com.atguigu.springcloud</groupId>
        <version>1.0.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>cloud-providerconsul-payment8006</artifactId>
    <dependencies>
        <!--SpringCloud consul-server -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-consul-discovery</artifactId>
        </dependency>
    </dependencies>

</project>

（3）修改YML配置文件

###consul服务端口号
server:
  port: 8006

spring:
  application:
    name: consul-provider-payment
####consul注册中心地址
  cloud:
    consul:
      host: localhost
      port: 8500
      discovery:
        #hostname: 127.0.0.1
        service-name: ${spring.application.name}

（4）主启动类

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

（5）业务类Controller

@RestController
@Slf4j
public class PaymentController{
    @Value("${server.port}")
    private String serverPort;

    @RequestMapping(value = "/payment/consul")
    public String paymentConsul(){
        return "springcloud with consul: "+serverPort+"\t"+ UUID.randomUUID().toString();
    }
}

（6）测试

  • http://localhost:8006/payment/consul
  • http://localhost:8500 - 会显示provider8006

5.4 新建cloud-consumerconsul-order80 订单微服务入驻Consul

仿照  前文4.4 cloud-consumerzk-order80 微服务完成如下：

（1）创建cloud-consumerconsul-order80 子工程

（2）改POM

    <parent>
        <artifactId>LearnCloud</artifactId>
        <groupId>com.atguigu.springcloud</groupId>
        <version>1.0.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>cloud-consumerconsul-order80</artifactId>
    <dependencies>
        <!--SpringCloud consul-server -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-consul-discovery</artifactId>
        </dependency>
    </dependencies>
</project>

（3）修改YML配置文件

###consul服务端口号
server:
  port: 80

spring:
  application:
    name: cloud-consumer-order
####consul注册中心地址
  cloud:
    consul:
      host: localhost
      port: 8500
      discovery:
        #hostname: 127.0.0.1
        service-name: ${spring.application.name}

（4）用spring注解创建RestTemplate对象并加入负载均衡

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

（5）Controller

@RestController
@Slf4j
public class OrderConsulController
{
    public static final String INVOKE_URL = "http://consul-provider-payment";

    @Resource
    private RestTemplate restTemplate;

    @GetMapping(value = "/consumer/payment/consul")
    public String paymentInfo()
    {
        String result = restTemplate.getForObject(INVOKE_URL+"/payment/consul",String.class);
        return result;
    }
}

（6）主启动类

@SpringBootApplication
@EnableDiscoveryClient //该注解用于向使用consul或者zookeeper作为注册中心时注册服务
public class OrderConsulMain80{
    public static void main(String[] args) {
            SpringApplication.run(OrderConsulMain80.class, args);
    }
}

（7）测试

运行consul，cloud-providerconsul-payment8006，cloud-consumerconsul-order80

http://localhost:8500/ 主页会显示出consul，cloud-providerconsul-payment8006，cloud-consumerconsul-order80三服务。

访问测试地址 - http://localhost/consumer/payment/consul

6、三个注册中心的异同 CAP

6.1 三种注册中心对比

组件名语言CAP服务健康检查对外暴露接口SpringCloud集成
EurekaJavaAP可配支持HTTP已集成
ConsulGoCP支持HTTP/DNS已集成
ZookeeperJavaCP支持客户端已集成

6.2 CAP理论

CAP：

  • C：Consistency (强一致性)

  • A：Availability (可用性)

  • P：Partition tolerance （分区容错性)

最多只能同时较好的满足两个。

CAP理论的核心是：一个分布式系统不可能同时很好的满足一致性，可用性和分区容错性这三个需求。

因此，根据CAP原理将NoSQL数据库分成了满足CA原则、满足CP原则和满足AP原则三大类:

CA - 单点集群，满足—致性，可用性的系统，通常在可扩展性上不太强大。

CP - 满足一致性，分区容忍必的系统，通常性能不是特别高。

AP - 满足可用性，分区容忍性的系统，通常可能对一致性要求低一些。
 

（1）AP架构（Eureka） 保证可用性

当网络分区出现后，为了保证可用性，系统B可以返回旧值，保证系统的可用性。

结论：违背了一致性C的要求，只满足可用性和分区容错，即AP

（2）CP架构（ZooKeeper/Consul）保证数据一致性

当网络分区出现后，为了保证一致性，就必须拒接请求，否则无法保证一致性。

结论：违背了可用性A的要求，只满足一致性和分区容错，即CP。

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

澄清石灰水t
关注
专栏目录
SpringCloud注册中心Eureka、Consul、Nacos简单对比
LO_YUN的博客
07-30 7295
Spring Cloud注册中心对比 Eureka： Netflix公司开源的注册中心，分为Eureka Server和Eureka Client，Eureka Server需要单独作为一个服务发布，启动之后可以在浏览器中打开，Eureka Client则是需要注册到Eureka Server上的服务。 Eureka有自我保护机制，Eureka Server 在运行期间会去统计心跳失败比例在 15...
SpringCloud 入门（4）：Eureka 与 zookeeper 的区别
Mr_tianyanxiaobai的博客
01-11 1163
Eureka 与 Zookeeper 的区别 比较项 Eureka zookeeper 集群结构 平级 主从 集群角色 主人 Leader、follower observer 是否可以及时知道服务状态变化 不能及时知道 会及时知道 一致性协议（CAP） 注重可用性（AP） 注重一致性(CP) 雪崩保护 有 没有 社区是否活跃 Eureka2.0 不再维护了 持续维护 管理端 有现成的eureka管理端 没有现成的管理端 负载均衡策略 使用ribbon实现 一般可以
SpringCloud篇——一篇文章了解和认识Eureka服务注册与发现、CAP原则、对比Zookeeper以及BASE理论！！！！！！
最新发布
我热爱学习，也乐于分享。无论是科技前沿的洞见，还是生活中的小技巧，我都会在这里与你分享。我相信，知识就是力量，而分享则能让这份力量得到更好的传递。
11-29 1131
一、Eureka定义和理解Netflix在设计Eureka时，遵循的是AP原则Eureka时Netflix的一个子模块，也是核心模块之一。Eureka是基于REST的服务，用于定位服务，以实现云端中间层服务发现和故障转移，服务注册与发现对于微服务来说十分重要，有了服务注册与发现，只需要使用服务的标识符，就可以访问到服务，而不需要修改服务调用的配置文件了，功能类似于Dubbo的注册中心，比如Zookeeper二、Eureka基本架构。
【SpringCloud】Eureka 整体架构 | CAP 原则 | Eureka 自我保护 | Eureka 优雅停服
Java攻城狮修炼中
04-30 359
Eureka 整体架构 Register（服务注册）：把自己的 IP 和端口注册给 Eureka Renew（服务续约）：发送心跳包，每 30 秒发送一次，告诉 Eureka 自己还活着，如果 90 秒还未发送心跳，宕机 Cancel（服务下线）：当 Provider 关闭时会向 Eureka 发送小心，把自己从服务列表中删除，防止 Consumer 调用到不存在的服务 Get Registry（获取服务注册列表）：获取其他服务列表 Replicate（集群中数据同步）：Eureka 集群中的数据复制与同.
Eureka 集群环境
小叶曲
08-16 218
集群环境配置 新建工程springcloud-eureka-7002、springcloud-eureka-7003 按照7001为模板粘贴POM 修改7002和7003的主启动类 修改映射配置 , windows域名映射 集群配置分析 修改3个EurekaServer的yaml文件夹 7001： server: port: 7001 #Eureka配置 eureka: instance: hostname: eureka7001.com #eureka服务端的实
SpringCloud学习二（Eureka服务注册与发现、自我保护机制、集群环境配置、Eureka：CAP原则及对比Zookeeper）
无极
08-07 571
111
SpringCloud 05 Eureka集群环境配置和CAP
小哞^同^学的技术博客
08-07 542
我们 尝试 搭建 三个 注册中心。然后 让它们 互相注册和依赖。如果一旦 有一个 注册中心 崩了，我们也不怕。可以从其它 注册中心里面 注册和引用服务。为什么不注册 自己的 URL 呢？现在 我们可以尝试 关闭掉 其中 一个 注册中心，来模拟 崩掉的情况。你会发现其他 两个注册 中心 活的 好好的，而且 也 有注册 过来的服务。...
ZooKeeper、Eureka、Consul
m0_69526738的博客
04-29 672
如果A是第一需求，那么只要有一个服务在，就能正常接受请求，但是对与返回结果变不能保证，原因是，在分布式部署的时候，数据一致的过程不可能想切线路那么快。 再如果，同事满足一致性和可用性，那么分区容错就很难保证了，也就是单点，也是分布式的基本核心，好了，明白这些理论，就可以在相应的场景选取服务注册与发现了 服务注册中心解决方案 ========== 设计或者选型一个服务注册中心，首先要考虑的就是服务注册与发现机制。纵观当下各种主流的服务注册中心解决方案，大致可归为三类： 应用内：直接集成到应用中，依赖于应用
SpringCloud-Eureka
07-14
Eureka 是 Netflix 在线影片公司开源的一个服务注册与发现的组件，是 Spring Cloud 社区整合为 Spring Cloud Netflix 模块。Eureka 来源于古希腊词汇，意为“发现了”。 知识点二：Eureka 和 Zookeeper 的区别 ...
SpringCloud（2）--服务注册与发现（Eureka、Zookeeper、Consul）
MOKE_SPACE
07-10 4110
文章目录服务注册中心Eureka单机版eureka创建Module其他服务注册到eureka集群版eureka集群原理![在这里插入图片描述](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9ody5tb2tlc3BhY2UuY24vaW1hZ2VzLzIwMjAvMDcvMDcvOGM0YzAxMGIxMTM0ZTY0MzVkMWRhNjUxNjhiYzI3YjYucG5n?x-oss-process=image/format,png)构建新erueka项目其他服务注册到
SpringCloud --- （三）Eureka服务注册与发现《4》（CAP原则和eureka、zookeeper区别））
weixin_43240792的博客
04-16 325
@
第四节：SpringCloud 服务注册与发现Eureka与CAP理论
Mr-让梦冬眠
02-26 351
一、没有使用注册中心搭建的分布式应用缺点: 1)我们的在调用的时候，请求的Ip地址和端口是硬编码的. 若此时，服务提供方(order)服务部署的机器换了端口或者是更换了部署机器的Ip,那么我们需要修改代码重新发布部署. 2) 假设我们的order服务压力过大，我们需要把order服务作为集群，那么意味着 order是多节点部署，比如原来的，我们只有一台服务器，现在有多台服务器，那么作为运维人员 需要在服务消费方进行手工维护一份注册表(容易出错) 3)有人马上回驳我说，我可以通过ng来做负载均衡,对，我首先认
SpringCloud入门(六) ------CAP理论以及Eureka与zookeeper的区别
jym的博客
02-28 4840
CAP理论 CAP理论概述 一个分布式系统最多只能同时满足一致性（Consistency）、可用性（Availability）和分区容错性（Partition tolerance）这三项中的两项。 Consistency 一致性： 即所有节点在同一时间的数据完全一致。 一致性的类别: 强一致性 对于关系型数据库，要求更新过的数据能被后续的访问都能看到，这是强一致性。 Partition Tole...
Eureka、Zookeeper、Consul三大注册中心的异同以及其CAP
初学者
03-24 757
三个注册中心的异同点 组件名 语言 CAP 服务健康检查 对外暴露接口 Spring Cloud集成 Eureka Java AP 可配支持健康检查 HTTP 集成 Consul GO CP 支持健康检查 HTTP、DNS 集成 Zookeeper Java CP 支持健康检查 客户端 集成 CAP 最多只能同时较好的满足两个。 CAP的核心理论是：一个分布式系统不...
SpringCloud服务注册中心比较:Consul vs Zookeeper vs Etcd vs Eureka
Zzhou1990的博客
05-23 1万+
原文链接地址：http://luyiisme.github.io/2017/04/22/spring-cloud-service-discovery-products/ 这里就平时经常用到的服务发现的产品进行下特性的对比，首先看下结论: Feature Consul zookeeper etcd euerka 服务健康检查 服务状态，内存，硬盘等 ...
服务发现比较:Consul vs Zookeeper vs Etcd vs Eureka
热门推荐
dengyisheng的专栏
05-05 2万+
服务发现比较:Consul vs Zookeeper vs Etcd vs Eureka 时间 2017-04-22 08:00:00 Luyi's Blog 原文  http://luyiisme.github.io/2017/04/22/spring-cloud-service-discovery-products/ 主题 Consul etcd ZooKeep
Eureka、Zookeeper、Consul异同点
bighuan的博客
03-21 608
1 CAP理论 C：consistency强一致性 A：availability可用性 P：partition tolerance分区容错性 CAP理论的核心是：一个分布式系统不可能同时很好的满足一致性、可用性、分区容错性这三个需求。因此，根据CAP原理将NoSql数据库分成了满足CA原则、CP原则、AP原则三大类。 CA：单点集群，满足一致性、可用性的系统，通常在可扩展性上不太强大。 ...
Eureka、Zookeeper和Consul 的区别
weixin_33970449的博客
02-26 1717
2019独角兽企业重金招聘Python工程师标准>>> ...
Eureka&Zookeeper&Consul 原理与对比
小松的博客
07-10 5364
看主要区别的话，三者都可作为注册中心，具体怎么选择可根据 CAP 定理去选择 CAP 定理 CAP定理：CAP定理又称CAP原则，指的是在一个分布式系统中，一致性（Consistency）、可用性（Availability）、分区容错性（Partition tolerance）。CAP 原则指的是，这三个要素最多只能同时实现两点，不可能三者兼顾。 一致性（C）：在分布式系统中的所有数据备份，在...
SpringCloud Eureka：服务注册与发现框架详解与Zookeeper比较
SpringCloud-Eureka是SpringCloud生态系统中的一个重要组件，由Netflix开源，主要功能是实现服务的注册与发现，它属于SpringCloud Netflix模块的一部分。Eureka的设计理念是为了解决分布式系统中服务间的通信问题，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值