springcloud Stream 消息驱动

最新推荐文章于 2022-07-24 23:54:21 发布

xkuna

最新推荐文章于 2022-07-24 23:54:21 发布

阅读量129

点赞数

分类专栏：微服务文章标签： stream eureka 分布式 java

本文链接：https://blog.csdn.net/xkuna/article/details/107990448

版权

微服务专栏收录该内容

22 篇文章 0 订阅

订阅专栏

1.概述

1.1是什么

一句话：屏蔽底层消息中间件的差异，降低切换成本，统一消息的编程模型

1.2stream为什么可以统一底层差异

Stream中的消息通信方式遵循了发布-订阅模式，也就是 Topic主题进行广播

在RabbitMQ就是Exchange，在Kafka中就是Topic

1.3Spring Cloud Stream标准流程套路

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

2.常用API 和注解

3.安装启动rabbitMQ

请查看我之前的博客：springcloud config 集成RabbitMQ 和消息总线Bus 实现服务配置实时刷新中的配置安装部分

4.案例

4.1 流程

此外，将所有的服务注册进eureka服务注册中心

4.2创建 Eureka服务注册中心7001

pom(版本控制都在父项目中，springboot版本 2.2.2.RELEASE springcloud版本 Hoxton.SR1 其他的自行选择)

 <dependencies>
        <!--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>

yml

server:
  port: 7001

eureka:
  instance:
    hostname: localhost #eureka服务端的实例名称
  client:
    register-with-eureka: false     #false表示不向注册中心注册自己。
    fetch-registry: false     #false表示自己端就是注册中心，我的职责就是维护服务实例，并不需要去检索服务
    service-url:
      #设置与Eureka server 交互的地址查询服务和注册服务都需要依赖这个地址。
      defaultZone: http://localhost:7001/eureka/ #单机版 指向自己

主启动类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

/**
 * @author Xkuna
 * @date 2020/7/22 15:32.
 */

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

4.3创建消息生产者8801

4.3.1 搭建项目基础

pom

<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>
        <!-- stream-rabbit驱动-->
        <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>

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地址

主启动类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

/**
 * @author Xkuna
 * @date 2020/8/13 11:22.
 */
@SpringBootApplication
@EnableEurekaClient
public class StreamMQMain8801 {
    public static void main(String[] args) {
        SpringApplication.run(StreamMQMain8801.class, args) ;
    }
}

4.3.2 创建service业务逻辑

先创建业务逻辑接口

/**
 * @author Xkuna
 * @date 2020/8/13 11:23.
 */
public interface IMessageProvider {
    public String send() ;
}

再创建其实现类

注意使用到的注解和 API 以及导包

此外，阅读@EnableBinding注解的源码发现该注解包含了@Configuration注解，众所周知，@Configuration注解包含了@Component注解，所以该实现类已经注入到ioc容器中

import org.springframework.cloud.stream.annotation.EnableBinding;
import org.springframework.cloud.stream.messaging.Source;    //注意导包
import org.springframework.messaging.MessageChannel;		//注意导包
import org.springframework.messaging.support.MessageBuilder;  //注意导包
import top.xkuna.springcloud.service.IMessageProvider;

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

/**
 * @author Xkuna
 * @date 2020/8/13 11:24.
 */
@EnableBinding(Source.class)//定义消息的推送管道
public class MessageProviderImpl implements IMessageProvider {
    @Resource
    private MessageChannel output ;// 消息发送管道
    @Override
    public String send() {
        //生成uuid
        String uuid = UUID.randomUUID().toString().replace("-", "" );
        System.out.println(uuid);
        //发送消息
        output.send(MessageBuilder.withPayload(uuid).build()) ;
        return uuid;
    }
}

4.3.3创建controller

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import top.xkuna.springcloud.service.IMessageProvider;

import javax.annotation.Resource;

/**
 * @author Xkuna
 * @date 2020/8/13 11:32.
 */
@RestController
public class SendMessageController {
    @Resource
    private IMessageProvider messageProvider ;
    @GetMapping("/send")
    public String send() {
        return messageProvider.send() ;
    }
}

4.4 创建消息消费者8802

4.4.1 搭建项目基础

pom

  <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <!-- stream-rabbitMQ驱动-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-stream-rabbit</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>

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 # 设置要绑定的消息服务的具体设置
          #group: GA  #分组  GA组



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: receive-8802.com  # 在信息列表时显示主机名称
    prefer-ip-address: true     # 访问的路径变为IP地址

主启动类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

/**
 * @author Xkuna
 * @date 2020/8/13 11:35.
 */
@SpringBootApplication
@EnableEurekaClient
public class StreamMQMain8802 {
    public static void main(String[] args) {
        SpringApplication.run(StreamMQMain8802.class, args) ;
    }
}

4.4.2创建controller

在这里我们就直接将接收到的消息输出到控制台

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;

/**
 * @author Xkuna
 * @date 2020/8/13 11:37.
 */
@EnableBinding(Sink.class) // 接收消息 用sink
public class ReceiveMessageListenerController {
    @Value("${server.port}")
    private String serverPort;
    @StreamListener(Sink.INPUT) //表明这是一个消息 监听输入通道
    //注意传入的Message 导的包
    public void input(Message<String> message) {
        
        System.out.println("消费者1号,----->接受到的消息: " + message.getPayload() + "\t port:" + serverPort);
    }
}

4.4.3 创建消息消费者 8803

copy一份消息消费者 8802

修改主启动类类名

修改yml 中的端口为 8803，注册进eureka的服务实例id 名称的8802修改为 8803

修改controller

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;


/**
 * @author Xkuna
 * @date 2020/8/13 11:37.
 */
@EnableBinding(Sink.class)
public class ReceiveMessageListenerController {
    @Value("${server.port}")
    private String serverPort;
    @StreamListener(Sink.INPUT)
    public void input(Message<String> message) {
        System.out.println("消费者2号,----->接受到的消息: " + message.getPayload() + "\t port:" + serverPort);
    }
}

此时项目搭建完成

4.4.5 测试

首先保证我们的rabbitMQ已经启动

然后依次启动 eureka7001 生产者8801 消费者8802 8803

连续访问两次 http://localhost:8801/send

查看控制台

8801

8802

8803

生产者成功发送两条消息，两个消费者也都成功接收到了两条消息

那么我们考虑一个问题：

假设消息生产者是一个订单微服务，消息消费者是两个支付微服务，此时买家下了一个订单（发送了一条支付消息），

按照我们上面的设计，两个支付微服务都收到支付消息，那么该买家的账户则会扣两次款。

如此，这样设计是绝对不可取的，那么该如何让若干的支付微服务中的一个微服务接收到信息并扣款呢？？

解决的方法就是分组，将所有的同一个业务的微服务放在一个组中:

在项目搭建的过程中，会发现消息消费者8802和8803的yml中，在配置bindings时,group参数注释掉了，将两个微服务的group参数取消注释，分在自定义名称的组中就可以了（在这里我设置的组名为GA）

此时我们重启消息消费者8802 和 8803

再次访问两次 http://localhost:8801/send

查看控制台

8801

8802

8803

如此，实现了我们上面的需求

但是，又有一个问题，如果消息生产者8801 发送了消息，而消息的消费者8802 8803 都宕机或者关机下线了怎么办？

其实，只要完成我们的分组，就可以避免这个问题了

我们此时关闭8802 和 8803

我们让8801 发送两次消息 http://localhost:8801/send

然后我们只启动8802

发现在跟8803同一组中的8802 上线时，会获取该组没有接收到的消息

此时再启动8803 肯定是没有8803 任何事情了。。。

查看控制台 8803 并没有收到任何消息

这里的分组就是把同一业务的所有微服务放在同一个组中，防止消息的重复消费，也防止微服务的消息收不到，业务无法继续执行的问题发生

xkuna

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
springcloud Stream 消息驱动

1.概述1.1是什么一句话：屏蔽底层消息中间件的差异，降低切换成本，统一消息的编程模型1.2stream为什么可以统一底层差异Stream中的消息通信方式遵循了发布-订阅模式，也就是 Topic主题进行广播在RabbitMQ就是Exchange，在Kafka中就是Topic1.3Spring Cloud Stream标准流程套路Binder：很方便的连接中间件，屏蔽差异Channel：通道，是队列Queue的一种抽象，在消息通讯系统中就是实现存储和转发的媒介，通过Channel对
复制链接

扫一扫