SpringCloud（1）基础 Eureka ZooKeeper Consul CAP

前言：现在主流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

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

 

    4.0.0  

    com.atguigu
    LearnCloud
    1.0.0-SNAPSHOT
    pom
    
    
    
        UTF-8
        1.8
        1.8
        4.12
        1.2.17
        1.16.18
        5.1.47
        1.1.16
        1.3.0
    
    
    
    
        
            
            
                org.springframework.boot
                spring-boot-dependencies
                2.2.2.RELEASE
                pom
                import
            
            
            
                org.springframework.cloud
                spring-cloud-dependencies
                Hoxton.SR1
                pom
                import
            
            
            
                com.alibaba.cloud
                spring-cloud-alibaba-dependencies
                2.1.0.RELEASE
                pom
                import
            
            
                mysql
                mysql-connector-java
                ${mysql.version}
            
            
                com.alibaba
                druid
                ${druid.version}
            
            
                org.mybatis.spring.boot
                mybatis-spring-boot-starter
                ${mybatis.spring.boot.version}
            
            
                junit
                junit
                ${junit.version}
            
            
                log4j
                log4j
                ${log4j.version}
            
            
                org.projectlombok
                lombok
                ${lombok.version}
                true
            
        
    

    
        
            
                org.springframework.boot
                spring-boot-maven-plugin
                
                    true
                    true
                
            
        
    

复习maven重点：

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

父项目

    
        
        mysq1
        mysql-connector-java
        5.1.2
        
    

子项目

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

    
    mysq1
    mysql-connector-java
    

     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

    
        LearnCloud
        com.atguigu
        1.0.0-SNAPSHOT
    
    4.0.0

    cloud-provider-payment8001

    
        
        
            org.springframework.cloud
            spring-cloud-starter-zipkin
        
        
        
            org.springframework.cloud
            spring-cloud-starter-netflix-eureka-client
        
            
        
        
            org.springframework.boot
            spring-boot-starter-web
        
        
            org.springframework.boot
            spring-boot-starter-actuator
        
        
            org.mybatis.spring.boot
            mybatis-spring-boot-starter
        
        
            com.alibaba
            druid-spring-boot-starter
            1.1.10
        
        
        
            mysql
            mysql-connector-java
        
        
        
            org.springframework.boot
            spring-boot-starter-jdbc
        
        
            org.springframework.boot
            spring-boot-devtools
            runtime
            true
        
        
            org.projectlombok
            lombok
            true
        
        
            org.springframework.boot
            spring-boot-starter-test
            test
        
    

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

    
        insert into payment(serial)  values(#{serial});
    
    
    
        
        
    

    
        select * from payment where id=#{id};
    

路径：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 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）添加热部署依赖

    org.springframework.boot
    spring-boot-devtools
    runtime
    true

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

    
    
        
            org.springframework.boot
            spring-boot-maven-plugin
            
                true
                true
            
        
    

（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

  
    LearnCloud
    com.atguigu
    1.0.0-SNAPSHOT
  
  4.0.0

  cloud-consumer-order80

  
    UTF-8
    1.7
    1.7
  

  
    
      org.springframework.boot
      spring-boot-starter-web
    
    
      org.springframework.boot
      spring-boot-starter-actuator
    

    
      org.springframework.boot
      spring-boot-devtools
      runtime
      true
    
    
      org.projectlombok
      lombok
      true
    
    
      org.springframework.boot
      spring-boot-starter-test
      test
    
  

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 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 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，还记得前面专门在CommonResult实体类中写了一个只有两个参数的构造器吗

（4）测试：

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

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

扩展：IDEA中快速开启Dashboard

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

修改方式：

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

在中修改或添加以下代码：

2.5 cloud-api-commons 子工程

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

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

公共父类上New—Module

2.5.2 改POM

		
            org.springframework.boot
            spring-boot-devtools
            runtime
            true
        
        
            org.projectlombok
            lombok
            true
        
        
            cn.hutool
            hutool-all
            5.3.7
        

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

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

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

2.6.3 将该项目用maven打包发布

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

    com.atguigu.springcloud
    cloud-api-commons
    ${project.version}

猜想：不写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服务器依赖

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

 ② 完整pom

    
        LearnCloud
        com.atguigu.springcloud
        1.0.0-SNAPSHOT
    
    4.0.0

    cloud-eureka-server7001

    
        
        
            org.springframework.cloud
            spring-cloud-starter-netflix-eureka-server
        
        
        
            com.atguigu.springcloud
            cloud-api-commons
            ${project.version}
        
        
        
            org.springframework.boot
            spring-boot-starter-web
        
        
            org.springframework.boot
            spring-boot-starter-actuator
        
        
        
            org.springframework.boot
            spring-boot-devtools
            runtime
            true
        
        
            org.projectlombok
            lombok
        
        
            org.springframework.boot
            spring-boot-starter-test
            test
        
        
            junit
            junit
        
    

（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（客户端依赖）

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

（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客户端

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

（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 services = discoveryClient.getServices();
        for (String element : services) {
            log.info("*****element: "+element);
        }
        //获取具体服务下的实例列表
        List 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不同的地方）

		
        
            org.springframework.cloud
            spring-cloud-starter-zookeeper-discovery
            
                
                
                    org.apache.zookeeper
                    zookeeper
                
            
        
        
        
            org.apache.zookeeper
            zookeeper
            3.6.1

需要注意的是：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

    
        LearnCloud
        com.atguigu.springcloud
        1.0.0-SNAPSHOT
    
    4.0.0

    cloud-consumerzk-order80

    
   
        
        
            org.springframework.cloud
            spring-cloud-starter-zookeeper-discovery
            
            
                
                    org.apache.zookeeper
                    zookeeper
                
            
        
        
        
            org.apache.zookeeper
            zookeeper
            3.6.1
        
    

（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依赖）

    
        LearnCloud
        com.atguigu.springcloud
        1.0.0-SNAPSHOT
    
    4.0.0

    cloud-providerconsul-payment8006
    
        
        
            org.springframework.cloud
            spring-cloud-starter-consul-discovery
        
    

（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

    
        LearnCloud
        com.atguigu.springcloud
        1.0.0-SNAPSHOT
    
    4.0.0

    cloud-consumerconsul-order80
    
        
        
            org.springframework.cloud
            spring-cloud-starter-consul-discovery
        
    

（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集成
Eureka	Java	AP	可配支持	HTTP	已集成
Consul	Go	CP	支持	HTTP/DNS	已集成
Zookeeper	Java	CP	支持	客户端	已集成

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。