Spring Cloud Stream(消息驱动)扫盲知识

最新推荐文章于 2024-07-15 09:47:21 发布

黑夜中坚持

最新推荐文章于 2024-07-15 09:47:21 发布

阅读量250

点赞数

分类专栏： springCloud全家桶及相关理论知识文章标签： java stream 微服务

本文链接：https://blog.csdn.net/qq_26496077/article/details/110746652

版权

springCloud全家桶及相关理论知识专栏收录该内容

21 篇文章 1 订阅

订阅专栏

消息驱动是什么
屏蔽底层消息中间件的差异,降低切换成本,统一消息的编程模型.
Spring Cloud Stream定义
原始普通的MQ(消息队列)

生产者、消费者之间靠消息(Message)媒介传递消息内容
消息必须走特定的通道(MessageChannel)
消息通道中的消息如何被消费以及谁负责收发处理: 消息通道MessageChannel的子接口SubscribableChannel,由MessageHandler消息处理器所订阅

Spring Cloud Stream出现背景
Spring Cloud Stream如何统一底层差异
一句话: 通过定义绑定器Binder作为中间层,实现了应用程序与消息中间件细节之间的隔离.
Spring Cloud Stream处理架构
Binder绑定器
Spring Cloud Stream的消息通信方式
发布-订阅模式.使用Topic主题(RabbitMQ中即Exchange,Kakfa中即Topic)进行广播.
Spring Cloud Stream标准流程套路

Binder: 方便的连接中间件,屏蔽差异
Channel: 通道,是队列Queue的一种抽象,在消息通讯系统中就是实现存储和转发的媒介,通过Channel对队列进行配置.
Source和Sink:简单的可以理解为Spring Cloud Stream自身,从Stream发布消息就是输出,接受消息就是输入.

编程API和常用注解
Spring Cloud Stream的消息重复消费问题
场景: 订单系统做集群部署,都会从RabbitMQ中获取订单信息,如果一个订单同时被两个服务获取到,那么就会造成数据错误,为了避免这种情况,我们可以使用Stream中的消息分组来解决.

在Stream中不同组是可以重复消费的.同一组内会发生竞争关系,只有其中一个可以消费.
解决重复消费问题的方法: 将重复消费的服务分到同一个组.
Spring Cloud Stream消息的持久化
消费者设置分组后,关闭消费者服务,查看RabbitMQ的Web后台，发现Exchange分组的Queue，并没有被删除
当provider发送消息，消息继续发送到了Exchange分组中启动消费者服务，发现消费者服务能够消费到服务未启动时提供者发送的消息说明具有消息持久化的效果.
　　注：消费者未设置分组时，关闭消费者服务，对应的queue会被删除，那么provider发送的消息就无法持久化,消费者启动后无法消费到未启动时provider发送的消息.
代码实现

provider消息生产者
pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>cloud2020</artifactId>
        <groupId>com.atguigu.springcloud</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>cloud-stream-rabbitmq-consumer8801</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-eureka-client</artifactId>
        </dependency>
        <!--        spring cloud stream消息驱动-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-stream-rabbit</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>

application.xml

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:
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka   #集群版
  instance:
    lease-renewal-interval-in-seconds: 2      # 心跳间隔时间（默认30s）
    lease-expiration-duration-in-seconds: 5   # eureka服务端在收到最后一次心跳后等待时间上限，单位为s，默认90s，超时将剔除服务
    instance-id: send-8801.com               # 信息列表显示的主机名称
    prefer-ip-address: true                   # 访问的路径变为ip地址

controller层

package com.atguigu.springcloud.controller;
import com.atguigu.springcloud.service.IMessageProvider;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;

@RestController
public class sendMessageController {
    @Resource
    private IMessageProvider messageProvider;

    @GetMapping("/sendMessage")
    public String sendMessage(){
        return messageProvider.send();
    }
}

service接口

package com.atguigu.springcloud.service;
public interface IMessageProvider {
    String send();
}

service实现类

package com.atguigu.springcloud.service.impl;
import com.atguigu.springcloud.service.IMessageProvider;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.stream.annotation.EnableBinding;
import org.springframework.cloud.stream.messaging.Source;
import org.springframework.integration.support.MessageBuilder;
import org.springframework.messaging.MessageChannel;
import javax.annotation.Resource;
import java.util.UUID;

// @EnableBinding作用：将管道channel和exchange绑定到一起
// 定义消息的推送管道,生产者这是Source(源，生产水)，消费者这是Sink(水槽，盛水)
@EnableBinding(Source.class)
@Slf4j
public class MessageProviderImpl implements IMessageProvider {
    @Resource
    private MessageChannel output;       // 消息发送管道

    @Override
    public String send() {
        String serial = UUID.randomUUID().toString();
        // send(): 将消息发送到channel中
        // MessageBuilder： 默认的消息构建器
        // withPayload()参数是需要发送的消息
        // 调用build()方法产生一个Message对象
        output.send(MessageBuilder.withPayload(serial).build());
        log.info("******serial: " + serial);
        return null;
    }
}

主启动类为最简单的,没有添加任何注解,不再写.

consumer1
pom.xml和provider基本一样
application.xml

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             # 设置要绑定的消息服务的具体设置
          group: atguiguA                   # 微服务分组，同一个组只能有一个服务消费，不同组可以重复消费

eureka:
  client:
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka   #集群版
  instance:
    lease-renewal-interval-in-seconds: 2      # 心跳间隔时间（默认30s）
    lease-expiration-duration-in-seconds: 5   # eureka服务端在收到最后一次心跳后等待时间上限，单位为s，默认90s，超时将剔除服务
    instance-id: send-8802.com               # 信息列表显示的主机名称
    prefer-ip-address: true                   # 访问的路径变为ip地址

controller层

package com.atguigu.springcloud.controller;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.stream.annotation.EnableBinding;
import org.springframework.cloud.stream.annotation.StreamListener;
import org.springframework.cloud.stream.messaging.Sink;
import org.springframework.messaging.Message;
import org.springframework.stereotype.Component;

@Component
// 消费者这时Sink(中文水槽，盛水),生产者这是Source(源头，生产水)
@EnableBinding(Sink.class)
@Slf4j
public class ReceiveMessageListenerController {

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

    // 监听队列，用于消费者队列的消息接收
    @StreamListener(Sink.INPUT)
    public void input(Message<String> message){
        log.info("消费者1号，------>接收到的消息：" + message.getPayload() + "\t port: " + serverPort);
    }
}

consumer2和consumer1基本一样

黑夜中坚持

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring Cloud Stream(消息驱动)扫盲知识

消息驱动是什么屏蔽底层消息中间件的差异,降低切换成本,统一消息的编程模型.Spring Cloud Stream定义原始普通的MQ(消息队列)生产者、消费者之间靠消息(Message)媒介传递消息内容消息必须走特定的通道(MessageChannel)消息通道中的消息如何被消费以及谁负责收发处理: 消息通道MessageChannel的子接口SubscribableChannel,由MessageHandler消息处理器所订阅Spring Cloud Stream出现..
复制链接

扫一扫

专栏目录