是阿岚呐

Spring Cloud（H版）女朋友看了都会的超详细保姆级笔记！看完还不会算我输！

1. 微服务架构理论

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tjPWmmpo-1619837391777)(E:\学习笔记\图片\image-20201019134302836.png)]$

1.1. SpringCloud简介

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Mt9XOLHL-1619837391782)(E:\学习笔记\图片\image-20201019134723201.png)]$

1.2. SpringCloud技术栈

2. 环境搭建

2.1. Boot和Cloud版本选择

依赖关系：
最终定型
Boot已经有2.2.4而且符合规范，为啥要选2.2.2？

官网推荐：

2.2. Cloud组件停更说明

停更引发的 “升级惨案”
- 停更不停用
- 变更

2.3. 父工程Project空间新建

微服务Cloud整体聚合父工程Project

2.4. 父工程pom文件


<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.0modelVersion>

    <groupId>com.atguigu.springcloudgroupId>
    <artifactId>cloud2020artifactId>
    <version>1.0-SNAPSHOTversion>
    <packaging>pompackaging>

    
    <properties>
            <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
            <maven.compiler.source>1.8maven.compiler.source>
            <maven.compiler.target>1.8maven.compiler.target>
            <junit.version>4.12junit.version>
            <lombok.version>1.18.10lombok.version>
            <log4j.version>1.2.17log4j.version>
            <mysql.version>5.1.47mysql.version>
            <druid.version>1.1.16druid.version>
            <mybatis.spring.boot.version>1.3.0mybatis.spring.boot.version>
    properties>

    
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.apache.maven.pluginsgroupId>
                <artifactId>maven-project-info-reports-pluginartifactId>
                <version>3.0.0version>
            dependency>
            
            <dependency>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-dependenciesartifactId>
                <version>2.2.2.RELEASEversion>
                <type>pomtype>
                <scope>importscope>
            dependency>
            
            <dependency>
                <groupId>org.springframework.cloudgroupId>
                <artifactId>spring-cloud-dependenciesartifactId>
                <version>Hoxton.SR1version>
                <type>pomtype>
                <scope>importscope>
            dependency>

            
            <dependency>
                <groupId>com.alibaba.cloudgroupId>
                <artifactId>spring-cloud-alibaba-dependenciesartifactId>
                <version>2.1.0.RELEASEversion>
                <type>pomtype>
                <scope>importscope>
            dependency>
            
            <dependency>
                <groupId>mysqlgroupId>
                <artifactId>mysql-connector-javaartifactId>
                <version>${mysql.version}version>
            dependency>
            
            <dependency>
                <groupId>com.alibabagroupId>
                <artifactId>druidartifactId>
                <version>${druid.version}version>
            dependency>

            
            <dependency>
                <groupId>org.mybatis.spring.bootgroupId>
                <artifactId>mybatis-spring-boot-starterartifactId>
                <version>${mybatis.spring.boot.version}version>
            dependency>
            
            <dependency>
                <groupId>junitgroupId>
                <artifactId>junitartifactId>
                <version>${junit.version}version>
            dependency>
            
            <dependency>
                <groupId>log4jgroupId>
                <artifactId>log4jartifactId>
                <version>${log4j.version}version>
            dependency>
        dependencies>
    dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-maven-pluginartifactId>
                <configuration>
                    <fork>truefork>
                    <addResources>trueaddResources>
                configuration>
            plugin>
        plugins>
    build>


project>

2.5. DependencyManagerment和Dependencies

DependencyManagerment：
- Maven使用dependencyManagement元素来提供了一种管理依赖版本号的方式。
- 通常会在一个组织或者项目的最顶层的父POM中看到dependencyManagement元素
- 使用pom.xml中的dependencyManagement元素能让所有在子项目中引用一个依赖而不用显式的列出版本号。Maven 会沿着父子层次向上走，直到找到一个拥有dependencyManagement元素的项目，然后它就会使用这个dependencyManagement元素中指定的版本号。
- 这样做的好处就是:如果有多个子项目都引用同一样依赖，则可以避免在每个使用的子项目里都声明一个版本号，这样当想升级或切换到另一个版本时，只需要在顶层父容器里更新，而不需要一个一个子项目的修改﹔另外如果某个子项目需要另外的一个版本，只需要声明version就可。
- dependencyManagement里只是声明依赖，并不实现引入，因此子项目需要显示的声明需要用的依赖。
- 如果不在子项目中声明依赖，是不会从父项目中继承下来的；只有在子项目中写了该依赖项，并且没有指定具体版本，才会从父项目中继承该项，并且version和scope都读取自父pom；如果子项目中指定了版本号，那么会使用子项目中指定的jar版本。
跳过单元测试：

3. 项目初始模块搭建

3.1 支付模块

3.1.1 支付模块搭建（上）

微服务模块：

建module

改pom


<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>cloud2020artifactId>
        <groupId>com.atguigu.springcloudgroupId>
        <version>1.0-SNAPSHOTversion>
    parent>
    <modelVersion>4.0.0modelVersion>

    <artifactId>cloud-provider-payment8081artifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-actuatorartifactId>
        dependency>
        <dependency>
            <groupId>org.mybatis.spring.bootgroupId>
            <artifactId>mybatis-spring-boot-starterartifactId>
        dependency>
        <dependency>
            <groupId>com.alibabagroupId>
            <artifactId>druid-spring-boot-starterartifactId>
            <version>1.1.10version>
        dependency>
        
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-jdbcartifactId>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-devtoolsartifactId>
            <scope>runtimescope>
            <optional>trueoptional>
        dependency>
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
            <optional>trueoptional>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <scope>testscope>
        dependency>



    dependencies>


project>

写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


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;

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

业务类

3.1.2 支付模块搭建（中）

业务类：

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

entities

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nXFF5eN3-1619837391789)(E:\学习笔记\图片\image-20201019195441201.png)]$

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

    public CommonResult(Integer code,String message){
       
        this(code,message,null);
    }
}

dao

接口PaymentDao

public int add(Payment payment);
public Payment getPaymentById(@Param("id") Long id);

mybatis映射文件PaymentMapper.xml



<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" resultType="BaseResultMap">
        select * from payment where id=#{id};
    select>
    
mapper>

service

 public interface PaymentService {
       
     public int add(Payment payment);
     public Payment getPaymentById(@Param("id") Long id);
 }

 @Service
 public class PaymentServiceImpl implements PaymentService {
       
     @Resource
     private PaymentDao paymentDao;

     public int add(Payment payment){
       
         return paymentDao.add(payment);
     }
     public Payment getPaymentById(@Param("id") Long id){
       
         return paymentDao.getPaymentById(id);
     }
 }

controller

@RestController
    @Slf4j
    public class PaymentController {
       
        @Resource
        private PaymentService paymentService;

        @PostMapping(value="/payment/create")
        public CommonResult create(Payment payment){
       
            int result=paymentService.add(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);
            log.info("******插入结果："+payment);
            if(payment!=null){
       
                return new CommonResult(200,"查询成功",payment);
            }else {
       
                return new CommonResult(444,"没有对应记录，查询ID："+id,null);
            }
        }
    }

3.1.3. 支付模块搭建（下）

测试：
- 浏览器对Post请求不支持测试，需要用Postman
- 需要自测通过
总结：
- 建module
- 改pom
- 写yml
- 主启动类
- 业务类

3.2. 热部署Devtools

添加devtools依赖

 <dependency>
     <groupId>org.springframework.bootgroupId>
     <artifactId	>spring-boot-devtoolsartifactId>
     <scope>runtimescope>
     <optional>trueoptional>
 dependency>

添加插件到父类的pom.xml里面

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-maven-pluginartifactId>
            <configuration>
                <fork>truefork>
                <addResources>trueaddResources>
            configuration>
        plugin>
    plugins>
build>

开启自动编译选项
更新池

ctrl+shift+alt+/

3.3 消费者模块

3.3.1. 消费者订单模块（上）

pom

 
 <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>cloud2020artifactId>
         <groupId>com.atguigu.springcloudgroupId>
         <version>1.0-SNAPSHOTversion>
     parent>
     <modelVersion>4.0.0modelVersion>

     <artifactId>cloud-consumer-order80artifactId>

     <dependencies>
         <dependency>
             <groupId>org.springframework.bootgroupId>
             <artifactId>spring-boot-starter-webartifactId>
         dependency>
         <dependency>
             <groupId>org.springframework.bootgroupId>
             <artifactId>spring-boot-starter-actuatorartifactId>
         dependency>
         <dependency>
             <groupId>org.springframework.bootgroupId>
             <artifactId>spring-boot-devtoolsartifactId>
             <scope>runtimescope>
             <optional>trueoptional>
         dependency>
         <dependency>
             <groupId>org.projectlombokgroupId>
             <artifactId>lombokartifactId>
             <optional>trueoptional>
         dependency>
         <dependency>
             <groupId>org.springframework.bootgroupId>
             <artifactId>spring-boot-starter-testartifactId>
             <scope>testscope>
         dependency>
     dependencies>


 project>

yml
```
server:  port: 80
```

业务类：

entities

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YUC2Q0nG-1619837391790)(E:\学习笔记\图片\image-20201020120154484.png)]$
RestTemplate
- RestTemplate提供了多种便捷访问远程Http服务的方法，是一种简单便捷的访问restful服务模块类，是Spring提供的用于访问Reset服务的客户端模块工具类
- 使用：
  
  使用restTemplate访问restful接口非常简单，url：rest请求地址，requestMap：请求参数，ResponseBean.class：Http响应转换被转换成的对象类型，要写一个配置类

controller

@RestController
@Slf4j
public class OrderController {
         

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

    @Resource
    private RestTemplate restTemplate;

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

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

测试

3.3.2 消费者订单模块（下）

在插入时候，前端显示正确，但是数据库中的serial却没有？
- RequestBody
Dashboard
- 通过修改idea的workspace.xml的方式来快速打开Run Dashboard窗口（.idea------>workspace.xml）
- 开启Run DashBoard

3.4. 工程重构

问题：不同模块中有重复部分：entityes，需要进行重构

新建module

pom依赖


<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>cloud2020artifactId>
        <groupId>com.atguigu.springcloudgroupId>
        <version>1.0-SNAPSHOTversion>
    parent>
    <modelVersion>4.0.0modelVersion>

    <artifactId>cloud-api-commonsartifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-devtoolsartifactId>
            <scope>runtimescope>
            <optional>trueoptional>
        dependency>

        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
            <optional>trueoptional>
        dependency>

        <dependency>
            <groupId>cn.hutoolgroupId>
            <artifactId>hutool-allartifactId>
            <version>5.1.0version>
        dependency>
    dependencies>


project>

entities

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6EQfUUiO-1619837391791)(E:\学习笔记\图片\image-20201020154515034.png)]$
maven命令clean install

订单80和支付8001分别改造

删除各自原先有的entities文件夹

各自粘贴POM内容

<dependency>    
    <groupId>com.atguigu.springcloudgroupId>
    <artifactId>cloud-api-commonsartifactId>
    <version>${project.version}version>
dependency>

4. Eurake

4.1. Eureka基础知识

什么是服务治理？

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

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

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

在服务注册与发现中，有一个注册中心。当服务器启动的时候，会把当前自己服务器的信息比加服务地址通讯地址等以别名方式注册到注册中心上。另一方(消费者服务提供者)，以该别名的方式去注册中心上获取到实际的服务通讯地址，然后再实现本地RPC调用。

RPC远程调用框架核心设计思想在于注册中心，因为使用注册中心管理每个服务与服务之间的一个依赖关系(服务治理概念)。在任何rpc远程框架中，都会有一个注册中心(存放服务地址相关信息(接口地址)
Eureka两组件：
- Eureka Serve：提供服务注册服务
  
  各个微服务节点通过配置启动后，会在Eureka Server中进行注册，这样Eureka Server中的服务注册表中将会存储所有可用服务节点的信息，服务节点的信息可以在界面中直观看到。
- Eureka Client：通过注册中心进行访问
  
  是一个Java客户端，用于简化Eureka Server的交互，客户端同时也具备一个内置的、使用轮询(round-robin)负载算法的负载均衡器。在应用启动后，将会向Eureka Server发送心跳(默认周期为30秒)。如果Eureka Server在多个心跳周期内没有接收到某个节点的心跳，EurekaServer将会从服务注册表中把这个服务节点移除（默认90秒)

4.2. Eureka服务端安装

Idea生成EurekaServe端服务注册中心（物业公司）

建Module

改POM


<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>cloud2020artifactId>
        <groupId>com.atguigu.springcloudgroupId>
        <version>1.0-SNAPSHOTversion>
    parent>
    <modelVersion>4.0.0modelVersion>

    <artifactId>cloud-eureka-serve7001artifactId>

    <dependencies>
        
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-netflix-eureka-serverartifactId>
        dependency>
        
        <dependency>
        <groupId>com.atguigu.springcloudgroupId>
        <artifactId>cloud-api-commonsartifactId>
        <version>${project.version}version>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-actuatorartifactId>
        dependency>

        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-devtoolsartifactId>
            <scope>runtimescope>
            <optional>trueoptional>
        dependency>
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <scope>testscope>
        dependency>
        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
        dependency>

    dependencies>


project>

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

@SpringBootApplication
public class EurekaMain7001 {
         

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

}

测试

localhost:7001

4.3. 支持微服务8001入驻Eureka

修改pom

  
  <dependency>
      <groupId>org.springframework.cloudgroupId>
      <artifactId>spring-cloud-starter-netflix-eureka-clientartifactId>
  dependency>

改yml

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

修改修改8001微服务客户端

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

测试
- 先要启动EurekaServer
- 自我保护机制：
- 注册名：

4.4. 支持微服务80入驻Eureka

改Pom

  <dependency>
      <groupId>org. springframework.cloudgroupId>
      <artifactId>spring-cloud-starter-netflix-eureka-clientartifactId>
  dependency>

改yml

  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

修改微服务80

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

测试

4.5. Eureka集群原理说明

4.6. Eureka集群环境搭建

思想：相互注册相互守望

新建cloud-eureka-server7002
POM（与上面的一样）
修改映射配置文件
- 找到C:\Windows\System32\drivers\etc路径下的hosts文件

YML

7001

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

7002

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

主启动（7002与7001一致）

4.7. 两微服务注册进集群

支付服务8001发布到集群

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

订单服务发布到集群

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

测试

先启动7001,7002，再启动8001，最后80

4.8. 支付微服务集群配置

新建8002
POM一样
改yml（端口号）
主启动、业务类直接粘贴
添加两个支付服务的端口号区别！
完成负载均衡
- 订单服务不可写死
  
  $[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JTXRWdV6-1619837391793)(E:\学习笔记\图片\image-20201021192745721.png)]$
- 使用**@LoadBalanced**赋予RestTemplate负载均衡能力

4.9. actuator微服务信息完整

主机名称：服务名称的修改
访问信息有IP显示

4.10. 服务发现Discover

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

修改cloud-provider-payment8001的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 lombok.extern.slf4j.Slf4j;
  import org.springframework.beans.factory.annotation.Value;
  import org.springframework.cloud.client.ServiceInstance;
  import org.springframework.cloud.client.discovery.DiscoveryClient;
  import org.springframework.web.bind.annotation.*;

  import javax.annotation.Resource;
  import java.util.List;


  @Slf4j
  @RestController
  public class PaymentController {
       
      @Resource
      private PaymentService paymentService;

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

      @Resource
      private DiscoveryClient discoveryClient;

      @PostMapping(value="/payment/create")

      public CommonResult add(@RequestBody Payment payment){
       
          int result=paymentService.add(payment);
          log.info("******插入结果："+result);
          if(result>0){
       
              return new CommonResult(200,"插入数据库成功,serverPort:"+serverPort,result);

          }else {
       
              return new CommonResult(444,"插入数据库失败",null);
          }
      }


      @GetMapping(value="/payment/get/{id}")
      public CommonResult getPaymentById(@PathVariable("id") Long id){
       
          Payment payment = paymentService.getPaymentById(id);
          log.info("******插入结果："+payment+"哈哈哈");
          if(payment!=null){
       
              return new CommonResult(200,"查询成功,serverPort："+serverPort,payment);
          }else {
       
              return new CommonResult(444,"没有对应记录，查询ID："+id,null);
          }
      }

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


  }

修改主启动类

4.11. Eureka自我保护理论知识

故障现象

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

一句话:某时刻某一个微服务不可用了，Eureka不会立刻清理，依旧会对该微服务的信息进行保存，属于CAP里面的AP分支

4.12. 禁止Eureka自我保护

注册中心7001
客户端
测试
- 7001,8001配置
- 先启动7001，再启动8001
- 关闭8001

5. Zookeeper

5.1. 支付微服务入驻Zookeeper

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

POM（必须与本机安装的Zookeeper版本号一致）

  
  <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>cloud2020artifactId>
          <groupId>com.atguigu.springcloudgroupId>
          <version>1.0-SNAPSHOTversion>
      parent>
      <modelVersion>4.0.0modelVersion>

      <artifactId>cloud-provider-payment8004artifactId>

      <dependencies>
          <dependency>    
              <groupId>com.atguigu.springcloudgroupId>
              <artifactId>cloud-api-commonsartifactId>
              <version>${project.version}version>
          dependency>

          <dependency>
              <groupId>org.springframework.bootgroupId>
              <artifactId>spring-boot-starter-webartifactId>
          dependency>

          <dependency>
              <groupId>org.springframework.bootgroupId>
              <artifactId>spring-boot-devtoolsartifactId>
              <scope>runtimescope>
              <optional>trueoptional>
          dependency>
          <dependency>
              <groupId>org.projectlombokgroupId>
              <artifactId>lombokartifactId>
              <optional>trueoptional>
          dependency>
          <dependency>
              <groupId>org.springframework.bootgroupId>
              <artifactId>spring-boot-starter-testartifactId>
              <scope>testscope>
          dependency>
          <dependency>
              <groupId>org.springframework.bootgroupId>
              <artifactId>spring-boot-starter-actuatorartifactId>
          dependency>
          <dependency>
              <groupId>org.springframework.cloudgroupId>
              <artifactId>spring-cloud-starter-zookeeper-discoveryartifactId>
              <exclusions>
                  <exclusion>
                      <groupId>org.apache.zookeepergroupId>
                      <artifactId>zookeeperartifactId>
                  exclusion>
              exclusions>
          dependency>
          <dependency>
              <groupId>org.apache.zookeepergroupId>
              <artifactId>zookeeperartifactId>
              <version>3.4.10version>
          dependency>
      dependencies>
  project>

YML

  #8004表示注册到zookeeper服务器的支付服务提供者端口号
  server :
    port: 8004
  #服务别名----注册zookeeper.到注册中心名称
  spring:
    application:
      name: cloud- provider- payment
    cloud:
      zookeeper :
        connect-string: 10.98.12.226:2181

主启动类

  package com.atguigu.springcloud;

  import org.springframework.boot.SpringApplication;
  import org.springframework.boot.autoconfigure.SpringBootApplication;
  import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

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

Controller

  package com.atguigu.springcloud.controller;


  import lombok.extern.slf4j.Slf4j;
  import org.springframework.beans.factory.annotation.Value;
  import org.springframework.web.bind.annotation.RequestMapping;
  import org.springframework.web.bind.annotation.RestController;

  import java.util.UUID;

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

  }

测试

5.2. 临时节点和持久节点

结论：临时节点

过程：停止了8004工程之后，会保留一段时间，然后再清除服务

5.3. 订单微服务入驻Zookeeper

新建order80

POM

  
  <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>cloud2020artifactId>
          <groupId>com.atguigu.springcloudgroupId>
          <version>1.0-SNAPSHOTversion>
      parent>
      <modelVersion>4.0.0modelVersion>

      <artifactId>cloud-consumerzk-order80artifactId>
      <dependencies>
          <dependency>    
              <groupId>com.atguigu.springcloudgroupId>
              <artifactId>cloud-api-commonsartifactId>
              <version>${project.version}version>
          dependency>

          <dependency>
              <groupId>org.springframework.bootgroupId>
              <artifactId>spring-boot-starter-webartifactId>
          dependency>

          <dependency>
              <groupId>org.springframework.bootgroupId>
              <artifactId>spring-boot-devtoolsartifactId>
              <scope>runtimescope>
              <optional>trueoptional>
          dependency>
          <dependency>
              <groupId>org.projectlombokgroupId>
              <artifactId>lombokartifactId>
              <optional>trueoptional>
          dependency>
          <dependency>
              <groupId>org.springframework.bootgroupId>
              <artifactId>spring-boot-starter-testartifactId>
              <scope>testscope>
          dependency>
          <dependency>
              <groupId>org.springframework.bootgroupId>
              <artifactId>spring-boot-starter-actuatorartifactId>
          dependency>
          <dependency>
              <groupId>org.springframework.cloudgroupId>
              <artifactId>spring-cloud-starter-zookeeper-discoveryartifactId>
              <exclusions>
                  <exclusion>
                      <groupId>org.apache.zookeepergroupId>
                      <artifactId>zookeeperartifactId>
                  exclusion>
              exclusions>
          dependency>
          <dependency>
              <groupId>org.apache.zookeepergroupId>
              <artifactId>zookeeperartifactId>
              <version>3.4.10version>
          dependency>
      dependencies>

  project>

YML

  server:
    port: 80
  spring:
    application:
      name: cloud-consumer-order
    cloud:
  #注册到zookeeper地址
      zookeeper:
        connect-string: 10.98.12.226:2181

主启动

  package com.atguigu.springcloud;

  import org.springframework.boot.SpringApplication;
  import org.springframework.boot.autoconfigure.SpringBootApplication;
  import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

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

Controller

  package com.atguigu.config;

  import org.springframework.cloud.client.loadbalancer.LoadBalanced;
  import org.springframework.context.annotation.Bean;
  import org.springframework.context.annotation.Configuration;
  import org.springframework.web.client.RestTemplate;

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

  package com.atguigu.controller;

  import lombok.extern.slf4j.Slf4j;
  import org.springframework.web.bind.annotation.GetMapping;
  import org.springframework.web.bind.annotation.RestController;
  import org.springframework.web.client.RestTemplate;

  import javax.annotation.Resource;

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

6. Consul

6.1. Consul概述及安装

Consul是一套开源的分布式服务发现和配置管理系统，由HashiCorp公司用Go语言开发。
提供了微服务系统中的服务治理、配置中心、控制总线等功能。这些功能中的每一个都可以根据需要单独使用，也可以一起使用以构

建全方位的服务网格，总之Consul提供了一种完整的服务网格解决方案。
它具有很多优点。包括:基于raft协议，比较简洁;支持健康检查,同时支持HTTP和DNS协议支持跨数据中心的WAN集群提供图形界面跨

平台，支持Linux、Mac、Windows
能干嘛？

安装之后一定要将consul.exe的目录配置到环境变量中：

使用开发模式启动：

6.2. 服务提供者注册进Consul

新建8006

POM

  
  <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>cloud2020artifactId>
          <groupId>com.atguigu.springcloudgroupId>
          <version>1.0-SNAPSHOTversion>
      parent>
      <modelVersion>4.0.0modelVersion>

      <artifactId>cloud-providerconsul-payment8006artifactId>
      <dependencies>
          <dependency>
              <groupId>org.springframework.cloudgroupId>
              <artifactId>spring-cloud-starter-consul-discoveryartifactId>
          dependency>
          <dependency>
              <groupId>org.springframework.bootgroupId>
              <artifactId>spring-boot-starter-webartifactId>
          dependency>

          <dependency>
              <groupId>org.springframework.bootgroupId>
              <artifactId>spring-boot-devtoolsartifactId>
              <scope>runtimescope>
              <optional>trueoptional>
          dependency>
          <dependency>
              <groupId>org.projectlombokgroupId>
              <artifactId>lombokartifactId>
              <optional>trueoptional>
          dependency>
          <dependency>
              <groupId>org.springframework.bootgroupId>
              <artifactId>spring-boot-starter-testartifactId>
              <scope>testscope>
          dependency>
          <dependency>
              <groupId>org.springframework.bootgroupId>
              <artifactId>spring-boot-starter-actuatorartifactId>
          dependency>
      dependencies>

  project>

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}

主启动类

业务类

  package com.atguigu.controller;

  import lombok.extern.slf4j.Slf4j;
  import org.springframework.beans.factory.annotation.Value;
  import org.springframework.web.bind.annotation.RequestMapping;
  import org.springframework.web.bind.annotation.RestController;

  import java.util.UUID;

  @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.3. 消费者注册进Consul

新建Moduleorder80

POM

  
  <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>cloud2020artifactId>
          <groupId>com.atguigu.springcloudgroupId>
          <version>1.0-SNAPSHOTversion>
      parent>
      <modelVersion>4.0.0modelVersion>

      <artifactId>cloud-consumerconsul-order80artifactId>
      <dependencies>
          <dependency>
              <groupId>org.springframework.cloudgroupId>
              <artifactId>spring-cloud-starter-consul-discoveryartifactId>
          dependency>
          <dependency>
              <groupId>org.springframework.bootgroupId>
              <artifactId>spring-boot-starter-webartifactId>
          dependency>

          <dependency>
              <groupId>org.springframework.bootgroupId>
              <artifactId>spring-boot-devtoolsartifactId>
              <scope>runtimescope>
              <optional>trueoptional>
          dependency>
          <dependency>
              <groupId>org.projectlombokgroupId>
              <artifactId>lombokartifactId>
              <optional>trueoptional>
          dependency>
          <dependency>
              <groupId>org.springframework.bootgroupId>
              <artifactId>spring-boot-starter-testartifactId>
              <scope>testscope>
          dependency>
          <dependency>
              <groupId>org.springframework.bootgroupId>
              <artifactId>spring-boot-starter-actuatorartifactId>
          dependency>
      dependencies>

  project>

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}

主启动类

配置Bean

  package com.atguigu.springcloud.config;

  import org.springframework.cloud.client.loadbalancer.LoadBalanced;
  import org.springframework.context.annotation.Bean;
  import org.springframework.context.annotation.Configuration;
  import org.springframework.web.client.RestTemplate;

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

Controller

  package com.atguigu.springcloud.controller;

  import org.springframework.web.bind.annotation.GetMapping;
  import org.springframework.web.client.RestTemplate;

  import javax.annotation.Resource;

  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.4. 三个注册中心的异同

组件名	语言	CAP	服务健康检查	对外暴露接口	Spring Cloud集成
Eureka	Java	AP	可配支持	HTTP	已集成
Consul	Go	CP	支持	HTTP/DNS	已集成
Zookeeper	Java	CP	支持	客户端	已集成

CAP：
- C:Consistency（强一致性）
  A:Availability 可用性）
  P:Partition tolerance（分区容错性）
  
  CAP理论关注粒度是数据，而不是整体系统设计的策略
- 最多只能同时较好的满足两个。
  
  CAP理论的核心是：一个分布式系统不可能同时很好的满足一致性，可用性和分区容错性这三个需求，因此，根据CAР原理将NoSQL数据库分成了满足CA原则、满足CP原则和满足AP原则三大类：

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

AP：满足可用性，分区容错性的系统，通常可能对—致性要求低一些

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

7. Ribbon

7.1. 概述

Spring Cloud Ribbon是基于Netflix Ribbon实现的一套客户端负载均衡的工具。
简单的说，Ribbon是Netflix发布的开源项目，主要功能是提供客户端的软件负载均衡算法和服务调用。Ribbon客户端组件提供一系列完善的配置项如连接超时，重试等。简单的说，就是在配置文件中列出Load Balancer(简称LB)后面所有的机器，Ribbon会自动的帮助你基于某种规则(如简单轮询，随机连接等）去连接这些机器。我们很容易使用Ribbon实现自定义的负载均衡算法。
能干嘛？
- LB（负载均衡）
一句话：负载均衡+RestTemplate调用
LB（负载均衡）
- 简单的说就是将用户的请求平摊的分配到多个服务上，从而达到系统的HA(高可用）。常见的负载均衡有软件Nginx，LVS，硬件F5等。
- Ribbon本地负载均衡客户端VS Nginx服务端负载均衡区别：
  - Nginx是服务器负载均衡，客户端所有请求都会交给nginx，然后由nginx实现转发请求。即负载均衡是由服务端实现的。
  - Ribbon本地负载均衡，在调用微服务接口时候，会在注册中心上获取注册信息服务列表之后缓存到JVM本地，从而在本地实现RPC远程服务调用技术。
- 集中式LB：
  
  即在服务的消费方和提供方之间使用独立的LB设施(可以是硬件，如F5,也可以是软件，如nginx)，由该设施负责把访问请求通过某种策略转发至服务的提供方
- 进程内LB：
  
  将LB逻辑集成到消费方，消费方从服务注册中心获知有哪些地址可用，然后自己再从这些地址中选择出一个合适的服务器。Ribbon就属于进程内LB，它只是一个类库，集成于消费方进程，消费方通过它来获取到服务提供方的地址。

7.2 Ribbon演示

Ribbon其实就是一个软负载均衡的客户端组件，他可以和其他所需请求的客户端结合使用，和eureka结合只是其中的一个实例。

Ribbon在工作时分成两步：
其中Ribbon提供了多种策略:比如轮询、随机和根据响应时间加权。
- 第一步先选择EurekaServer ,它优先选择在同一个区域内负载较少的server.
- 第二步再根据用户指定的策略，在从server取到的服务注册列表中选择一个地址
在新版的Eurake的jar包中已经整合了Ribbon！
RestTemplate
- getForObject方法/getForEntity方法
- postForObject方法/postForEntity方法
- post方法
- get方法

7.3 Ribbon核心组件IRule

IRule：根据特定算法中从服务列表中选取一个要访问的服务

如何替换当前的负载规则？----- 修改order80

注意配置细节
新建package

新建MySelfRule规则

package com.atguigu.myrule;

import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RandomRule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MySelfRule {
         
    @Bean
    public IRule myRule(){
         
        return new RandomRule(); //定义为随机
    }
}

主启动类添加@RibbonClient
测试

7.4 默认负载轮询算法原理

原理
源码分析（下标+cas+自旋锁）

8. OpenFeign

8.1 概述

Feign是一个声明式WebService客户端。使用Feign能让编写Web Service客户端更加简单。
它的使用方法是定义一个服务接口然后在上面添加注解。Feign也支持可拔插式的编码器和解码器。Spring Cloud对Feign进行了封装，使其支持了Spring MVC标准注解和HttpMessageConverters。Feign可以与Eureka和Ribbon组合使用以支持负载均衡
能干嘛？
Feign和OpenFeign的区别

8.2 使用步骤

接口＋注解：微服务调用接口+@FeignClient
新建order80

pom

  
  <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>cloud2020artifactId>
          <groupId>com.atguigu.springcloudgroupId>
          <version>1.0-SNAPSHOTversion>
      parent>
      <modelVersion>4.0.0modelVersion>

      <artifactId>cloud-consumer-feign-order80artifactId>
      <dependencies>

          <dependency>
              <groupId>org.springframework.cloudgroupId>
              <artifactId>spring-cloud-starter-openfeignartifactId>
          dependency>

          <dependency>
              <groupId>org.springframework.cloudgroupId>
              <artifactId>spring-cloud-starter-netflix-eureka-clientartifactId>
          dependency>

          <dependency>    
              <groupId>com.atguigu.springcloudgroupId>
              <artifactId>cloud-api-commonsartifactId>
              <version>${project.version}version>
          dependency>


          <dependency>
              <groupId>org.springframework.bootgroupId>
              <artifactId>spring-boot-starter-webartifactId>
          dependency>
          <dependency>
              <groupId>org.springframework.bootgroupId>
              <artifactId>spring-boot-starter-actuatorartifactId>
          dependency>
          <dependency>
              <groupId>org.springframework.bootgroupId>
              <artifactId>spring-boot-devtoolsartifactId>
              <scope>runtimescope>
              <optional>trueoptional>
          dependency>
          <dependency>
              <groupId>org.projectlombokgroupId>
              <artifactId>lombokartifactId>
              <optional>trueoptional>
          dependency>
          <dependency>
              <groupId>org.springframework.bootgroupId>
              <artifactId>spring-boot-starter-testartifactId>
              <scope>testscope>
          dependency>
      dependencies>

  project>

YML

  server:
    port: 80

  eureka:
    client:
      register-with-eureka: false
      service-url:
        defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/

主启动类

  package com.atguigu.springcloud;

  import org.springframework.boot.SpringApplication;
  import org.springframework.boot.autoconfigure.SpringBootApplication;
  import org.springframework.cloud.openfeign.EnableFeignClients;

  @SpringBootApplication
  @EnableFeignClients
  //@RibbonClient(name = "CLOUD-PAYMENT-SERVICE",configuration = MySelfRule.class)
  public class OrderFeignMain80 {
       
      public static void main(String[] args) {
       
          SpringApplication.run(OrderFeignMain80.class,args);
      }
  }

业务类

  package com.atguigu.springcloud.service;

  import com.atguigu.springcloud.entities.CommonResult;
  import com.atguigu.springcloud.entities.Payment;
  import org.springframework.cache.annotation.Cacheable;
  import org.springframework.cloud.openfeign.EnableFeignClients;
  import org.springframework.cloud.openfeign.FeignClient;
  import org.springframework.stereotype.Component;
  import org.springframework.web.bind.annotation.GetMapping;
  import org.springframework.web.bind.annotation.PathVariable;

  @Component
  @FeignClient(value = "CLOUD-PAYMENT-SERVICE")
  public interface PaymentFeignService {
       
      @GetMapping(value="/payment/get/{id}")
      public CommonResult<Payment> getPaymentById(@PathVariable("id") Long id);
  }

  package com.atguigu.springcloud.controller;

  import com.atguigu.springcloud.entities.CommonResult;
  import com.atguigu.springcloud.entities.Payment;
  import com.atguigu.springcloud.service.PaymentFeignService;
  import lombok.extern.slf4j.Slf4j;
  import org.springframework.web.bind.annotation.GetMapping;
  import org.springframework.web.bind.annotation.PathVariable;
  import org.springframework.web.bind.annotation.RestController;

  import javax.annotation.Resource;

  @RestController
  @Slf4j
  public class OrderFeignController {
       

      @Resource
      private PaymentFeignService paymentFeignService;

      @GetMapping(value="/consumer/payment/get/{id}")
      public CommonResult<Payment> getPaymentById(@PathVariable("id") Long id){
       
          return paymentFeignService.getPaymentById(id);
      }
  }

8.3 OpenFeign超时控制

超时设置，故意设置超时演示出错

8001写暂停程序

@GetMapping(value = "/payment/feign/timeout")
public String paymentFeignTimeout(){
         
    try {
         
        TimeUnit.SECONDS.sleep(3);
    } catch (InterruptedException e) {
         
        e.printStackTrace();
    }
    return serverPort;
}

80添加超时方法PaymentFeignService

@GetMapping(value = "/payment/feign/timeout")
public String paymentFeignTimeout();

80添加超时方法OrderFeignController

@GetMapping(value = "consumer/payment/feign/timeout")
public String paymentFeignTimeout(){
         
    //openfeign-ribbon 客户端消费者一般默认等待1s
    return paymentFeignService.paymentFeignTimeout();
}

测试

报错，时间超时！（OpenFeign默认只等待1s，等不到就报错）

开启OpenFeign客户端超时控制

  server:
    port: 80

  spring:
    application:
      name: cloud-order-service
  eureka:
    client:
      register-with-eureka: false
      fetchRegistry: true
      service-url:
        defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka

  #没置feign客户端超时时间(OpenFeign默认支持ribbon)
  ribbon:
    #指的是建立连接所用的时间，适用于网络状况正常的情况下,两端连接所用的时间
    ConnectTimeout: 5000
    #指的是逮立连接后从服务器渎取到可用资源所用的既间
    ReadTimeout: 5000

8.4 OpenFeign日志打印功能

Feign 提供了日志打印功能，我们可以通过配置来调整日志级别，从而了解Feign中Http请求的细节。说白了就是对Feign接口的调用情况进行监控和输出
日志级别：
- NONE：默认的，不显示任何日志;
- BASIC：仅记录请求方法、URL、响应状态码及执行时间;
- HEADERS：除了BASIC中定义的信息之外，还有请求和响应的头信息;
- FULL：除了HEADERS中定义的信息之外，还有请求和响应的正文及元数据。

配置日志bean

  package com.atguigu.springcloud.config;

  import feign.Logger;
  import org.springframework.context.annotation.Bean;
  import org.springframework.context.annotation.Configuration;



  @Configuration
  public class FeignConfig {
       
      @Bean
      Logger.Level feignLoggerLevel(){
       
          return Logger.Level.FULL;
      }
  }

YML文件中开启日志的Feign客户端

9. Hystrix

9.1 概述

Hystrix是一个用于处理分布式系统的延迟和容错的开源库，在分布式系统里，许多依赖不可避免的会调用失败，比如超时、异常等，Hystrix能够保证在一个依赖出问题的情况下，不会导致整体服务失败，避免级联故障，以提高分布式系统的弹性。
"断路器”本身是一种开关装置，当某个服务单元发生故障之后，通过断路器的故障监控（类似熔断保险丝)，向调用方返回一个符合预期的、可处理的备选响应（FallBack)，而不是长时间的等待或者抛出调用方无法处理的异常，这样就保证了服务调用方的线程不会被长时间、不必要地占用，从而避免了故障在分布式系统中的蔓延，乃至雪崩。

9.2 概念

服务降级：服务器忙，请稍后再试，不让客户端等待并且立刻返回一个友好提示，fallback
- 哪些情况会出现服务降级？
  - 程序运行异常
  - 超时
  - 服务熔断
  - 线程池/信号量打满
服务熔断：类比保险丝达到最大服务访问后，直接拒绝访问，拉闸限电，然后调用服务降级的方式并返回友好提示（保险丝）
服务限流：秒杀高并发等操作，严禁一窝蜂地拥挤，大家排队，一秒钟N个，有序进行

9.3 支付微服务搭建

构建：

7001改pom，守望自己
新建熔断的8001

POM


<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>cloud2020artifactId>
        <groupId>com.atguigu.springcloudgroupId>
        <version>1.0-SNAPSHOTversion>
    parent>
    <modelVersion>4.0.0modelVersion>

    <artifactId>cloud-provider-hystrix-payment8001artifactId>
    <dependencies>

        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-netflix-hystrixartifactId>
        dependency>


        
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-netflix-eureka-clientartifactId>
        dependency>


        <dependency>    
            <groupId>com.atguigu.springcloudgroupId>
            <artifactId>cloud-api-commonsartifactId>
            <version>${project.version}version>
        dependency>

        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-actuatorartifactId>
        dependency>
        <dependency>
            <groupId>org.mybatis.spring.bootgroupId>
            <artifactId>mybatis-spring-boot-starterartifactId>
        dependency>
        <dependency>
            <groupId>com.alibabagroupId>
            <artifactId>druid-spring-boot-starterartifactId>
            <version>1.1.10version>
        dependency>
        
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-jdbcartifactId>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-devtoolsartifactId>
            <scope>runtimescope>
            <optional>trueoptional>
        dependency>
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
            <optional>trueoptional>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <scope>testscope>
        dependency>




    dependencies>

project>

YML

server:
  port: 8001
spring:
  application:
    name: cloud-provider-hystrix-payment
eureka:
  client:
    register-with-eureka: true
    fetch-registry: true
    service-url:
      #defaultZone: http://eureka7001.com:7001/eureka, http:/ /eureka7002.com:7002/eureka
      defaultzone:http://eureka7001.com:7001/eureka

主启动

业务类

package com.atguigu.springcloud.controller;

import com.atguigu.springcloud.service.PaymentService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

@RestController
@Slf4j
public class PaymentController {
         
    @Resource
    private PaymentService paymentService;

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

    @GetMapping("/payment/hystrix/ok/{id}")
    public String paymentInfo_OK(@PathVariable("id") Integer id){
         
        String result = paymentService.paymentInfo_OK(id);
        log.info("*********result"+result);
        return result;
    }

    @GetMapping("/payment/hystrix/timeout/{id}")
    public String paymentInfo_TIMEOUT(@PathVariable("id") Integer id){
         
        String result = paymentService.paymentInfo_TIMEOUT(id);
        log.info("*********result"+result);
        return result;
    }
}

package com.atguigu.springcloud.service;

import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;

@Service
public class PaymentService {
         
    public String paymentInfo_OK(Integer id){
         
        return "线程池："+Thread.currentThread().getName()+" paymentInfo_OK,id："+id+"\t"+"哈哈";
    }

    public String paymentInfo_TIMEOUT(Integer id){
         
        int timeNumber=3;
        try {
         
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
         
            e.printStackTrace();
        }
        return "线程池："+Thread.currentThread().getName()+" paymentInfo_TIMEOUT,id："+id+"\t"+"哈哈"+"耗时s"+timeNumber;
    }
}

9.4 高并发测试后卡顿

Jmeter压测测试：20000个并发访问paymentInfo_timeout
- 结果：两个都在转圈圈，被卡死
- 原因：Tomcat的默认工作线程数被打满了，没有多余的线程来分解压力和处理
- 结论：自测都很慢，如果消费者也来访问，只能干等，最终80不满意，8001直接被拖死

9.5 订单微服务调用支付服务

新建

POM

  
  <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>cloud2020artifactId>
          <groupId>com.atguigu.springcloudgroupId>
          <version>1.0-SNAPSHOTversion>
      parent>
      <modelVersion>4.0.0modelVersion>

      <artifactId>cloud-consumer-hystrix-order80artifactId>

      <dependencies>
          <dependency>
              <groupId>org.springframework.cloudgroupId>
              <artifactId>spring-cloud-starter-netflix-eureka-clientartifactId>
          dependency>

          <dependency>
              <groupId>org.springframework.cloudgroupId>
              <artifactId>spring-cloud-starter-openfeignartifactId>
          dependency>

          <dependency>
              <groupId>org.springframework.cloudgroupId>
              <artifactId>spring-cloud-netflix-hystrixartifactId>
          dependency>




          <dependency>    
              <groupId>com.atguigu.springcloudgroupId>
              <artifactId>cloud-api-commonsartifactId>
              <version>${project.version}version>
          dependency>


          <dependency>
              <groupId>org.springframework.bootgroupId>
              <artifactId>spring-boot-starter-webartifactId>
          dependency>
          <dependency>
              <groupId>org.springframework.bootgroupId>
              <artifactId>spring-boot-starter-actuatorartifactId>
          dependency>
          <dependency>
              <groupId>org.springframework.bootgroupId>
              <artifactId>spring-boot-devtoolsartifactId>
              <scope>runtimescope>
              <optional>trueoptional>
          dependency>
          <dependency>
              <groupId>org.projectlombokgroupId>
              <artifactId>lombokartifactId>
              <optional>trueoptional>
          dependency>
          <dependency>
              <groupId>org.springframework.bootgroupId>
              <artifactId>spring-boot-starter-testartifactId>
              <scope>testscope>
          dependency>
          <dependency>
              <groupId>org.springframework.cloudgroupId>
              <artifactId>spring-cloud-netflix-eureka-clientartifactId>
          dependency>
      dependencies>


  project>

YML
主启动

业务类

  package com.atguigu.springcloud.service;

  import org.springframework.cloud.openfeign.FeignClient;
  import org.springframework.stereotype.Component;
  import org.springframework.stereotype.Service;
  import org.springframework.web.bind.annotation.GetMapping;
  import org.springframework.web.bind.annotation.PathVariable;

  @Component
  @FeignClient(value = "CLOUD-PROVIDER-HYSTRIX-PAYMENT")
  public interface PaymentHystrixService {
       
      @GetMapping("/payment/hystrix/ok/{id}")
      public String paymentInfo_OK(@PathVariable("id") Integer id);

      @GetMapping("/payment/hystrix/timeout/{id}")
      public String paymentInfo_TIMEOUT(@PathVariable("id") Integer id);

  }

  package com.atguigu.springcloud.controller;

  import com.atguigu.springcloud.service.PaymentHystrixService;
  import lombok.extern.slf4j.Slf4j;
  import org.springframework.web.bind.annotation.GetMapping;
  import org.springframework.web.bind.annotation.PathVariable;
  import org.springframework.web.bind.annotation.RestController;

  import javax.annotation.Resource;

  @RestController
  @Slf4j
  public class OrderHystrixController {
       
      @Resource
      private PaymentHystrixService paymentHystrixService;

      @GetMapping("/consumer/payment/hystrix/ok/{id}")
      public String paymentInfo_OK(@PathVariable("id") Integer id){
       
          String result=paymentHystrixService.paymentInfo_OK(id);
          return result;
      }

      @GetMapping("/consumer/payment/hystrix/timeout/{id}")
      public String paymentInfo_TIMEOUT(@PathVariable("id") Integer id){
       
          String result=paymentHystrixService.paymentInfo_TIMEOUT(id);
          return result;
      }
  }

测试
- 高并发情况下特别慢，有时候甚至会白页
原因：
- 8001同一层次的其他接口服务被困死了，因为tomcat线程池里面的工作线程已经被抢占完了
- 80此时调用8001，客户端访问缓慢，转圈圈

9.6 降级容错的维度要求

超时导致服务器变慢（转圈）
出错（宕机或程序运行出错）
解决
- 8001超时了，80不能一直卡死等待，必须有服务降级
- 对方8001宕机了，80不能一直卡死等待，必须有服务降级
- 对方8001可以，80自己出故障或者自我要求（比方自己的等待时间小于服务提供者），自己处理降级

9.7 服务降级支付侧

降级配置：@HystrixCommand
8001自身找问题
- 设置自身调用超时时间的峰值，峰值内可以正常运行
- 超过需要有兜底方法处理，作服务降级fallback

8001fallback

业务类启用：@HystrixCommand

package com.atguigu.springcloud.service;

import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixProperty;
import com.netflix.ribbon.proxy.annotation.Hystrix;
import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;

@Service
public class PaymentService {
         
    public String paymentInfo_OK(Integer id){
         
        return "线程池："+Thread.currentThread().getName()+" paymentInfo_OK,id："+id+"\t"+"哈哈";
    }


    @HystrixCommand(fallbackMethod = "paymentInfo_TIMEOUTHandler",commandProperties = {
         
            @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds",value = "3000")
    })
    public String paymentInfo_TIMEOUT(Integer id){
         
        int timeNumber=5;
        try {
         
            TimeUnit.SECONDS.sleep(timeNumber);
        } catch (InterruptedException e) {
         
            e.printStackTrace();
        }
        return "线程池："+Thread.currentThread().getName()+" paymentInfo_TIMEOUT,id："+id+"\t"+"哈哈"+"耗时s"+timeNumber;
    }

    public String paymentInfo_TIMEOUTHandler(Integer id){
         
        return "线程池："+Thread.currentThread().getName()+" paymentInfo_TIMEOUTHandler,id："+id+"\t"+"o(╥﹏╥)o";

    }
}

主启动类激活：@EnableCircuitBreaker

9.8 服务降级订单侧

热部署对注解里面的属性修改不太敏感，建议重启
YML
主启动：EnableHystrix

业务类

  package com.atguigu.springcloud.controller;

  import com.atguigu.springcloud.service.PaymentHystrixService;
  import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
  import com.netflix.hystrix.contrib.javanica.annotation.HystrixProperty;
  import lombok.extern.slf4j.Slf4j;
  import org.springframework.web.bind.annotation.GetMapping;
  import org.springframework.web.bind.annotation.PathVariable;
  import org.springframework.web.bind.annotation.RestController;

  import javax.annotation.Resource;
  import java.util.concurrent.TimeUnit;

  @RestController
  @Slf4j
  public class OrderHystrixController {
       
      @Resource
      private PaymentHystrixService paymentHystrixService;

      @GetMapping("/consumer/payment/hystrix/ok/{id}")
      public String paymentInfo_OK(@PathVariable("id") Integer id){
       
          String result=paymentHystrixService.paymentInfo_OK(id);
          return result;
      }

      @GetMapping("/consumer/payment/hystrix/timeout/{id}")
      @HystrixCommand(fallbackMethod = "paymentInfo_TIMEOUTHandler",commandProperties = {
       
              @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds",value = "1500 ")
      })
      public String paymentInfo_TIMEOUT(Integer id){
       
          String result = paymentHystrixService.paymentInfo_TIMEOUT(id);
          return result;
      }

      public String paymentInfo_TIMEOUTHandler(Integer id){
       
          return "我是消费者80，支付系统8001繁忙，请稍后再试！o(╥﹏╥)o";

      }
  }

9.9 全局服务降级DefaultProperties

问题：

每个业务方法对饮一个兜底的方法，代码膨胀
统一和自定义分开

解决：

代码膨胀：@DefaultProperties（defaultFallback=" "）

设定全局降级

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KSqAJLiN-1619837391804)(E:\学习笔记\图片\image-20201027162534179.png)]$

兜底方法

//全局fallback
public String payment_Globel_FallbackMethod(){
         
    return "Global全局处理信息，请稍后再试o(╥﹏╥)o";
}

使用兜底方法

9.10 统配服务降级FeignFallback

修改order80

新建一个类，实现Service接口

  package com.atguigu.springcloud.service;

  public class PaymentFallbackService implements PaymentHystrixService{
       
      @Override
      public String paymentInfo_OK(Integer id) {
       
          return "-----PaymentFallbackService fall back o(╥﹏╥)o";
      }

      @Override
      public String paymentInfo_TIMEOUT(Integer id) {
       
          return "------PaymentFallbackService fall back o(╥﹏╥)o";
      }
  }

Sercice接口

  package com.atguigu.springcloud.service;


  import org.springframework.cloud.openfeign.FeignClient;
  import org.springframework.stereotype.Component;
  import org.springframework.stereotype.Service;
  import org.springframework.web.bind.annotation.GetMapping;
  import org.springframework.web.bind.annotation.PathVariable;

  @Component
  @FeignClient(value = "CLOUD-PROVIDER-HYSTRIX-PAYMENT",fallback = PaymentFallbackService.class)
  public interface PaymentHystrixService {
       
      @GetMapping("/payment/hystrix/ok/{id}")
      public String paymentInfo_OK(@PathVariable("id") Integer id);

      @GetMapping("/payment/hystrix/timeout/{id}")
      public String paymentInfo_TIMEOUT(@PathVariable("id") Integer id);
  }

9.11 服务熔断

熔断机制是应对雪崩效应的一种微服务链路保护机制。当扇出链路的某个微服务出错不可用或者响应时间太长时，会进行服务的降级，进而熔断该节点微服务的调用，快速返回错误的响应信息。
当检测到该节点微服务调用响应正常后，恢复调用链路。
在Spring Cloud框架里，熔断机制通过Hystrix实现。Hystrix会监控微服务间调用的状况

当失败的调用到一定阈值，缺省是5秒内20次调用失败，就会启动熔断机制。熔断机制的注解是@HystrixCommand。

9.12 服务熔断案例

修改8001

PaymentService

  package com.atguigu.springcloud.service;

  import cn.hutool.core.util.IdUtil;
  import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
  import com.netflix.hystrix.contrib.javanica.annotation.HystrixProperty;
  import com.netflix.ribbon.proxy.annotation.Hystrix;
  import org.springframework.stereotype.Service;
  import org.springframework.web.bind.annotation.PathVariable;

  import java.util.concurrent.TimeUnit;

  @Service
  public class PaymentService {
       
      public String paymentInfo_OK(Integer id){
       
          return "线程池："+Thread.currentThread().getName()+" paymentInfo_OK,id："+id+"\t"+"哈哈";
      }


      @HystrixCommand(fallbackMethod = "paymentInfo_TIMEOUTHandler",commandProperties = {
       
              @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds",value = "5000")
      })
      public String paymentInfo_TIMEOUT(Integer id){
       
          int timeNumber=3;
          try {
       
              TimeUnit.SECONDS.sleep(timeNumber);
          } catch (InterruptedException e) {
       
              e.printStackTrace();
          }
          return "线程池："+Thread.currentThread().getName()+" paymentInfo_TIMEOUT,id："+id+"\t"+"哈哈"+"耗时s"+timeNumber;
      }

      public String paymentInfo_TIMEOUTHandler(Integer id){
       
          return "线程池："+Thread.currentThread().getName()+" 8001系统忙，请稍后再试！id："+id+"\t"+"o(╥﹏╥)o";

      }

      //服务熔断

      @HystrixCommand(fallbackMethod= "paymentcircuitBreaker_fallback" ,commandProperties = {
       
              @HystrixProperty(name = "circuitBreaker.enabled",value = "true"),  //是否开启断路器
              @HystrixProperty(name = "circuitBreaker.requestVolumeThreshold",value = "10"),  //请求次数
              @HystrixProperty(name = "circuitBreaker.sleepWindowInMilliseconds",value = "10000"),  //时间窗口期
              @HystrixProperty(name = "circuitBreaker.errorThresholdPercentage",value = "60"), //失败率达到多少后跳闸
      })
      public String paymentCircuitBreaker(@PathVariable("id")Integer id){
       
            if(id < 0)
              {
       
                  throw new RuntimeException("******id 不能负数");
              }
              String serialNumber = IdUtil.simpleUUID();
              return Thread.currentThread() .getName()+"\t"+"调用成功，流水号:" +serialNumber;
      }
      public String paymentCircuitBreaker_fallback(@PathVariable("id") Integer id){
       
          return "id不能负数，请稍后再试，/(ToT)/~~id: " +id;
      }
  }

PaymentController

  package com.atguigu.springcloud.controller;

  import com.atguigu.springcloud.service.PaymentService;
  import lombok.extern.slf4j.Slf4j;
  import org.springframework.beans.factory.annotation.Value;
  import org.springframework.web.bind.annotation.GetMapping;
  import org.springframework.web.bind.annotation.PathVariable;
  import org.springframework.web.bind.annotation.RestController;

  import javax.annotation.Resource;
  @RestController
  @Slf4j
  public class PaymentController {
       
      @Resource
      private PaymentService paymentService;

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

      @GetMapping("/payment/hystrix/ok/{id}")
      public String paymentInfo_OK(@PathVariable("id") Integer id){
       
          String result = paymentService.paymentInfo_OK(id);
          log.info("*********result"+result);
          return result;
      }

      @GetMapping("/payment/hystrix/timeout/{id}")
      public String paymentInfo_TIMEOUT(@PathVariable("id") Integer id){
       
          String result = paymentService.paymentInfo_TIMEOUT(id);
          log.info("*********result"+result);
          return result;
      }

      //服务熔断
      @GetMapping("/payment/circuit/{id}")
      public String paymentCoircuitBreaker(@PathVariable("id") Integer id){
       
          String  result = paymentService.paymentCircuitBreaker(id);
          log.info("************result："+result);
          return result;
      }
  }

测试

9.13 总结

熔断类型：

打开：请求不再进行调用当前服务，内部设置时钟一般为MTTR(平均故障处理时间)，当打开时长达到所设时钟则进入半熔断状态
关闭：熔断关闭不会对服务进行熔断
半开：部分请求根据规则调用当前服务，如果请求成功且符合规则则认为当前服务恢复正常，关闭熔断

断路器开启或者关闭的条件：

断路器打开之后：

9.14 Hystrix工作流程

9.15 Dashboard搭建

9.15.1 概述

除了隔离依赖服务的调用以外，Hystrixi还提供了准实时的调用监控（Hystrix Dashboard)，Hystrix会持续地记录所有通过Hystrix发起的请求的执行信息，并以统计报表和图形的形式展示给用户，包括每秒执行多少请求多少成功，多少失败等。Netflix通过hystrix-metrics-event-stream项目实现了对以上指标的监控。Spring Cloud也提供了Hystrix Dashboard的整合，对监控内容转化成可视化界面。

9.15.2 仪表盘9001

新建cloud-consumer-hystrix-dashboard9001

POM

  
  <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>cloud2020artifactId>
          <groupId>com.atguigu.springcloudgroupId>
          <version>1.0-SNAPSHOTversion>
      parent>
      <modelVersion>4.0.0modelVersion>

      <artifactId>cloud-consumer-hystrix-dashboard9001artifactId>

      <dependencies>
          <dependency>
              <groupId>org.springframework.cloudgroupId>
              <artifactId>spring-cloud-starter-netflix-hystrix-dashboardartifactId>
          dependency>
          <dependency>
              <groupId>org.springframework.bootgroupId>
              <artifactId>spring-boot-starter-actuatorartifactId>
          dependency>
          <dependency>
              <groupId>org.springframework.bootgroupId>
              <artifactId>spring-boot-devtoolsartifactId>
              <scope>runtimescope>
              <optional>trueoptional>
          dependency>
          <dependency>
              <groupId>org.projectlombokgroupId>
              <artifactId>lombokartifactId>
              <optional>trueoptional>
          dependency>
          <dependency>
              <groupId>org.springframework.bootgroupId>
              <artifactId>spring-boot-starter-testartifactId>
              <scope>testscope>
          dependency>
      dependencies>


  project>

YML
```
server:  port: 9001
```

新注解@EnableHystrixDashboard

  package com.atguigu.springcloud;

  import org.springframework.boot.SpringApplication;
  import org.springframework.boot.autoconfigure.SpringBootApplication;
  import org.springframework.cloud.netflix.hystrix.dashboard.EnableHystrixDashboard;

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

所有Provider微服务提供类（8001,8002,8003）都需要监控依赖配置

  <dependency>
      <groupId>org.springframework.bootgroupId>
      <artifactId>spring-boot-starter-actuatorartifactId>
  dependency>

启动9001

访问 http://localhost:9001/hystrix

9.15.3 监控实战

修改8001

新版本Hystrix需要在主启动类MainAppHystrix8001中指定监控路径

/**
 *此敲置是为了服务监控面配置，与服务容错本身无关，springcLoud升级后的坑
 *ServletRegistrationBean因为springboot的默认路径不是"/hystrix.stream",
 *只要在自己的项目里配置上下面的servlet就可以了
*/
    @Bean
    public ServletRegistrationBean getServlet(){
         
        HystrixMetricsStreamServlet streamServlet = new HystrixMetricsStreamServlet();
        ServletRegistrationBean registrationBean = new ServletRegistrationBean(streamServlet);
        registrationBean.setLoadOnStartup(1);
        registrationBean.addUrlMappings("/hystrix.stream");
        registrationBean.setName("HystrixMetricsStreamServlet");
        return registrationBean;
    }

测试：启动一个Eurake或者3个集群
观察监控窗口：
- 9001监控8001：填写监控地址：http://localhost:8001/hystrix.stream
- 测试地址：
  - http://localhost:8001/payment/circuit/31
  - http://localhost:8001/payment/circuit/-31
  - 上述测试通过 ok
  - 先访问正确地址，再访问错误地址，再正确地址，会发现断路器都是慢慢放开的
- 如何看图？
  - 七色
  - 一圈
    
    $[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5CQIjtaa-1619837391809)(E:\学习笔记\图片\image-20201104163338229.png)]$
    
    $[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9XkDk8gb-1619837391810)(E:\学习笔记\图片\image-20201104163328904.png)]$
  - 一线：用来记录2分钟内流量的相对变化，可以通过它来观察到流量的上升和下降趋势。
  - 整个图说明
  - 整个图说明

10. GateWay网关

10.1 概述

Cloud全家桶中有个很重要的组件就是网关，在1.x版本中都是采用的Zuul网关，但在2.x版本中，zuul的升级就一直跳票，SpringCloud最后自己研发了一个网关替代了Zuul------------SpringCloud GateWay
gateWay是原zuul1.x版本的替换，是在Spring生态系统之上构建的API网关服务，基于Spring5，Spirng Boot2和Project Reactor等技术
GateWay旨在提供一种简单而有效的方式来对API进行路由，以及提供一些强大的过滤器功能，例如：熔断、限流、重试等
SpringCloud GateWay使用的Webflux中的reactor-netty响应式编程组件，底层使用了Netty通讯框架

10.2 非阻塞异步模式

Spring Cloud Gateway具有如下特性:
- 基于Spring Framework 5,Project Reactor和Spring Boot 2.0进行构建；
- 动态路由:能够匹配任何请求属性；
- 可以对路由指定Predicate(断言）和Filter(过滤器)；
- 集成Hystrix的断路器功能；
- 集成Spring Cloud服务发现功能；
- 易于编写的 Predicate(断言）和Filter(过滤器）;
- 请求限流功能；
- 支持路径重写。
SpringCloud GateWay和Zuul的区别
- Zuul1.x基于Servlet2.5 IO模型使用阻塞架构
- SpringCloud GateWay使用非阻塞API
WebFlux是什么？
- 区别于SpringMVC，不需要依赖Servlet API，它是完全异步非阻塞的，并且基于Reactor来实现响应式流规范。

10.3 GateWay工作流程

路由（Route）：构建网关的基本模块，由id，目标URI，一系列的断言和过滤器组成，如果断言为true，则匹配该断言。
断言（Predicate）：参考的是Java8的java.util.function.Predicate，开发人员可以匹配HTTP请求中的所有内容（例如请求头或请求参数），如果请求与断言相匹配则进行路由
过滤（Filter）：指的是Spring框架中GateWayFilter的实现，使用过滤器，可以在请求被路由前或者之后对请求进行修改

总结：路由转发+执行过滤器链

10.4 GateWay9527搭建

新建Module

POM

  
  <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>cloud2020artifactId>
          <groupId>com.atguigu.springcloudgroupId>
          <version>1.0-SNAPSHOTversion>
      parent>
      <modelVersion>4.0.0modelVersion>

      <artifactId>cloud-gateway-gateway9527artifactId>

      <dependencies>
          <dependency>
              <groupId>org.springframework.cloudgroupId>
              <artifactId>spring-cloud-starter-gatewayartifactId>
          dependency>

          <dependency>
              <groupId>org.springframework.cloudgroupId>
              <artifactId>spring-cloud-starter-netflix-eureka-clientartifactId>
          dependency>


          <dependency>    
              <groupId>com.atguigu.springcloudgroupId>
              <artifactId>cloud-api-commonsartifactId>
              <version>${project.version}version>
          dependency>

          <dependency>
              <groupId>org.springframework.bootgroupId>
              <artifactId>spring-boot-devtoolsartifactId>
              <scope>runtimescope>
              <optional>trueoptional>
          dependency>
          <dependency>
              <groupId>org.projectlombokgroupId>
              <artifactId>lombokartifactId>
              <optional>trueoptional>
          dependency>
          <dependency>
              <groupId>org.springframework.bootgroupId>
              <artifactId>spring-boot-starter-testartifactId>
              <scope>testscope>
          dependency>
      dependencies>


  project>

YML
业务类

主启动类

  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 GateWayMain9527 {
       
      public static void main(String[] args) {
       
          SpringApplication.run(GateWayMain9527.class,args);
      }
  }

9527网关做路由映射

YML新增网关配置

  server:
    port: 9527

  spring:
    application:
      name: cloud-gateway
    cloud:
      gateway:
        routes:
          - id: payment_routh
            uri:  http://localhost:8081
            predicates:
              - Path=/payment/get/**

          - id: payment_routh2
            uri:  http://localhost:8001
            predicates:
              - Path=/payment/lb/**

  eureka:
    instance:
      hostname: cloud-gateway-service
    client: #服务提供者provider注册进eureka服务列表内
      service-url:
        register-with-eureka: true
        fetch-registry: true
        defaultZone:  http://eureka7001.com:7001/eureka

测试
YML配置说明

10.5 配置路由的两种方式

上述的yaml配置

代码中注入RouteLocator的Bean：在9527新建config文件夹配置类！

 @Configuration
 public class GateWayConfig {
       
     @Bean
     public RouteLocator customRouterLocator(RouteLocatorBuilder routeLocatorBuilder){
       
         RouteLocatorBuilder.Builder routes = routeLocatorBuilder.routes();
         routes.route("path_route_atguigu",
                 r->r.path("/guonei")
                         .uri("http://news.baidu.com/guonei")).build();

         return routes.build();
     }
 }

效果：

10.6 动态路由

默认情况下Gateway会根据注册中心注册的服务划表，以注册中心上微服务名为路径创建动态路由进行转发，从而实现动态路由的功能

YML：

 server:
   port: 9527

 spring:
   application:
     name: cloud-gateway
   cloud:
     gateway:
       discovery:
         locator:
           enabled: true         #开启从注册中心动态创建路由的功能，利用微服务名进行路由
       routes:
         - id: payment_routh     #路由的ID，没有固定规则但要求唯一，建议配合服务名
           uri:  lb://cloud-payment-service     #匹配后提供服务的路由地址
           predicates:
             - Path=/payment/get/**    #断言，路径相匹配的进行路由


         - id: payment_routh2      #路由的ID，没有固定规则但要求唯一，建议配合服务名
           uri:  lb://cloud-payment-service     #匹配后提供服务的路由地址
           predicates:
             - Path=/payment/lb/**     #创言，路径相匹配的进行路由


 eureka:
   instance:
     hostname: cloud-gateway-service
   client: #服务提供者provider注册进eureka服务列表内
     service-url:
       register-with-eureka: true
       fetch-registry: true
       defaultZone:  http://eureka7001.com:7001/eureka

10.7 常用的predicate

After Route Predicate：

 public class Test {
       
     public static void main(String[] args) {
       
         ZonedDateTime zbj = ZonedDateTime.now();
         System.out.println(zbj);
     }
 }

Before Route Predicate、Between Route Predicate与上面类似
Cookie Route Predicate：
Header Route Predicate

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Q9eS4g72-1619837391813)(E:\学习笔记\图片\image-20210419172521954.png)]$
Host Route Predicate：

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-y1icktN2-1619837391814)(E:\学习笔记\图片\image-20210419172638825.png)]$
Method Route Predicate：
Path Route Predicate：

就是 -Path
Query Route Predicate：

总结

说白了，Predicate就是为了实现一组匹配规则，让请求过来找到对应的Route进行处理。

10.8 Filter

介绍

路由器指的是Spring框架中GatewayFilter的实例，使用过滤器，可以在请求被路由前或者之后对请求进行修改。
路由过滤器可用于修改进入的HTTP请求和返回的HTTP响应，路由过滤器只能指定路由进行使用。
Spring Cloud Gateway内置了多种路由过滤器，他们都由GatewayFilter的工厂类来产生
生命周期：pre、post
种类：GatewayFilter、GlobalFilter

自定义过滤器：实现两个接口，GlobalFilter、Ordered

能干嘛？全局日志记录，统一网关鉴权

 @Component
 @Slf4j
 public class MyLogGateWayFilter  implements GlobalFilter, Ordered
 {
       
     @Override
     public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
       
         log.info("*******************************come in MyLogGateWayFilter:   "+new Date());
         String uname = exchange.getRequest().getQueryParams().getFirst("uname");
         if(uname == null){
       
             log.info("**************用户名为null，非法用户，┭┮﹏┭┮");
             exchange.getResponse().setStatusCode(HttpStatus.NOT_ACCEPTABLE);
             return exchange.getResponse().setComplete();
         }
         return chain.filter(exchange);
     }

     @Override
     public int getOrder() {
       
         return 0;
     }
 }

11. Config配置中心

11.1 分布式配置中心介绍

微服务意味着要将单体应用中的业务拆分成一个个子服务，每个服务的粒度相对较小，因此系统中会出现大量的服务。由于每个服务都需要必要的配置信息才能运行，所以一套集中式的、动态的配置管理设施是必不可少的。

介绍

SpringCloud Config为微服务架构中的微服务提供集中化的外部配置支持，配置服务器为各个不同微服务应用的所有环境提供了一个中心化的外部配置。
SpringCloud Config分为服务端和客户端两部分。
服务端也称为分布式配置中心，它是一个独立的微服务应用，用来连接配置服务器并为客户端提供获取配置信息，加密/解密信息等访问接口。

客户端则是通过指定的配置中心来管理应用资源，以及与业务相关的配置内容，并在启动的时候从配置中心获取和加载配置信息配置服务器默认采用git来存储配置信息，这样就有助于对环境配置进行版本管理，并且可以通过git客户端工具来方便的管理和访问配置内容

11.2 配置总控中心搭建

POM

 
 <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>cloud2020artifactId>
         <groupId>com.atguigu.springcloudgroupId>
         <version>1.0-SNAPSHOTversion>
     parent>
     <modelVersion>4.0.0modelVersion>

     <artifactId>cloud-config-center-3344artifactId>
     <dependencies>
         <dependency>
             <groupId>org.springframework.cloudgroupId>
             <artifactId>spring-cloud-config-serverartifactId>
         dependency>
         
         <dependency>
             <groupId>org.springframework.cloudgroupId>
             <artifactId>spring-cloud-starter-netflix-eureka-serverartifactId>
         dependency>
         
         <dependency>
             <groupId>org.springframework.bootgroupId>
             <artifactId>spring-boot-starter-webartifactId>
         dependency>
         <dependency>
             <groupId>org.springframework.bootgroupId>
             <artifactId>spring-boot-starter-actuatorartifactId>
         dependency>

         <dependency>
             <groupId>org.springframework.bootgroupId>
             <artifactId>spring-boot-devtoolsartifactId>
             <scope>runtimescope>
             <optional>trueoptional>
         dependency>
         <dependency>
             <groupId>org.projectlombokgroupId>
             <artifactId>lombokartifactId>
         dependency>
         <dependency>
             <groupId>org.springframework.bootgroupId>
             <artifactId>spring-boot-starter-testartifactId>
             <scope>testscope>
         dependency>
         <dependency>
             <groupId>junitgroupId>
             <artifactId>junitartifactId>
         dependency>

     dependencies>


 project>

YML

 server:
   port: 3344

 spring:
   application:
     name: cloud-config-center #注册进Eureka服务器的微服务名
   cloud:
     config:
       server:
         git:
           uri: https://github.com/lyyrhf/springcloud-config.git #GitHub上面的git仓库名字
           ##非#搜索目录
           search-paths:
             - springcloud-config
           username: [email protected]
           password: ran88518
           skip-ssl-validation: true
       ####读取分支
       label: main

 #服务注册至eureka地址
 eureka:
   client:
     service-url:
       defaultZone: http://localhost:7001/eureka

主启动类

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

windows下修改hosts文件，增加映射
```
127.0.0.1	config-3344.com
```
测试通过Config微服务是否可以从GitHub上获取配置内容：启动3344，http://config-3344.com:3344/main/config-dev.yml

配置读取规则

/{label}/{application}-fprofile}.yml
/{application}-{profile}.yml
/{application}/{profile}[/{label}]

配置细节

label：分支名
name：服务名
profile：环境（dev/test/prod）

11.3 客户端配置与测试

新建cloud-config-client-3355
POM

bootstrap.yml：applicaiton .yml是用户级的资源配置项，bootstrap.yml是系统级的，优先级更加高

 server:
   port: 3355
 spring:
   application:
     name: config-client
   cloud:
     #Config客户端配置
     config:
       label: main     #分支名称
       name: config  #配置文件名称
       profile: dev   #读取后缎名称
       uri: http://localhost:3344    #配置中心地址k
       #上述3个综合:master分支上config-dev.yml的配置文件被读取http://config-3344.com:3344/moster/config-dev.yml
 #服务注册到eureka地址
 eureka:
   client:
     service-url:
       defau1tZone: http://localhost:7001/eureka

修改config-dev.yml配置并且提交到github，比如加个变量age或者版本号version

主启动类

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

业务类

 @RestController
 public class ConfigClientController {
       
     @Value("${config.info}")
     private String configInfo;

     @GetMapping("/configInfo")
     public String getConfigInfo(){
       
         return configInfo;
     }
 }

测试：7001，3344，3355，然后访问http://localhost:3355/configInfo

问题：分布式的动态刷新问题

11.4 动态刷新手动版

修改3355模块：

POM引入actuator监控

 <dependency>
     <groupId>org.springframework.bootgroupId>
     <artifactId>spring-boot-starter-actuatorartifactId>
 dependency>

修改yml，暴露监控端口

 #暴露监控端口
 management:
   endpoints:
     web:
       exposure:
         include: "*"

@RefreshScope业务类Controller修改

 @RestController
 @RefreshScope
 public class ConfigClientController {
       
     @Value("${config.info}")
     private String configInfo;

     @GetMapping("/configInfo")
     public String getConfigInfo(){
       
         return configInfo;
     }
 }

此时修改github由2->1，发现没生效啊！
需要运维人员发个post请求刷新3355：curl -X POST “http://localhost:3355/actuator/refresh”

新的问题：多个微服务客户端，能否广播，一次通知，处处生效，大范围自动刷新？

12. bus消息总线

12.1 概述

Bus只支持两种消息代理，RabbitMQ和Kafka
可以实现配置的自动刷新
Spring Cloud Bus能管理和传播分布式系统间的消息，就像一个分布式执行器，可用于广播状态更改、事件推送等，也可以当作微服务间的通信通道。

12.2 环境配置

安装erlang：http://erlang.org/download/otp_win64_21.3.exe
rabbitmq：https://dl.bintray.com/rabbitmq/all/rabbitmq-server/3.7.14/rabbitmq-server-3.7.14.exe
进入rabbitmq安装的sbin目录下，命令行输入：.\rabbitmq-plugins enable rabbitmq_management
开始目录启动rabbit.start，测试是否成功：http://localhost:15672，成功进入，登录账号密码均是guest

12.3 动态刷新全局广播

环境搭建

再制作一个3366：POM、YML、Controller差不多

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

     @Value("${config.info}")
     private String configInfo;

     @GetMapping("/configInfo")
     public String getConfigInfo(){
       
         return "serverPort: "+serverPort+"\t\n\n configInfo: "+configInfo;
     }
 }

设计思想：
- 利用消息总线触发一个客户端/bus/refresh，而刷新所有客户端的配置
- 利用消息总线触发一个服务端ConfigServer的/bus/refresh端点，而刷新所有客户端的配置
- 图二的架构显然更加适合，图—不适合的原因如下：
  
  $[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-69vSQx9x-1619837391817)(E:\学习笔记\图片\image-20210421153536027.png)]$

实现

给cloud-config-center-3344配置中心服务端添加消息总线支持：

POM：

   
   <dependency>
       <groupId>org.springframework.cloudgroupId>
       <artifactId>spring-cloud-starter-bus-amqpartifactId>
   dependency>

YML：

   #rabbitmq相关配置
   rabbitmq:
     host: localhost
     port: 5672
     username:guest
     password:guest

   #rabbitmq相关配置，暴露bus刷新配置的端扣
   management:
     endpoints:    #暴露bus刷新配置的端扣
       web:
         exposure:
           include: 'bus-refresh'

给cloud-config-client-3355客户端添加消息总线支持：

POM

   
   <dependency>
       <groupId>org.springframework.cloudgroupId>
       <artifactId>spring-cloud-starter-bus-amqpartifactId>
   dependency>

YML

 #rabbitmq相关配置
 rabbitmq:
   host: localhost
   port: 5672
   username: guest
   password: guest

给cloud-config-client-3366客户端添加消息总线支持：跟上面3355一样
测试：
- 修改github版本号，发送POST请求，一次发送，处处生效！

12.4 动态刷新定点通知

只通知3355，不通知3366：

公式: http://localhost:配置中心的端口号/actuator/bus-refresh/{destination}

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ac844H32-1619837391818)(E:\学习笔记\图片\image-20210421162442393.png)]$

13. Stream消息驱动

介绍

官方定义Spring Cloud Stream是一个构建消息驱动微服务的框架。
它可以屏蔽底层消息中间件的差异,降低切换成本，统一消息的编程模型。

设计思想

它为什么可以统一底层差异？

通过定义绑定器Binder作为中间层，实现应用程序和消息中间件细节上的解耦隔离
Binder：
- INPUT：对应消费者
- OUTPUT：对应生产者
- 通信方式遵循发布-订阅模式：Topic主题进行广播

13.1 常用注解介绍

标准流程套路

Binder：连接中间件
Channel：通道，是队列Queue的一种抽象，在消息通讯系统中就是实现存储和转发的媒介，通过Channel对队伍进行配置
Source和Sink：简单理解为输入输出

编码API和常用注解

13.2 生产者

新建cloud-stream-rabbitmq-provider8801

POM

 <artifactId>cloud-stream-rabbitmq-provider8801artifactId>
     <dependencies>
         
         <dependency>
             <groupId>org.springframework.cloudgroupId>
             <artifactId>spring-cloud-starter-stream-rabbitartifactId>
         dependency>
         <dependency>
             <groupId>org.springframework.cloudgroupId>
             <artifactId>spring-cloud-starter-configartifactId>
         dependency>
         
         <dependency>
             <groupId>org.springframework.cloudgroupId>
             <artifactId>spring-cloud-starter-netflix-eureka-clientartifactId>
         dependency>
         
         <dependency>
             <groupId>org.springframework.bootgroupId>
             <artifactId>spring-boot-starter-webartifactId>
         dependency>
         <dependency>
             <groupId>org.springframework.bootgroupId>
             <artifactId>spring-boot-starter-actuatorartifactId>
         dependency>

         <dependency>
             <groupId>org.springframework.bootgroupId>
             <artifactId>spring-boot-devtoolsartifactId>
             <scope>runtimescope>
             <optional>trueoptional>
         dependency>
         <dependency>
             <groupId>org.projectlombokgroupId>
             <artifactId>lombokartifactId>
         dependency>
         <dependency>
             <groupId>org.springframework.bootgroupId>
             <artifactId>spring-boot-starter-testartifactId>
             <scope>testscope>
         dependency>
         <dependency>
             <groupId>junitgroupId>
             <artifactId>junitartifactId>
         dependency>

     dependencies>

 project>

YML

 server:
   port: 8801

 spring:
   application:
     name: cloud-stream-provider
   cloud:
     stream:
       binders: #在此处配置要绑定的rabbitmq的服务信息;
         defaultRabbit:    #表示定义的名称，用于丁binding整合
           type: rabbit    #消息组件类型
           environment:    #设置rabbitmq的相关的环境配置
             spring:
               rabbitmq:
                 host: localhost
                 port: 5672
                 username: guest
                 password: guest
       bindings:   #服务的整合处理
         output:   #这个名字是一个通道的名称
           destination: studyExchange    #表示要使用的Exchange名称定义
           content-type: application/json  #设置消息类型，本次为json，文本则设置"text/plain"
           binder: defaultRabbit   #设置要绑定的消息服务的具体设置


 eureka:
   client: #客户端进行Eureka注册的配置
     service-url:
       defaultZone: http://localhost:7001/eureka
   instance:
     lease-renewal-interval-in-seconds: 2        #设置心跳的时间间隔（默认是30秒)
     lease-expiration-duration-in-seconds: 5     #如果现在超过了5秒的间隔（默认是90秒
     instance-id: send-8801.com                  #在信息列表时显示主机名称
     prefer-ip-address: true                     #访问的路径变为IP地址

主启动类

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

业务类

发送消息接口

   package com.atguigu.springcloud.service;

   public interface IMessageProvide {
         
       public String send();
   }

发送消息接口实现类

   @EnableBinding(Source.class)    //定义消息的推送管道
   public class IMessageProviderImpl implements IMessageProvide {
         

       @Resource
       private MessageChannel output;

       @Override
       public String send() {
         
           String serial = UUID.randomUUID().toString();
           output.send(MessageBuilder.withPayload(serial).build());
           System.out.println("*******serial: "+serial);
           return null;
       }
   }

Controller

   @RestController
   public class SendMessageController {
         
       @Resource
       private IMessageProvide messageProvide;

       @GetMapping(value = "/sendMessage")
       public String sendMessage(){
         
           return messageProvide.send();
       }
   }

测试：7001、rabbitmq、8801、访问http://localhost:8801/sendMessage，然后在rabbitmq监控页面查看！

13.3 消费者

新建cloud-stream-rabbitmq-consumer8802

POM

 <artifactId>cloud-stream-rabbitmq-provider8801artifactId>
     <dependencies>
         
         <dependency>
             <groupId>org.springframework.cloudgroupId>
             <artifactId>spring-cloud-starter-stream-rabbitartifactId>
         dependency>
         <dependency>
             <groupId>org.springframework.cloudgroupId>
             <artifactId>spring-cloud-starter-configartifactId>
         dependency>
         
         <dependency>
             <groupId>org.springframework.cloudgroupId>
             <artifactId>spring-cloud-starter-netflix-eureka-clientartifactId>
         dependency>
         
         <dependency>
             <groupId>org.springframework.bootgroupId>
             <artifactId>spring-boot-starter-webartifactId>
         dependency>
         <dependency>
             <groupId>org.springframework.bootgroupId>
             <artifactId>spring-boot-starter-actuatorartifactId>
         dependency>

         <dependency>
             <groupId>org.springframework.bootgroupId>
             <artifactId>spring-boot-devtoolsartifactId>
             <scope>runtimescope>
             <optional>trueoptional>
         dependency>
         <dependency>
             <groupId>org.projectlombokgroupId>
             <artifactId>lombokartifactId>
         dependency>
         <dependency>
             <groupId>org.springframework.bootgroupId>
             <artifactId>spring-boot-starter-testartifactId>
             <scope>testscope>
         dependency>
         <dependency>
             <groupId>junitgroupId>
             <artifactId>junitartifactId>
         dependency>

     dependencies>

 project>

YML

 server:
   port: 8802

 spring:
   application:
     name: cloud-stream-consumer
   cloud:
     stream:
       binders:          #在此处配置要绑定的rabbitmq的服务信息;
         defaultRabbit:      #表示定义的名称，用子binding整合
           type: rabbit      #消息组件类型
           environment:      #没置rabbitmq的相关的环境鄗置
             spring:
               rabbitmq:
                 host: localhost
                 port: 5672
                 username: guest
                 password: guest
       bindings:     #服务的整合处理
         input:      #这个名字是一个通道的名称
           destination: studyExchange  #表示要使用的Exchange名称定义
           content-type: application/json    #设置消息类型，本次为对象json，如果是文本则设置“text/plain”
           binder: defaultRabbit       #没置婆绑定的消息服务的具体设置

 eureka:
   client: #客户端进行Eureka注册的配置
     service-url:
       defaultZone: http://localhost:7001/eureka
   instance:
     lease-renewal-interval-in-seconds: 2        #设置心跳的时间间隔（默认是30秒)
     lease-expiration-duration-in-seconds: 5     #如果现在超过了5秒的间隔（默认是90秒
     instance-id: send-8802.com                  #在信息列表时显示主机名称
     prefer-ip-address: true                     #访问的路径变为IP地址

主启动类

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

业务类

 @Controller
 @EnableBinding(Sink.class)
 public class ReceiveMessageListener {
       

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

     @StreamListener(Sink.INPUT)
     public void input(Message<String> message){
       
         System.out.println("消费者1号,--------->接收到的消息： "+message.getPayload()+"\t port: "+serverPort);
     }
 }

测试8801发送消息8802接受：访问http://localhost:8801/sendMessage

13.4 消息重复消费及解决

重复消费问题

依照8002，克隆一份8003
启动
两个问题：
- 重复消费问题
  
  如何解决？分组和持久化属性group
- 消息持久化问题

解决

原理：微服务应用放置于同一个group中，就能够保证消息只会被其中一个应用消费一次。不同的组是可以消费的，同一个组内会发生竞争关系，只有其中一个可以消费。
YML（8802、8803）：
测试

13.5 消息持久化

停掉8802、8803，去掉8802的group，保留8803的group，然后7001发送4条消息，重启8802、8803,8802的服务不会接收到消息，而8803的服务可以重新获取消息进行消费。

14. Sleuch请求链路追踪

14.1 概述

问题

在微服务框架中，一个由客户端发起的请求在后端系统中会经过多个不同的的服务节点调用来协同产生最后的请求结果，每一个前段请求都会形成一条复杂的分布式服务调用链路，链路中的任何一环出现高延时或错误都会引起整个请求最后的失败。

Sleuch是什么

Spring Cloud Sleuth提供了一套完整的服务跟踪的解决方案，在分布式系统中提供追踪解决方案并且兼容支持了zipkin。

14.2 zipkin搭建安装

下载：http://dl.bintray.com/openzipkin/maven/io/zipkin/java/zipkin-server/2.12.9/zipkin-server-2.12.9-exec.jar
当前目录命令行中运行jar：java -jar zipkin-server-2.12.9-exec.jar
运行控制台：http://localhost:9411/zipkin/
- 完整的链路调用：
- Trace：类似于树结构的Span集合，表示一条调用链路，存在唯一标识
- span：表示调用链路来源，通俗理解span就是一次请求信息

14.3 sleuch链路监控展现

修改8001模块：

POM：

   
   <dependency>
       <groupId>org.springframework.cloudgroupId>
       <artifactId>spring-cloud-starter-zipkinartifactId>
   dependency>

YML

   zipkin:
     base-url: http://localhost:9411
   sleuth:
     sampler:
       #采样率值介于0到1之间，1则表示全部采集
       probability: 1

业务类：

   @GetMapping(value = "/payment/zipkin")
   public String paymentZipkin(){
         
       return "hi, i am paymentzipkin server fall back, welcome to atguigu, O(∩_∩)O哈哈~";
   }

修改80模块

POM：同上
YML：同上

Controller：（没加@loadbalance就这么写）

   @GetMapping("/consumer/payment/zipkin")
   public String getPaymentZipkin(){
         
       String result = restTemplate.getForObject("http://localhost:8001"+"/payment/zipkin/",String.class);
       return result;
   }

   @GetMapping("/consumer/payment/zipkin")
   public String paymentZipkin(){
         
       String result = restTemplate.getForObject("http://cloud-payment-service"+"/payment/zipkin/",String.class);   //加@loadbalance了的
       return result;
   }

80调用8001：http://localhost/consumer/payment/zipkin
查看http://localhost:9411/zipkin/：