springcloud 介绍

Spring Cloud是一系列框架的有序集合。它利用Spring Boot的开发便利性巧妙地简化了分布式系统基础设施的开发，如服务发现注册、配置中心、消息总线、负载均衡、断路器、数据监控等，都可以用Spring Boot的开发风格做到一键启动和部署。Spring Cloud并没有重复制造轮子，它只是将各家公司开发的比较成熟、经得起实际考验的服务框架组合起来，通过Spring Boot风格进行再封装屏蔽掉了复杂的配置和实现原理，最终给开发者留出了一套简单易懂、易部署和易维护的分布式系统开发工具包。
老实说介绍百度粘来的自己看看就好,这种得了解下就行;

学习springcloud 需要提前知道知识

我想相信啊基本上能来找springcloud 得学习资料的人基本上都已经掌握了spring ,springboot ,springmvc ,mybatis等技术啊!
我这边主要想解释一下上面为啥说springcloud 是个有序的框架集合
从字面的意思就是有很多的框架组合的框架就叫springcloud,从官方我们也能知道下面有很多的框架集合截图

spring cloud 中实际有这么多的框架每一个都是独立的存在的而我们这边学习的时候不是所有的多会使用到我简单介绍最常用的几种技术；

1. 注册中心：eureka 和consul 进行讲解 zookeeper 在spring cloud 的项目中我不建议使用；
2. ribbon: 负载均衡
3. 服务调用： openFeign,restTemplate
4. 断路器服务的降级，熔断，限流： hystrix
5. 网关： gateway网关
6. 配置中心：spring cloud config
7. 消息总线： spring cloud bus
8. 消息驱动： spring cloud stream
9. 链路： spring cloud sleuth

注册中心

介绍注册中心就必须先得说说CAP原则
C ——一致性 ，A——可用性 ，P——分区容错性，但是没有注册中心能同时满足三个原则但是P是要绝对成立得那也就是说注册中心的框架要不满足AP,要不满足CP，实时也是这样的啊eureka 就是AP ,consul 就是CP

eureka 注册中心

这个注册中心可以用但是有些项目中逐渐开始不使用，具体啥原因不知道，官方也不推荐再继续使用。不知道后期会怎么样，我用起来觉得还行所以写写;
创建一个主项目除了pom 文件没有其他的目录

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.cloud.csdn</groupId><artifactId>cloud-csdn</artifactId><packaging>pom</packaging><version>1.0-SNAPSHOT</version><modules><module>cloud-eureka-server3XXX</module><module>cloud-eureka-csdn-provider800X</module><module>cloud-common-api</module><module>cloud-eureka-csdn-consumer900X</module></modules><properties><lombok.version>1.18.10</lombok.version></properties><dependencyManagement><dependencies><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-dependencies</artifactId><version>Hoxton.SR1</version><type>pom</type><scope>import</scope></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-dependencies</artifactId><version>2.2.1.RELEASE</version><type>pom</type><scope>import</scope></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><version>${lombok.version}</version></dependency></dependencies></dependencyManagement></project>

eureka server

我是用的工具IDEA 第一步创建一个子项目spring mvn 项目来作为eureka 的服务
pom.xml

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

主启动项

@SpringBootApplication
//一定添加enablkeeurekaserver这个注解
@EnableEurekaServer
public class EurekaServer3XXX {public static void main(String[] args) {SpringApplication.run(EurekaServer3XXX.class, args);}
}

注册中心服务配置
我这里使用的是yml的多环境方式，这为我们后期处理集群时每次启动只需要选择环境启动就好

spring:profiles: eureka3001---
spring:profiles:active: eureka3001application:name: eurekaserver3001
server:port: 3001
eureka:instance:hostname: localhsot# 注册的idinstance-id: ${spring.application.name}:${eureka.instance.hostname}:${server.port}prefer-ip-address: trueclient:# 不往注册中心或列表注册fetch-registry: falseregister-with-eureka: false# 修改默认注册地址 当使用单机的eureka 不填写 这个可以用但是在监听的时候会报错service-url:defaultZone: http://localhost:3001

上述就完成了简单的eureka 的注册服务启动后使用本地的http://locahost:3001得到下面页面。（注意这个没有配置修改默认地址所以和第二张图标红的地址与配置地址不一样，还有红色的字体就是告诉我们eureka的安全机制开启）

修改过默认地址

eureka 还有几个我觉得比较好的功能就是监听，我只说两个一般在使用中我感觉这两个的作用比较大一个是服务下线和服务上线
EurekaInstanceCanceledEvent 服务为下线
EurekaInstanceRegisteredEvent 服务注册

package com.cloud.csdn.config;import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.netflix.eureka.server.event.EurekaInstanceCanceledEvent;
import org.springframework.cloud.netflix.eureka.server.event.EurekaInstanceRegisteredEvent;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.event.EventListener;
/*** @author  whj* @deprecated  监听服务的操作*/
@Configuration
@Slf4j
public class EurekaListenConfig {@EventListenerpublic void listen(EurekaInstanceCanceledEvent event){log.warn("服务通知： "+event.getServerId()+"服务下线");}@EventListenerpublic  void listen(EurekaInstanceRegisteredEvent event){log.warn("服务通知： "+event.getInstanceInfo().getInstanceId()+"服务上线");}}

服务提供者

在书写一个提供服务的服务并注册到eureka 中
创建一个好的mvn 项目我们直接上代码
pom.xml 注意我这里只粘贴了核心的依赖，springboot的依赖我默认你是很熟悉的了

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

同样的编写一个主启动类

@SpringBootApplication
//注解告诉这个是一个客户端
@EnableEurekaClient
public class EurekaClientprovider800X {public static void main(String[] args) {SpringApplication.run(EurekaClientprovider800X.class, args);}
}

书写一个yml的配置文件

spring:profiles: cloud-eurekaclient8001
---
server:port: 8001
spring:profiles:active: cloud-eurekaclientapplication:name: cloud-eurekaclient8001
eureka:instance:prefer-ip-address: trueinstance-id: ${spring.application.name}:${server.port}client:service-url:defaultZone: http://localhost:3001/eureka

到这向注册中心中注册一个服务就完成了；下面我们创建我们平时写的业务代码就行了；我这边测试就是随便写写主要要为了演示功能
先写一个service 接口

package com.cloud.csdn.common.service;public interface UserService {String saythello();
}

在书写个实现类

package com.cloud.csdn.service;import com.cloud.csdn.common.service.UserService;
import org.springframework.stereotype.Service;@Service
public class UserServiceImpl  implements UserService {public String saythello() {return "你好!成功调用此接口";}
}

书写一个web 接口

package com.cloud.csdn.controller;import com.cloud.csdn.common.entry.ReturnUtil;
import com.cloud.csdn.common.service.UserService;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;import javax.annotation.Resource;@RestController
public class UserController {@Resourceprivate UserService userService;@GetMapping("say")public ReturnUtil<String> sayhello(){return ReturnUtil.success(200, userService.saythello(), "成功获取！");}
}

服务消费者

这里的创建并注册到注册中心的步骤同上面注册到配置步骤一模一样，只是需要配置restTemplate，这个用来服务调用的

@Configuration
public class Httpclientutil {@Beanpublic RestTemplate restTemplate(){return  new RestTemplate();}
}

调用接口服务提供者

@RestController
public class UserController {@Resourceprivate RestTemplate restTemplate;@GetMapping("sayhello")public ReturnUtil<String> sayhello(){return restTemplate.getForObject("http://localhost:8001/say", ReturnUtil.class);}}

eureka集群

由eureka 的安全配置带来的问题和解决的方案
问题:当我们的服务已近关闭了后，注册中心依然保持信息我们可以通过配置来关闭注册中心的安全，给服务端配置检查时间，给客户端配置心跳和响应时间件来解决这个问题
在服务端中的配置

eureka:server:#关闭安全enable-self-preservation: false#每隔5s检查一次逐出不可用的 eviction-interval-timer-in-ms: 5000

客户端的主要增加的配置

eureka:instance:#租期续订lease-renewal-interval-in-seconds: 20#到期时间间隔lease-expiration-duration-in-seconds: 20

这样配置后当你关闭服务后的第五秒钟就会被注册中心清扫出去；
服务集群配置
假设现在又三台eureka01,eureka02,eureka03;
eureka01的配置就是把01，注册到02，03上

	spring:profiles:active: eureka3003
#eureka01
---
spring:profiles: eureka3001application:name: eurekaserver01
server:port: 3001
eureka:instance:hostname: localhsotinstance-id: ${spring.application.name}:${eureka.instance.hostname}:${server.port}client:fetch-registry: falseregister-with-eureka: falseservice-url:#这里向02，03中加入01defaultZone: http://127.0.0.1:3002/eureka,http://192.168.0.100:3003/eurekaserver:enable-self-preservation: falseeviction-interval-timer-in-ms: 5000
#eureka02
---
spring:profiles: eureka3002application:name: eurekaserver02
server:port: 3002
eureka:instance:hostname: 127.0.0.1instance-id: ${spring.application.name}:${eureka.instance.hostname}:${server.port}client:fetch-registry: falseregister-with-eureka: falseservice-url:defaultZone: http://localhost:3001/eureka,http://192.168.0.100:3003/eurekaserver:enable-self-preservation: falseeviction-interval-timer-in-ms: 5000
#eureka03
---
spring:profiles: eureka3003application:name: eurekaserver03
server:port: 3003
eureka:instance:hostname: 192.168.0.100instance-id: ${spring.application.name}:${eureka.instance.hostname}:${server.port}client:fetch-registry: falseregister-with-eureka: falseservice-url:defaultZone: http://localhost:3001/eureka,htpp://127.0.0.1:3002/eurekaserver:enable-self-preservation: falseeviction-interval-timer-in-ms: 5000

看一下01这个服务器配置和这张图 DS 部分更配置中相同 其他的你们在学习中也能看到我就不写了
客户端怎么注册

server:port: 8001
spring:profiles:active: cloud-eurekaclient8001application:name: cloud-eurekaclient
eureka:instance:prefer-ip-address: trueinstance-id: ${spring.application.name}:${server.port}lease-renewal-interval-in-seconds: 20lease-expiration-duration-in-seconds: 20client:service-url:               # 单服#defaultZone: http://localhost:3001/eureka# 集群配置defaultZone: http://localhost:3001/eureka/,http://127.0.0.1:3002/eureka/,http://192.168.0.100:3003/eureka/

总结：上面的就算是eureka 的使用方式，现在官方不建议使用了，其实我个人觉得这个框架比较好，易学习为啥呢？集群的配置也相对简单

consul 注册中心

consul server

consul 的服务跟eureka就有所不同了，这个注册中心是需要我们自己去官方网站下载 https://www.consul.io
类似一个写好的安装程序安装并使用 下载安装好以后直接使用我这里使用两个一个是win10 下的和liunx 系统下的docker 中使用集群，当然也可以在你的win10下进行集群我是为了方便我的win10没有配置集群环境，win10下的集群自行百度
由于我们进场使用win10开发测试我这里先讲 如何在win10 下使用consul
使用cmd 直接启动

	consul agent -dev

启动成功后访问http://ip:8500
consul server+client 集群配置centos docker 容器为例

 #先使用docker 命令拿下consul docker pull consul#启动一个节点的 consul serverdocker run -d -p 8500:8500 --name=consul01  consul agent -server -ui -node=server01 -bootstrap-expect=3 -client 0.0.0.0#查看一下docker自动分配置的 ip地址docker inspect -f '{{.NetworkSettings.IPAddress}}' consul01#启动第二个 节点 serverdocker run -d -p 8501:8500 --name=consul02 consul agent -server  -ui -node=server02 -bootstrap-expect=3 -client=0.0.0.0 -join=根据你查询的ip
#启动 第三个 节点 server docker run -d -p 8502:8500 --name=consul03 consul agent -server  -ui -node=server03 -bootstrap-expect=3 -client=0.0.0.0 -join=根据你查询的ip#上面启动都是服务我么这边在启动一个 client 也可以启动多个clien当我们在代码中连接时只需要连接client 模式docker run -d -p 9100:8500 --name=consul03 consul agent   -ui -node=client01 -bootstrap-expect=3 -client=0.0.0.0 -join=根据你查询的ip

上述配置的只是一个简单的集权案例就是模拟一下集权的工作，在开发中实际的consul 的集权是在这个基础上加上多个client 模式然后通过nginx 负载均衡，服务端也是通过地址访问nginx 然后通过nginx 的算法找到可用的client 注册信息保存到server 模式的consul 中

向consul 中注册服务

服务提供者
主要的pom 引用

		<dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-consul-discovery</artifactId></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>com.cloud.csdn.common</groupId><artifactId>cloud-common-api</artifactId><version>1.0-SNAPSHOT</version></dependency>

主启动类

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

配置文件yml

spring:profiles:active: consul8101
---
server:port: 8101
spring:profiles: consul8101application:name: consul-provider8101cloud:consul:host: 192.168.0.100:9100discovery:enabled: trueregister: truederegister: trueprefer-ip-address: trueip-address: 192.168.0.104

其他的service 实现类和controller 同上eureka

服务消费者略

consul 的config 配置中心

使用背景：当我们的服务越来越多的时候我们每次修改掉的数据库地址或其他的公共数据时候，都需要来操作修改配置文件这样就会太麻烦我们能不能有个公共的配置文件来处理这样的问题这时候就用到了配置中心，还有的公司可能数据库的配置文件跟你开发人员不是一个人时候他不可能来需改代码中的文件，而我们的consul 提供了一个K:V从而来实现一个简单的配置中心；

创建一个bootstrap.yml 文件，为啥用bootstrap 这里是自动配置有一个自动配置类首先加载那个类了导致了一个bug 就是你在application 配置的 信息不会被使用所有这里要想使用config 就得使用bootstrap,首先加载bootstrap 且不会被覆盖

spring:profiles:active: consul8101
---
server:port: 8101
spring:profiles: consul8101application:name: consul-provider8101cloud:consul:host: 192.168.0.100:9100discovery:enabled: trueregister: truederegister: trueprefer-ip-address: trueip-address: 192.168.0.104config:prefix: testconfigdefault-context: applicationformat: yamlprofile-separator: ':'data-key: data

ribbon:负载均衡

ribbon:就是一个负载均衡的客户端

ribbon与RestTemplate 的简单使用

上面配置一个bean 只需要在那个bean 上添加一个注解 @LoadBalanced 就可以使用负载均衡的算法默认使用轮询 如下图所示
开始使用restTempate 的方法的时候使用的是指定的地址路径，由于ribbon 和注册中心的整合只需要使用注册中心的名称即可例： http://注册中心的名字/controller路径;

ribbon 的IRlue

首先我们来看一个继承树
负载均衡的算法

1. RoundRobinRule 轮询默认的就是这个算法
2. RandomRule 随机算法
3. RetyRule :没有问题的时候执行轮询当出现问题时会自动重新找到可用的服务
4. BestAvailableRule: 过滤掉由于访问过多所以使用hystrix的熔断服务，然后找一个教空闲的服务
5. AvailabilityFilteringRule: 过滤掉故障实例在找到一个较为空闲的实例
6. WeightedResponseTimeRule: 权重算法：设置权重越大的实例响应越快越快的权重越大 ，被选择的次数就越多
   如何修改默认的算法
   创建一个包不要放在你的项目启动路径下再创建一个MyRuleConfig的类

@Configuration
public class MyRuleConfig{@Beanpublic IRule iRule(){return new RandomRule();}}

自主启动类上加上注解@RibbonClient(name = “consul-provider8101”,configuration = MyRuleConfig.class)即可使用 name是你需要被负载均衡调用的服务
通过上面的继承类树如果想使用自定义算法 自行继承实现方法完成

openFeign 服务的调用

openFeign :前面使用的是在消费者controller层使用resttemplate 来调用服务使用注解拦截器的方式完成ribbon与resttemlate 结合使用完成的负载均衡，而openFeign 在上面的基础上进行了封装使用接口+注解的方式调用服务，也就是使用openFeign无需添加注解@LoadBalanced 使用只需要指定负载算法即可
创建一个 openFeign的 接口例如：

/*** @author whj* @FeignClient value ： 调用的服务名*/
@Component
@FeignClient(value = "consul-provider8101")
public interface UserFeignService {@GetMapping("sayhello")ReturnUtil<String> sayhello();
}

在主启动类中加入 注解@EnableFeignClients ，controller 层只需要注入这个 上面实例的对象调用sayhello的方法即可
我这里没有讲解Feign 使用的是openFeign 其实这两个没啥区别 openFeign 是在Feign 的基础上升级支持了springmvc 的注解

hystrix 断路器

hystrix 有三个主要的概念： 服务降级，服务熔断，服务限流

服务降级

服务降级就是当我们的用户量较大的时候会出现网页卡顿，我们可以通过设置时间的长度来给用户迅速的返回一个数据告诉他稍后重试的提示从而减少服务调度的排队等待；如果没有降级就会出现什么情况，在实际开发中如果当用户达到数量后会自然形成一个排队一个个执行（这里的一个个并不是真的一个个他也是根据线程池并发执行的我只是比喻），等待执行而我们浏览器通常等待的最大时间是15分钟，可能出现浏览器十五分钟显示网页断链，但是我们的服务器的服务还在执行而不会断掉你的请求，这样足够多的时候就会压垮我们的服务器，也会影响我们同服务器的其他的接口；但是我们通过设置过期时间比如3S他就会在到达这个过期时间的时候去调用我们的指定方法。不会一直等待执行。
服务降级案例如：我这里为了模拟设置时间过期我使用线程等待来强制过期来模拟
方式一 ： 使用@HystrixCommand注解
我的熔断放在消费方一般都是放在这里当然放在提供方也是可以的，但是提供放一般业务都放在提供方在处理大业务量的时候可能会宕机所以我一般选择消费方，也建议使用消费方
在主启动类添加@EnableHystrix 注解
controller 实例代码

//这里继承的UserError 自定义的类为了是在fallbackMethod的方法不需要重复书写因为你在实际开发中可能有很多个controller也并不是所有的多需要重写@RestController
public class UserController extends UserError {
//     @Resource
     private RestTemplate restTemplate;
     private static final String url="http://consul-provider8101/";@Resourceprivate UserFeignService userFeignService;@GetMapping("say")@HystrixCommand( fallbackMethod = "timeoutorerror",commandProperties = {//这个注解的name的值是可以可以在jar包中找到不是背的——————作为一个程序员一定要回去找源码@HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value="3000")})public ReturnUtil<String> sayhello() {return userFeignService.sayhello();}}

方式二：结合openFeign来使用把hystrix的代码从业务中拆解出来 定义全局的配置对特定的进行注解配置；
在主启动类的中添加一个@EnableHystrix 注解
openfeign实例：

/*** @author whj* @FeignClient value ： 调用的服务名*/
@Component
@FeignClient(value = "consul-provider8101",fallback = UserFeginServiceImpl.class)
public interface UserFeginService {@GetMapping("sayhello")ReturnUtil<String> sayhello();
}

在书写一个实现这个接口的实例当错误或者超时等达到一系列需要降级的时候就会调用实现的feign接口的实现方法，实例如下：

@Component
public class UserFeginServiceImpl implements UserFeginService {public ReturnUtil<String> sayhello() {return ReturnUtil.success(200, "有可能是超时或者代码错误", "错误");}
}

yaml文件配置在你原来的配置文件中添加

feign:hystrix:enabled: trueclient:config:#这个默认的实际配置ribbon 中的连接和读取超时为啥配置这个能在ribbon 默认是1s但是实际开发中我们一般响应0-3s所以这里可能会改使用feign 就是如下配置也可以在ribbon中配置default:connect-timeout: 10000read-timeout: 10000#全局的参数配置hystrix:command:default: #这个是根据@HystrixProperty这个注解的name来配置的execution:isolation:thread:timeoutInMilliseconds: 4000

注意:上面这个方法二说的是配置一个全局的降级但是在我们代码中可能会出现一些需要单独配置那么就直接在方法上加上注解；默认注解的方法优先大于全局配置只限于同一种服务的处理方案

服务熔断

很多的资料说到熔断才会讲到一个雪崩效应，其实我觉得只是我认为啊，熔断，降级，限流都是解决雪崩的，但是熔断更降级很想为啥呢？举例：降级就是我们假设并发有一千个这是响应超过设定时间的所有用户都会返回错误提示。
熔断就是我们在请求一个接口我们设置在20s中出现10次错误后就会启动降级在时间段里请求的所有人返回固定的错误提示，当下个时间段他又会慢慢的放开直到全开
我这里以注解为例完成一个简单的熔断
根据上述方式一

    @PostMapping("fause")@HystrixCommand(fallbackMethod = "getFuse",commandProperties ={//开启熔断@HystrixProperty(name = "circuitBreaker.enabled" ,value = "true"),//设置请求开启阈值默认是20@HystrixProperty(name = "circuitBreaker.requestVolumeThreshold", value = "5"),//多少毫秒内@HystrixProperty(name="circuitBreaker.sleepWindowInMilliseconds",value = "20000") ,//达到错误率@HystrixProperty(name="circuitBreaker.errorThresholdPercentage",value = "50")})public ReturnUtil<String> getfause(int num){System.out.println("消费者："+num);return ReturnUtil.success(200,userFeginService.getFuse(num),"成功");}

服务限流

一般使用在抢购秒杀等项目中

hystrix dashboard 熔断监控

先创建一个监控服务
pom 文件

  <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-actuator</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId></dependency>

主启动类

package com.cloud.csdn;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.hystrix.dashboard.EnableHystrixDashboard;
@SpringBootApplication
@EnableHystrixDashboard
public class HystrixDashboard100X {public static void main(String[] args) {SpringApplication.run(HystrixDashboard100X.class, args);}  
}

ymal 文件配置

server:port: 1001

hystrix dashboard 根据上述配置测试地址是;http://localhost:1001/hystrix;
这个工具主要用于监控我们的系统在调用服务的成功和熔断等次数；
配置消费在之前的集成hystrix的基础上修改主启动类如下：

@SpringBootApplication
@EnableDiscoveryClient
@EnableFeignClients
@EnableHystrix
@RibbonClient(name = "consul-provider8101",configuration = MyRlue.class)
public class ConsulConsumer910X {public static void main(String[] args) {SpringApplication.run(ConsulConsumer910X.class, args);}
//	监控的路径映射bean@Beanpublic ServletRegistrationBean servletRegistrationBean(){HystrixMetricsStreamServlet streamServlet=new HystrixMetricsStreamServlet();ServletRegistrationBean servletRegistrationBean=new ServletRegistrationBean(streamServlet);servletRegistrationBean.addUrlMappings("/hystrix.stream");servletRegistrationBean.setLoadOnStartup(1);servletRegistrationBean.setName("HystrixMetricsStreamServlet");return servletRegistrationBean;}
}

路由网关

路由网关：从字面意思去理解，网间转换器，协议连接器；连接需要地址 那么路由就是连接地址；在我们系统中的左右看一下下图

zuul 路由网关

zuul ：其实就是一个过滤链而拦截的方式只四种：pre，route，post ，error；这些模式链可以帮助我们完成登录认证操作日志等等；
pre： 在调用服务发生前的调用拦截器，例如登录验证，ip黑白名单的拦截等；
route: 在请求服务时候被调用。这个能用于灰度发布，就是在我们跟新一个服务的可能会指定时间上线，没到时间不能使用；
post: 当 route 和 error 某一个拦截完成时 才会被调用拦截；
error： 这个很明显了错误拦截，出错拦截；

先创建一个简单路由——创建一个新的项目
创建一个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>cloud-csdn</artifactId><groupId>com.cloud.csdn</groupId><version>1.0-SNAPSHOT</version></parent><modelVersion>4.0.0</modelVersion><groupId>com.cloud.csdn</groupId><artifactId>cloud-consul-csdn-zuul927X</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.cloud</groupId><artifactId>spring-cloud-starter-netflix-zuul</artifactId></dependency><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-consul-discovery</artifactId></dependency><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-netflix-ribbon</artifactId></dependency></dependencies></project>

主启动类

package com.cloud.csdn;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.netflix.zuul.EnableZuulProxy;
@SpringBootApplication
@EnableDiscoveryClient
@EnableZuulProxy
public class ZuulApplication {public static void main(String[] args) {SpringApplication.run(ZuulApplication.class, args);}
}

yaml 配置

spring:profiles:active: zuul9270
---
spring:profiles: zuul9270application:name: zuulcloud:consul:host: 192.168.0.100:9100discovery:prefer-ip-address: trueip-address: 192.168.0.104
zuul:routes:payment:path: /payment/**# 这里配置你需要代理的并注册到注册中心名serviceId: consumer9101
server:port: 9270

通过上述配置后你能得到的访问路劲就变成了 http://网关的IP:9270/payment/controller的配置名
下面说下自定义的过滤器继承 ZuulFilter这个是过滤类

package com.cloud.csdn.filter;import com.cloud.csdn.common.utils.IpUtiles;
import com.netflix.zuul.ZuulFilter;
import com.netflix.zuul.context.RequestContext;
import com.netflix.zuul.exception.ZuulException;
import org.springframework.context.annotation.Configuration;//Ip地址拦截
public class IpFliter extends ZuulFilter {public String filterType() {return "pre"; //pre   route post error}public int filterOrder() {return 1;}public boolean shouldFilter() {return true;}public Object run() throws ZuulException {RequestContext requestContext=RequestContext.getCurrentContext();String ip= IpUtiles.getIpAddress(requestContext.getRequest());if(ip==null || ip.equals("")){//这个设定不在向下请求System.out.println("由于我的设定这个方法永远不会被触发");requestContext.setSendZuulResponse(false);return null;}return "";}
}

filterType： 这个方法用来定义过滤器的类型
filterOrder： 这个方法用来定义你的过滤器的有限级越小越先
shouldFilter： 是不是需要执行这个过滤器false 则不执行
run: 过滤的方法逻辑实现，通过setSendZuulResponse来设置是否调用服务为false则是不调用；当出现多个自定义过滤器时他们之间的数据传递是通过 RequestContext 类来完成；
最后创建配置类配置上面类的bean

Gateway 路由网关

Gateway 网关与zuul的区别？
zuul：使用阻塞式api,不支持长连接，使用的servlet 底层实现，不支持异步；
Gateway: 这个框架的出生是为了替换 zuul 1.X ，使用非阻塞式api ,不能和传统的servlet 一起使用，基于spring 5.0+spring boot2.0 和project reactor使用netty的底层环境
三大核心概念：Route (路由)，predicate (断言)， Filter(过滤)
Route(路由)： 顾名思义就是代理地址，就是由ID，目标的URI的地址通过判断断言和过滤器等如果判断为true;则通过路由访问到代理的地址
predicate(断言)：断言实际就是一个代理，当我们请求的路径与断言相同则访问断言的代理的服务地址
Filter(过滤)：过滤工厂GatewayFilter 类一共31种配置yml中即可，使用GlobalFilter 设置自定义过滤

创建gateway 案例

创建一个简单的案例作为例子后面会围绕例子来书写

<?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>cloud-csdn</artifactId><groupId>com.cloud.csdn</groupId><version>1.0-SNAPSHOT</version></parent><modelVersion>4.0.0</modelVersion><groupId>com.cloud.csdn</groupId><artifactId>cloud-consul-csdn-gateway957X</artifactId><build><plugins><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-compiler-plugin</artifactId><configuration><source>8</source><target>8</target></configuration></plugin></plugins></build><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-actuator</artifactId></dependency><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-gateway</artifactId></dependency><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-consul-discovery</artifactId></dependency></dependencies>
</project>

主启动类

package com.cloud.csdn;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
@SpringBootApplication
@EnableDiscoveryClient
public class GatewayApplication {public static void main(String[] args) {SpringApplication.run(GatewayApplication.class, args);}
}

添加yml 配置

spring:profiles:active: dev
---
spring:profiles: devapplication:name: gatewayservercloud:consul:host: 192.168.0.100:9100discovery:prefer-ip-address: truegateway:routes:- id: consumer9101uri: lb://consumer9101
server:port: 9527

上面就是一个简单的案例yml中的配置id 可以随便写只要保证唯一就行,uri的lb://是注册在注册中心的名字

断言的配置

断言在官方文档种有很多的方式共11种,上面的简单案例也是断言的方式
1.The After Route Predicate Factory:其实这个意思就是在条件之后
例如:

spring:application:name: gatewayservercloud:consul:host: 192.168.0.100:9100discovery:prefer-ip-address: truegateway:routes:- id: consumer9101uri: lb://consumer9101predicates:- After=2021-10-11T14:00:47.789+08:00[Asia/Shanghai] #在这个时间之前请求这个网段的地址是无效的,在这个时间段后是有效的

上面的配置文件里After后面的值必须是根据zonedDateTime 转化出来的这个需要注意一下
2.The Before Route Predicate Factory:上面是在什么时间之后那这个就是在什么时间之前生效
例如:

spring:application:name: gatewayservercloud:consul:host: 192.168.0.100:9100discovery:prefer-ip-address: truegateway:routes:- id: consumer9101uri: lb://consumer9101predicates:- Before=2021-10-11T14:00:47.789+08:00[Asia/Shanghai] #在这个时间之前请求这个网段的地址是有效的,在这个时间段后是无效的

上面的例子就是在这个时间之前是可以生效,就有的点我们使用的redis 給一个过期值,当然我们可以使用After 和Before 连用产生一个时间段
3.The Between Route Predicate Factory:这个就是在一个时间段里生效

spring:profiles: devapplication:name: gatewayservercloud:consul:host: 192.168.0.100:9100discovery:prefer-ip-address: truegateway:routes:# - id: consumer9101#  uri: lb://consumer9101#   predicates:#  - After=2021-10-11T14:00:47.789+08:00[Asia/Shanghai] #在这个时间之前请求这个网段的地址是无效的#  - Before=2021-10-11T14:05:47.789+08:00[Asia/Shanghai] #在这个时间之后此网段失效- id: consumer9102    # 设置第二个路由代理和断言uri: lb://consumer9101predicates:- Path=/say- Between=2021-10-11T21:15:47.789+08:00[Asia/Shanghai],2021-10-11T21:45:47.789+08:00[Asia/Shanghai]  #在这个时间段内生效

4.The Cookie Route Predicate Factory:请求需要带一个Cookie 和断言的条件一样即可生效,这个cookie 的名字自定义的,但是后面的值可以是一个字符串或者是一个正则表达式,我的案例给的是一个字符,你可以自己长是正则,实际开发一般都会使用正则
例如:

spring:profiles: devapplication:name: gatewayservercloud:consul:host: 192.168.0.100:9100discovery:prefer-ip-address: truegateway:routes:- id: consumer9101uri: lb://consumer9101predicates:- Path=/say- After=2021-10-11T14:00:47.789+08:00[Asia/Shanghai] #在这个时间之前请求这个网段的地址是无效的- Before=2021-10-11T14:05:47.789+08:00[Asia/Shanghai] #在这个时间之后此网段失效- id: consumer9102    # 设置第二个路由代理和断言uri: lb://consumer9101predicates:- Path=/say- Between=2021-10-11T21:15:47.789+08:00[Asia/Shanghai],2021-10-11T21:45:47.789+08:00[Asia/Shanghai]  #在这个时间段内生效- Cookie=whj,123

从上述案例中知道设置了Cookie为whj=123 那么他的请求就需要带上此cookie
5.The Header Route Predicate Factory:设置指定的请求头

# 上面的案例不动添加
- Header= x-request-id,1 # 同样的道理就是在请求的时候在上这个条件

6.The Host Route Predicate Facoty: 这个也是浏览器请求的一个条件的增加 配置这个就是有他才能生效

# 上面的案例不动添加
- Host= www.whj.com # 同样的道理就是在请求的时候在上这个条件

7.The Method Route Predicate Factory:指定路由被请求的方法类型GET,POST, PUT 等指定由该路由只能使用指定的请求方式被请求

# 上面的案例不动添加- Method=POST,GET

8.The Path Route Predicate Factory:指定路径

# 上面的案例不动添加- Path=/say # 当此设定设置以后只能访问指定的路径(但是实际开发一般是填项目的上下文的名称)

9.The Query Route Predicate Factory: 指定传递的参数 指定是k,v.v可以为字符或者正则

 - Query=num,\d # 意思就是访问的请求需要加上num 这个参数,参数值为数字. 

10.The RemoteAddr Route Predicate Factory:指定远程请求的地址

 - RemoteAddr=192.168.0.105 # 意思就是访问的请求时指定访问的IP 

11.The Weight Route Predicate Factory: 访问权重,当同一地址配置不过这个配置用的地方非常的少

Filter 过滤器

GateWay 的过滤器这里面有很多的过滤gatewayFilter 工厂一共 有31种类型我这边讲几种其他我觉自己去看一下其实也很简单:
1.添加请求头过滤工厂:AddRequestHeader

    filters:- AddRequestHeader=x-header-id,1

2.添加请求参数: AddRequestParameter 就是类似于在请求的后面加上参数的请求但是注意着是在没有给参数的情况下配置这个就相当于给了个默认值,如果在请求中书写了参数会覆盖这个配置的参数配置于上述几乎相同
3.添加响应请求头:AddResponseHeader这个配置就是当请求响应的时候添加一个头部的响应信息
4.hystrix 断路器的过滤:这个过滤其实一样的就是当我们的访问超时出错他都会返回一个指定的方法信息,他比我们在消费层单独使用hystrix 的好处是以可以把你的返回方法独立成一个来响应服务,还有就是在定义路由的时候可以对方法同一定义一个回退的方法并且返回的方法值类型可以与你的调用的方法不一样这是优势.缺点这个种方式只能使用简单的服务降级,如果使用熔断还是要在消费层使用注解.
优先级问题:在网关下配置了多个降级,优先级从上往下,如果在消费层和网关服务同时配置则网关覆盖一切
下面说一下两种配置方式一种是把回退的方法放在被代理路由的层第二种是独立出单独的服务或者指定回退方法的路由
第一种配置

spring:application:name: gatewayservercloud:consul:host: 192.168.0.100:9100discovery:prefer-ip-address: truegateway:routes:- id: gatewayuri: lb://consumer9101filters:- AddRequestHeader=x-header-id,1- AddRequestParameter=num,1- name: Hystrixargs:name: fallbackcmdfallbackUri: forward:/myCommandName

上面这个配置在你的consumer9101上书写一个controller 路径为/myCommandName的
第二种配置

spring:application:name: gatewayservercloud:consul:host: 192.168.0.100:9100discovery:prefer-ip-address: truegateway:routes:- id: gatewayuri: lb://consumer9101filters:- AddRequestHeader=x-header-id,1- AddRequestParameter=num,1- name: Hystrixargs:name: fallbackcmdfallbackUri: forward:/myCommandName- id: ingredients-fallbackuri: lb://fallback01predicates:- Path=/myCommandName

这个就是定义一个fallback01到注册中心并且由/myCommandName 的路径
这个gateway的过滤器工厂介绍到这后面自己去翻翻文档很简单的 gateway文档

自定义一个过滤器

package com.cloud.csdn.filter;import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.http.HttpStatus;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
public class LoginFilter implements GlobalFilter, Ordered {
//这个就是过滤器的逻辑实现方法可以通过ServerWebExchange 来实现获取请求的消息也是通过这个类来完成过滤器与过滤器之前的信息的传递public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {if(exchange.getAttribute("Cookie")!=null||exchange.getAttribute("Cookie")!=""){System.out.println("别走被拦驾");exchange.getResponse().setStatusCode(HttpStatus.INTERNAL_SERVER_ERROR);return exchange.getResponse().setComplete();}return chain.filter(exchange);}//假设有很多的自定义的过滤器形成过滤链通过设置数字来确定过滤链的先后顺序@Overridepublic int getOrder() {return 0;}
}

配置中心spring-cloud-config

spring-cloud-config:从名称看出这个是个配置服务，当我们的项目足够的大时候我们可能会使用很多微服务，很多个微服务之间又有很多的集群这时候我们的数据库从一个端口被迁移那么我们要是去修改配置文件那实在有点灾难了，还有我们的数据库库配置也有可能不是我们去修改能不能提供一个外部的修改方式，这时候就有spring-cloud-config的诞生由他来帮我们处理公共的环境配置
配置一个简单的config 服务端口8888创建一个项目 并在coding上上传一个yml 得文件

   <dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-config-server</artifactId></dependency>

server:port: 8888
spring:application:name: configservercloud:config:discovery:service-id: configserverserver:git:# coding或者这其他的地址uri: https://e.coding.net/kobebryant41/spring-coud-config-211014/spring-cloud-csdn-config.git# 安全验证	username: wanghuajianbad@126.compassword: hh520whj# 搜索的文档search-paths: - spring-cloud-csdn-config# git 分支label: master
#eureka 注册中心的配置
eureka:instance:lease-expiration-duration-in-seconds: 20lease-renewal-interval-in-seconds: 20client:service-url:defaultZone: http://localhost:3001/eureka

主启动类

package com.cloud.csdn;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.config.server.EnableConfigServer;
@SpringBootApplication
//注入服务配置
@EnableConfigServer
public class CloudConfigCsdn {public static void main(String[] args) {SpringApplication.run(CloudConfigCsdn.class, args);}}

客户端在实际开发中只需要配置pom就可以了,我这里为了让他显示出来写个实体类来加载pom设置的值并返回对象检测是否配置生效

spring:profiles:active: consulConsumer9101
---
server:port: 9101
spring:profiles: consulConsumer9101application:name: consumer9101cloud:config:name: user # 这个地方要特别得注意也是跟人绝的坑uri: http://localhost:8888label: master
eureka:instance:lease-renewal-interval-in-seconds: 20lease-expiration-duration-in-seconds: 20prefer-ip-address: trueclient:service-url:defaultZone: http://localhost:3001/eureka

书写类来加载获取这个部分的值就不写了
上面就是一个简单你的config 服务端和客户端默认使用的都是git 还有的使用占位符,验证等这里介绍最简单的快速使用像解锁其他的功能参照官方:https://docs.spring.io/spring-cloud-config/docs/3.0.6-SNAPSHOT/reference/html/#_push_notifications_and_spring_cloud_bus

消息总线 spring-cloud-bus

这个框架在我个人开看来还是很坑的，个人觉得使用bus不如直接使用spring-cloud-stream为啥这么讲我先卖个关子。
在我们的spring-cloud-config 服务端项目中pom添加 spring-cloud-starter-config-server,客户端添加 spring-cloud-starter-config 多句嘴实际开发种config bus gateway 是可以放在一起的但是看你们架构是怎么设计了
案例： spring-cloud-config服务层

      <dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-bus-amqp</artifactId></dependency><!--下面这个坐标有的时候会出现缺包的情况，如果你也缺就加上一般只需要加上上面的就行--><dependency><groupId>org.springframework.amqp</groupId><artifactId>spring-amqp</artifactId><version>2.3.10</version></dependency>

配置文件添加对rabbitmq 的连接

spring:rabbitmq:host: 填写自己的rabbitmq服务器地址username: guestpassword: guestport: 端口
#暴露给总线的刷新点
management:endpoints:web:exposure:include: "*"

其他的跟上上面config-server 实例样
客户端案例：
pom 文件添加

      <dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-bus-amqp</artifactId></dependency><!--下面这个坐标有的时候会出现缺包的情况，如果你也缺就加上一般只需要加上上面的就行--><dependency><groupId>org.springframework.amqp</groupId><artifactId>spring-amqp</artifactId><version>2.3.10</version></dependency>

yml 文件添加对rabbitmq 的 连接和地址的暴露

spring:rabbitmq:host: 填写自己的rabbitmq服务器地址username: guestpassword: guestport: 端口
#暴露给总线的刷新点
management:endpoints:web:exposure:include: "*"

读取配置文件的改变测试我写在了controller

@RestController
@RefreshScope
public class UserController extends UserError {@Value("${User.name}")private String name;@Value("${User.age}")private String age;@GetMapping("getuser")public String getusettest(){return "user:"+name+",age: "+age;}}

就这样完成了简单总线的配置 注意使用总线或者更新配置的时候必须使用@RefreshScope 如果不使用这个注解是不会生效的，也就是当我们配置一个数据库的配置文件的时候如果我们想通过这种方式修改配置之文件并生效那么我们就需要在你修改的服务创建一个新的bean并使用@RefreshScope 来注释重写的datasoure 理论来讲是这样的这样就是增大开发的难度为啥这么讲本来配置的yml 使用自动 配置就可以了如果要使用 这个修改配置那就需要使用配置类，那么如果是小改动写少量的配置类也可以但是如果改动大的我建议直接重启算了，但是有人讲从太多服务，那么可以写一个springboot 的重启方法然后监听一个队列就可以实现全部重启

spring cloud stream

这是个什么东西？能解决什么问题？他是怎么和中间件工作的？
我的话总结就是消息中间件代理；当我们做项目升级或者项目的接口调用的话比如别人用的rabittmq 而我们用的是kafka 那这个时候可能就会同一消息中间需要修改，但是如果我们是用spring boot starter rabbitmq 这种我们代码就非常的耦合，也就是说只能使用这种中间件，想要使用其他的那么就需要修改代码这样就增加了开发成本，这个时候如果我们使用的是消息驱动的话只需要修改我们的配置文件的地址，只想需要修改的地址即可；
工作这个框架提供两个通道inputs outputs 这两个通道流一个向binders 层发起消息，并使用通道往外消费；然后绑定层设定绑定是RabbitMQ或者KafKa 目前只支持这两种

简单队列实例

创建一个简单队列实例在已有的项目基础上pom加入——RabbitMQ

        <dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-stream-rabbit</artifactId></dependency>

配置文件添加为

# 配置片段 关于这个功能的主要配置stream:binders:defaultRabbit:type: rabbitbindings: # 配置通道output:destination: studeycontext-type: text/plainbinder: defaultRabbitgroup: text  # 为了不让重复消费input:destination: studeycontext-type: text/plainbinder: defaultRabbitgroup: text

发送类 使用注解@EnableBinding(Source.class)

@EnableBinding(Source.class)
public class MessageSendImpl {@Resourceprivate MessageChannel output;public void out() {System.out.println("发送消息12");output.send(MessageBuilder.withPayload("你好王华健").build());}
}

监听使用@StreamListener() 这个注解；我们普通的都是监听队列实际这个是监听input通道所以他没有办法直接向监听队列一样当一个消费时另一个就无法消费了，要通过我们上述的配置文件中的设置group 这个分组属性来区分

@EnableBinding(Sink.class)
public class RabbitMqListen {/**
这里很多人写成Sink.INPUT 其实这个因为我们的类注解他有个自动识别通道
**/@StreamListener("input")public void getmessage(Message<String> message){System.out.println("接受消息： "+ message.getPayload());}}

上面的案例实际上除了使用注解还是用了source.class 和 sink.class 这两个类 为什么使用这个两个类
实际使用的时@Input(“input”) 和@ouput(“ouput”) 这个两个注解也可以自己书写这个类，这个两个注解的值对应的就是配置文件的input 和output;同样的如果这两个注解的只改变那么监听里的值也要改变，不改变就监听不到了，

应答队列

spring:cloud:stream:rabbit:bindings:input: # 主要放在监听的管道，也可以因为这里就是消费consumer:acknowledge_mode: MANUAL # 默认时AUTO

@EnableBinding(Sink.class)
public class RabbitMqListen {@StreamListener("input")public void getmessage(Message<String> message, @Header(AmqpHeaders.CHANNEL) Channel channel, @Header(AmqpHeaders.DELIVERY_TAG)long deli){System.out.println("接受消息： "+ message.getPayload());try {channel.basicAck(deli,true);} catch (IOException e) {e.printStackTrace();}}}

死信队列

还是利用上面的案例把配置文件改一下

spring:profiles:active: consulConsumer9101
---
spring:profiles: consulConsumer9101application:name: consumer9101cloud:rabbit:host: 192.168.0.100port: 5671stream:binders:defaultRabbit:type: rabbitbindings:output:destination: studeycontext-type: application/jsonbinder: defaultRabbitgroup: textinput:destination: studeycontext-type: application/jsonbinder: defaultRabbitgroup: textoutputdlx: #死信通道destination: exchangedlxcontext-type: application/jsoninputdlx: #死信消费通道destination: exchangedlxcontext-type: application/jsonrabbit:bindings:input:consumer:#acknowledge_mode: MANUALautoBindDlq: true #是否自动绑定死信队列deadLetterExchange: exchangedlx #死信交换机deadLetterQueueName: exchangedlx.dlqueueproducer:ttl: 2000
eureka:instance:lease-renewal-interval-in-seconds: 20lease-expiration-duration-in-seconds: 20prefer-ip-address: trueclient:service-url:defaultZone: http://localhost:3001/eureka
server:port: 9101

书写消息发送

@EnableBinding(Source.class)
public class MessageSendImpl {@Resourceprivate MessageChannel output;public void out() {System.out.println("发送消息12");output.send(MessageBuilder.withPayload("你好王华健").build());}
}

监听消息

@EnableBinding(Sink.class)
public class RabbitMqListen {@StreamListener("input")public void getmessage(Message<String> message){//为了监听死信且超时进入下一个队列try {Thread.sleep(5000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("接受消息： "+ message.getPayload());}
}

书写一个通道的接口

package com.cloud.csdn.config;
import org.springframework.cloud.stream.annotation.Input;
import org.springframework.cloud.stream.annotation.Output;
import org.springframework.messaging.MessageChannel;
import org.springframework.messaging.SubscribableChannel;
public interface DealQueue {String INPUT = "inputdlx";@Input(INPUT)SubscribableChannel input();String OUTPUT = "outputdlx";@Output(OUTPUT)MessageChannel output();
}

在书写监听死信发过来数据并消费

@EnableBinding(DealQueue.class)
public class DealListen {@StreamListener(DealQueue.INPUT)public void getmessage(Message<String> message){System.out.println("接受消息： "+ message.getPayload());}
}

我简单说连着三个队列想知道更多的自行查阅spring-cloud-stream 的rabbitMQ 文档

Spring cloud sleuth 链路

这个技术为啥出现，有什么作用？
我们在开发软件的时候我们会使用的微服务将系统分成若干的子系统（每一个子系统多可以独立运行），若干个子系统通过集群的方式架构成为一个庞大的系统集群，这时候就会有子系统之间的调用，而这种调用是存在在后台不好查看，这时候就可以通过链路来实现，子系统之间调用的关系；
简单的使用案例
首先在docker 中下载zipkin-server.jar 并启动9411这个端口 如下

 docker pull openzipkin/zipkin# 子使用docker 命令 启动docker run -d -p 9411:9411 openzipkin/zipkin

启动完成后在你的项目里添加pom配置

<!-- 这个坐标包含了sleuth和zipkin--><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-zipkin</artifactId></dependency>

接下来只需要配置你的项目的需要链路的yml

spring:zipkin:base-url: http://Ip:9411sleuth:sampler:probability: 1 #取值在0-1之间官方说是用来1就是100%提取的意思

当上述配置都完成了就可以实现简单的链路监控,地址是http://Ip:9411/Zipkin


到这里基本的我们在开发中常用的springcloud的集合框架我们就讲完了，后期我会在更新spring-cloud-alibaba;上述有不对的地方请私信我，我及时更正谢谢