跳过单元测试：

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

总结：

建module
• 改pom
• 写yml
• 主启动类
• 业务类

3.2. 热部署Devtools

• 添加devtools依赖

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

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

  <build>
  <plugins>
  <plugin>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-maven-plugin</artifactId>
  <configuration>
  <fork>true</fork>
  <addResources>true</addResources>
  </configuration>
  </plugin>
  </plugins>
  </build>

• 开启自动编译选项

  

• 更新池

  ctrl+shift+alt+/

  

  

3.3 消费者模块

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

• pom

  <?xml version="1.0" encoding="UTF-8"?>
  <project xmlns="http://maven.apache.org/POM/4.0.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <parent>
  <artifactId>cloud2020</artifactId>
  <groupId>com.atguigu.springcloud</groupId>
  <version>1.0-SNAPSHOT</version>
  </parent>
  <modelVersion>4.0.0</modelVersion>
  
  <artifactId>cloud-consumer-order80</artifactId>
  
  <dependencies>
  <dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
  <dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-actuator</artifactId>
  </dependency>
  <dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-devtools</artifactId>
  <scope>runtime</scope>
  <optional>true</optional>
  </dependency>
  <dependency>
  <groupId>org.projectlombok</groupId>
  <artifactId>lombok</artifactId>
  <optional>true</optional>
  </dependency>
  <dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-test</artifactId>
  <scope>test</scope>
  </dependency>
  </dependencies>
  
  </project>

• yml

  server:  port: 80

• 业务类：

  entities

  

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

测试

Dashboard

通过修改idea的workspace.xml的方式来快速打开Run Dashboard窗口（.idea------>workspace.xml）



• 开启Run DashBoard

3.4. 工程重构

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

• 新建module

• pom依赖

  <?xml version="1.0" encoding="UTF-8"?>
  <project xmlns="http://maven.apache.org/POM/4.0.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <parent>
  <artifactId>cloud2020</artifactId>
  <groupId>com.atguigu.springcloud</groupId>
  <version>1.0-SNAPSHOT</version>
  </parent>
  <modelVersion>4.0.0</modelVersion>
  
  <artifactId>cloud-api-commons</artifactId>
  
  <dependencies>
  <dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-devtools</artifactId>
  <scope>runtime</scope>
  <optional>true</optional>
  </dependency>
  
  <dependency>
  <groupId>org.projectlombok</groupId>
  <artifactId>lombok</artifactId>
  <optional>true</optional>
  </dependency>
  
  <dependency>
  <groupId>cn.hutool</groupId>
  <artifactId>hutool-all</artifactId>
  <version>5.1.0</version>
  </dependency>
  </dependencies>
  
  </project>

• entities

  

• maven命令clean install

  

• 订单80和支付8001分别改造

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

• 各自粘贴POM内容

  <dependency>    <!--引入自己定义的API通用包-->
  <groupId>com.atguigu.springcloud</groupId>
  <artifactId>cloud-api-commons</artifactId>
  <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

  <?xml version="1.0" encoding="UTF-8"?>
  <project xmlns="http://maven.apache.org/POM/4.0.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <parent>
  <artifactId>cloud2020</artifactId>
  <groupId>com.atguigu.springcloud</groupId>
  <version>1.0-SNAPSHOT</version>
  </parent>
  <modelVersion>4.0.0</modelVersion>
  
  <artifactId>cloud-eureka-serve7001</artifactId>
  
  <dependencies>
  <!--eureka-server-->
  <dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
  </dependency>
  <!--引入自己定义的api通用包，可以使用Payment支付Entity -->
  <dependency>
  <groupId>com.atguigu.springcloud</groupId>
  <artifactId>cloud-api-commons</artifactId>
  <version>${project.version}</version>
  </dependency>
  <!--boot web actuator-->
  <dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
  <dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-actuator</artifactId>
  </dependency>
  
  <dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-devtools</artifactId>
  <scope>runtime</scope>
  <optional>true</optional>
  </dependency>
  <dependency>
  <groupId>org.projectlombok</groupId>
  <artifactId>lombok</artifactId>
  </dependency>
  <dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-test</artifactId>
  <scope>test</scope>
  </dependency>
  <dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  </dependency>
  
  </dependencies>
  
  </project>

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

  <!--Eureka Client-->
  <dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
  </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.cloud</groupId>
  <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
  </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一致）

一句话：负载均衡+RestTemplate调用

LB（负载均衡）

简单的说就是将用户的请求平摊的分配到多个服务上，从而达到系统的HA(高可用）。常见的负载均衡有软件Nginx，LVS，硬件F5等。

• Ribbon本地负载均衡客户端VS Nginx服务端负载均衡区别：

  Nginx是服务器负载均衡，客户端所有请求都会交给nginx，然后由nginx实现转发请求。即负载均衡是由服务端实现的。
• Ribbon本地负载均衡，在调用微服务接口时候，会在注册中心上获取注册信息服务列表之后缓存到JVM本地，从而在本地实现RPC远程服务调用技术。

集中式LB：

即在服务的消费方和提供方之间使用独立的LB设施(可以是硬件，如F5,也可以是软件，如nginx)，由该设施负责把访问请求通过某种策略转发至服务的提供方

进程内LB：

将LB逻辑集成到消费方，消费方从服务注册中心获知有哪些地址可用，然后自己再从这些地址中选择出一个合适的服务器。Ribbon就属于进程内LB，它只是一个类库，集成于消费方进程，消费方通过它来获取到服务提供方的地址。

在新版的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

    <?xml version="1.0" encoding="UTF-8"?>
  <project xmlns="http://maven.apache.org/POM/4.0.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <parent>
  <artifactId>cloud2020</artifactId>
  <groupId>com.atguigu.springcloud</groupId>
  <version>1.0-SNAPSHOT</version>
  </parent>
  <modelVersion>4.0.0</modelVersion>
  
  <artifactId>cloud-consumer-feign-order80</artifactId>
  <dependencies>
  
  <dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-openfeign</artifactId>
  </dependency>
  
  <dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
  </dependency>
  
  <dependency>    <!--引入自己定义的API通用包-->
  <groupId>com.atguigu.springcloud</groupId>
  <artifactId>cloud-api-commons</artifactId>
  <version>${project.version}</version>
  </dependency>
  <dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
  <dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-actuator</artifactId>
  </dependency>
  <dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-devtools</artifactId>
  <scope>runtime</scope>
  <optional>true</optional>
  </dependency>
  <dependency>
  <groupId>org.projectlombok</groupId>
  <artifactId>lombok</artifactId>
  <optional>true</optional>
  </dependency>
  <dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-test</artifactId>
  <scope>test</scope>
  </dependency>
  </dependencies>
  
  </project>
  

• 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);
  }<
  4000
  /span> 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

配置日志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客户端

服务熔断：类比保险丝达到最大服务访问后，直接拒绝访问，拉闸限电，然后调用服务降级的方式并返回友好提示（保险丝）

服务限流：秒杀高并发等操作，严禁一窝蜂地拥挤，大家排队，一秒钟N个，有序进行

原因：

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=" "）

  设定全局降级

  

• 兜底方法

  //全局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";
  }
  }

• YML

  

• 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

  <?xml version="1.0" encoding="UTF-8"?>
  <project xmlns="http://maven.apache.org/POM/4.0.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <parent>
  <artifactId>cloud2020</artifactId>
  <groupId>com.atguigu.springcloud</groupId>
  <version>1.0-SNAPSHOT</version>
  </parent>
  <modelVersion>4.0.0</modelVersion>
  
  <artifactId>cloud-consumer-hystrix-dashboard9001</artifactId>
  
  <dependencies>
  <dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
  </dependency>
  <dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-actuator</artifactId>
  </dependency>
  <dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-devtools</artifactId>
  <scope>runtime</scope>
  <optional>true</optional>
  </dependency>
  <dependency>
  <groupId>org.projectlombok</groupId>
  <artifactId>lombok</artifactId>
  <optional>true</optional>
  </dependency>
  <dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-test</artifactId>
  <scope>test</scope>
  </dependency>
  </dependencies>
  
  </project>

• 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.boot</groupId>
  <artifactId>spring-boot-starter-actuator</artifactId>
  </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
• 先访问正确地址，再访问错误地址，再正确地址，会发现断路器都是慢慢放开的

如何看图？

七色



• 一圈

  

  

• 一线：用来记录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

    <?xml version="1.0" encoding="UTF-8"?>
  <project xmlns="http://maven.apache.org/POM/4.0.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <parent>
  <artifactId>cloud2020</artifactId>
  <groupId>com.atguigu.springcloud</groupId>
  <version>1.0-SNAPSHOT</version>
  </parent>
  <modelVersion>4.0.0</modelVersion>
  
  <artifactId>cloud-gateway-gateway9527</artifactId>
  
  <dependencies>
  <dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-gateway</artifactId>
  </dependency>
  
  <dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
  </dependency>
  
  <dependency>    <!--引入自己定义的API通用包-->
  <groupId>com.atguigu.springcloud</groupId>
  <artifactId>cloud-api-commons</artifactId>
  <version>${project.version}</version>
  </dependency>
  <dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-devtools</artifactId>
  <scope>runti
  4000
  me</scope>
  <optional>true</optional>
  </dependency>
  <dependency>
  <groupId>org.projectlombok</groupId>
  <artifactId>lombok</artifactId>
  <optional>true</optional>
  </dependency>
  <dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-test</artifactId>
  <scope>test</scope>
  </dependency>
  </dependencies>
  
  </project>
  

• 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 配置路由的两种方式

1. 上述的yaml配置

2. 代码中注入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会根据注册中心注册的服务划表，以注册中心上微服务名为路径创建动态路由进行转发，从而实现动态路由的功能

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

1. After Route Predicate：

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

   

2. Before Route Predicate、Between Route Predicate与上面类似

3. Cookie Route Predicate：

   

   

   

   

4. Header Route Predicate

   

   

5. Host Route Predicate：

   

   

6. Method Route Predicate：

   

7. Path Route Predicate：

   就是 -Path

8. Query Route Predicate：

   

总结

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

10.8 Filter

介绍

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

1. 自定义过滤器：实现两个接口，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 分布式配置中心介绍

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

介绍

1. SpringCloud Config为微服务架构中的微服务提供集中化的外部配置支持，配置服务器为各个不同微服务应用的所有环境提供了一个中心化的外部配置。

2. SpringCloud Config分为服务端和客户端两部分。

3. 服务端也称为分布式配置中心，它是一个独立的微服务应用，用来连接配置服务器并为客户端提供获取配置信息，加密/解密信息等访问接口。

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

11.2 配置总控中心搭建

1. POM

   <?xml version="1.0" encoding="UTF-8"?>
   <project xmlns="http://maven.apache.org/POM/4.0.0"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <parent>
   <artifactId>cloud2020</artifactId>
   <groupId>com.atguigu.springcloud</groupId>
   <version>1.0-SNAPSHOT</version>
   </parent>
   <modelVersion>4.0.0</modelVersion>
   
   <artifactId>cloud-config-center-3344</artifactId>
   <dependencies>
   <dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-config-server</artifactId>
   </dependency>
   <!--eureka-server-->
   <dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
   </dependency>
   <!--boot web actuator-->
   <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
   </dependency>
   <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-actuator</artifactId>
   </dependency>
   
   <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-devtools</artifactId>
   <scope>runtime</scope>
   <optional>true</optional>
   </dependency>
   <dependency>
   <groupId>org.projectlombok</groupId>
   <artifactId>lombok</artifactId>
   </dependency>
   <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-test</artifactId>
   <scope>test</scope>
   </dependency>
   <dependency>
   <groupId>junit</groupId>
   <artifactId>junit</artifactId>
   </dependency>
   
   </dependencies>
   
   </project>

2. 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: 448191580@qq.com
   password: ran88518
   skip-ssl-validation: true
   ####读取分支
   label: main
   
   #服务注册至eureka地址
   eureka:
   client:
   service-url:
   defaultZone: http://localhost:7001/eureka

3. 主启动类

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

4. windows下修改hosts文件，增加映射

   127.0.0.1	config-3344.com

5. 测试通过Config微服务是否可以从GitHub上获取配置内容：启动3344，http://config-3344.com:3344/main/config-dev.yml

   

配置读取规则

1. /{label}/{application}-fprofile}.yml

   

2. /{application}-{profile}.yml

   

3. /{application}/{profile}[/{label}]

   

配置细节

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

11.3 客户端配置与测试

1. 新建cloud-config-client-3355

2. POM

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

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

5. 主启动类

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

6. 业务类

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

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

   

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

11.4 动态刷新手动版

修改3355模块：

1. POM引入actuator监控

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

2. 修改yml，暴露监控端口

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

3. @RefreshScope业务类Controller修改

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

4. 此时修改github由2->1，发现没生效啊！

5. 需要运维人员发个post请求刷新3355：curl -X POST “http://localhost:3355/actuator/refresh”

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

12. bus消息总线

12.1 概述

1. Bus只支持两种消息代理，RabbitMQ和Kafka

2. 可以实现配置的自动刷新

   

3. Spring Cloud Bus能管理和传播分布式系统间的消息，就像一个分布式执行器，可用于广播状态更改、事件推送等，也可以当作微服务间的通信通道。

12.2 环境配置

1. 安装erlang：http://erlang.org/download/otp_win64_21.3.exe

2. rabbitmq：https://dl.bintray.com/rabbitmq/all/rabbitmq-server/3.7.14/rabbitmq-server-3.7.14.exe

3. 进入rabbitmq安装的sbin目录下，命令行输入：.\rabbitmq-plugins enable rabbitmq_management

   

4. 开始目录启动rabbit.start，测试是否成功：http://localhost:15672，成功进入，登录账号密码均是guest

12.3 动态刷新全局广播

环境搭建

1. 再制作一个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;
   }
   }

2. 设计思想：

   利用消息总线触发一个客户端/bus/refresh，而刷新所有客户端的配置

   • 利用消息总线触发一个服务端ConfigServer的/bus/refresh端点，而刷新所有客户端的配置

   • 图二的架构显然更加适合，图—不适合的原因如下：

     

实现

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

   POM：

   <!--添加消息总线RabbitMQ支持-->
   <dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-bus-amqp</artifactId>
   </dependency>

   • YML：

     #rabbitmq相关配置
     rabbitmq:
     host: localhost
     port: 5672
     username:guest
     password:guest
     
     #rabbitmq相关配置，暴露bus刷新配置的端扣
     management:
     endpoints:    #暴露bus刷新配置的端扣
     web:
     exposure:
     include: 'bus-refresh'

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

   POM

   <!--添加消息总线RabbitMQ支持-->
   <dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-bus-amqp</artifactId>
   </dependency>

   • YML

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

3. 给cloud-config-client-3366客户端添加消息总线支持：跟上面3355一样

4. 测试：

   修改github版本号，发送POST请求，一次发送，处处生效！

12.4 动态刷新定点通知

只通知3355，不通知3366：

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

   

13. Stream消息驱动

介绍

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

设计思想

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

   通过定义绑定器Binder作为中间层，实现应用程序和消息中间件细节上的解耦隔离

2. Binder：

   INPUT：对应消费者

   • OUTPUT：对应生产者

   • 通信方式遵循发布-订阅模式：Topic主题进行广播

13.1 常用注解介绍

标准流程套路

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

编码API和常用注解

13.2 生产者

1. 新建cloud-stream-rabbitmq-provider8801

2. POM

   <artifactId>cloud-stream-rabbitmq-provider8801</artifactId>
   <dependencies>
   <!--添加消息总线RabbitMQ支持-->
   <dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-stream-rabbit</artifactId>
   </dependency>
   <dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-config</artifactId>
   </dependency>
   <!--eureka-server-->
   <dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
   </dependency>
   <!--boot web actuator-->
   <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
   </dependency>
   <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-actuator</artifactId>
   </dependency>
   
   <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-devtools</artifactId>
   <scope>runtime</scope>
   <optional>true</optional>
   </dependency>
   <dependency>
   <groupId>org.projectlombok</groupId>
   <artifactId>lombok</artifactId>
   </dependency>
   <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-test</artifactId>
   <scope>test</scope>
   </dependency>
   <dependency>
   <groupId>junit</groupId>
   <artifactId>junit</artifactId>
   </dependency>
   
   </dependencies>
   
   </project>

3. YML

   server:
   port: 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地址

4. 主启动类

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

5. 业务类

   发送消息接口

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

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

   

13.3 消费者

1. 新建cloud-stream-rabbitmq-consumer8802

2. POM

   <artifactId>cloud-stream-rabbitmq-provider8801</artifactId>
   <dependencies>
   <!--添加消息总线RabbitMQ支持-->
   <dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-stream-rabbit</artifactId>
   </dependency>
   <dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-config</artifactId>
   </dependency>
   <!--eureka-server-->
   <dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
   </dependency>
   <!--boot web actuator-->
   <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
   </dependency>
   <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-actuator</artifactId>
   </dependency>
   
   <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-devtools</artifactId>
   <scope>runtime</scope>
   <optional>true</optional>
   </dependency>
   <dependency>
   <groupId>org.projectlombok</groupId>
   <artifactId>lombok</artifactId>
   </dependency>
   <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-test</artifactId>
   <scope>test</scope>
   </dependency>
   <dependency>
   <groupId>junit</groupId>
   <artifactId>junit</artifactId>
   </dependency>
   
   </dependencies>
   
   </project>

3. YML

   server:
   port: 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地址

4. 主启动类

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

5. 业务类

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

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

   

   

13.4 消息重复消费及解决

重复消费问题

1. 依照8002，克隆一份8003

2. 启动

3. 两个问题：

   重复消费问题

   如何解决？分组和 持久化属性group

   

   • 消息持久化问题

解决

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

2. YML（8802、8803）：

   

3. 测试

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搭建安装

1. 下载：http://dl.bintray.com/openzipkin/maven/io/zipkin/java/zipkin-server/2.12.9/zipkin-server-2.12.9-exec.jar

2. 当前目录命令行中运行jar：java -jar zipkin-server-2.12.9-exec.jar

3. 运行控制台：http://localhost:9411/zipkin/

   完整的链路调用：

   

   

   • Trace：类似于树结构的Span集合，表示一条调用链路，存在唯一标识

   • span：表示调用链路来源，通俗理解span就是一次请求信息

14.3 sleuch链路监控展现

1. 修改8001模块：

   POM：

   <!--包含了sleuth+zipkin-->
   <dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-zipkin</artifactId>
   </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哈哈~";
     }

2. 修改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;
     }

3. 80调用8001：http://localhost/consumer/payment/zipkin

   

4. 查看http://localhost:9411/zipkin/：