SpringCloud Stream+RabbitMQ自定义通道

最新推荐文章于 2024-09-14 17:52:16 发布
最新推荐文章于 2024-09-14 17:52:16 发布
阅读量3.4k 收藏 9
点赞数
分类专栏： SpringCloud
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mameng1988/article/details/83901475
版权

SpringCloud Stream默认的消息生产通道和消费通道分别是output和input，我们也可以自定义消息生产通道和消费通道；下面对这一过程进行记录。

1 父maven工程

1.1 工程结构如下：

在这里插入图片描述

1.2 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">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.study</groupId>
  <artifactId>cloud-ma</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>pom</packaging>
  <name>SpringCloudStudy</name>
  <description>SpringCloudStudy</description>

  <!-- 私有仓库的配置 -->
  <repositories>          
    <repository>            
        <id>nexus</id> <!-- 和setting.xml中配置的id保持一致 -->           
        <url>http://xxx.xxx.xxx.xxx:xxxx/repository/maven-public/</url>            
        <releases>
            <enabled>true</enabled>
        </releases>           
        <snapshots>
            <enabled>true</enabled>
        </snapshots>          
      </repository>               
   </repositories>

  <parent>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-parent</artifactId>
     <version>2.0.3.RELEASE</version>
     <relativePath/>
  </parent>

  <properties>
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
     <java.version>1.8</java.version>
     <spring-cloud.version>Finchley.RELEASE</spring-cloud.version>
  </properties>

  <dependencies>

    <!-- 上边引入 parent，因此 下边无需指定版本 -->
        <!-- 包含 mvc,aop 等jar资源 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <exclusions>
                <exclusion><!-- 去除默认log配置 -->
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <!-- 配置log4j2 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-log4j2</artifactId>
        </dependency>
        <!-- 配置log4j2 -->

        <!-- 支持识别yml配置 -->
        <dependency>
            <groupId>com.fasterxml.jackson.dataformat</groupId>
            <artifactId>jackson-dataformat-yaml</artifactId>
        </dependency>
        <!-- 支持识别yml配置 -->

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

    <!-- 热部署 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <optional>true</optional>
        <scope>true</scope>
    </dependency>

    <!--开始  阿里的fastjson  -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.51</version>
    </dependency>
    <!--结束  阿里的fastjson  -->

  </dependencies>

  <dependencyManagement>
      <dependencies>
          <dependency>
              <groupId>org.springframework.cloud</groupId>
              <artifactId>spring-cloud-dependencies</artifactId>
              <version>${spring-cloud.version}</version>
              <type>pom</type>
              <scope>import</scope>
          </dependency>
      </dependencies>
  </dependencyManagement>

  <build>
     <plugins>
         <plugin>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-maven-plugin</artifactId>
             <configuration>
                    <!-- 没有该配置，devtools 不生效 -->
                    <fork>true</fork>
             </configuration>
         </plugin>
     </plugins>
  </build>


  <modules>
      <module>EurekaServer</module>
      <module>EurekaClientHi</module>
    <module>EurekaClientRibbonCustomer</module>
    <module>EurekaClientHi2</module>
    <module>EurekaClientFeignCustomer</module>
    <module>EurekaClientZuul</module>
    <module>config_server</module>
    <module>config-client</module>
    <module>config-server-svn</module>
    <module>config-client-svn</module>
    <module>StreamProvider</module>
    <module>stream-output</module>
    <module>stream-input</module>
    <module>StreamRabbitMQSelf</module>
  </modules>
</project>

2 StreamRabbitMQSelf工程

2.1 工程结构

在这里插入图片描述

2.2 该工程的pom.xml

<?xml version="1.0"?>
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>com.study</groupId>
    <artifactId>cloud-ma</artifactId>
    <version>0.0.1-SNAPSHOT</version>
  </parent>
  <artifactId>StreamRabbitMQSelf</artifactId>
  <name>StreamRabbitMQSelf</name>
  <url>http://maven.apache.org</url>
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>
  <dependencies>
  
     <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-stream-rabbit</artifactId>
    </dependency>
  
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <scope>test</scope>
    </dependency>
  </dependencies>
</project>

2.3 自定义消息通道

2.3.1 消息生产通道

新建一个接口，这个接口中可以定义多个管道用来发送消息，可以实现向不同的exchange发送消息。

/**
 * 
 */
package com.StreamRabbitMQSelf.rabbitMQ.channels;

import org.springframework.cloud.stream.annotation.Output;
import org.springframework.messaging.MessageChannel;

/**
 * @author mazhen
 *
 */
public interface SendOutputChannel {
	// 这里可以定义不同的通道
    String MSG_SENDER = "msgSender"; // 通道名
    
    @Output(SendOutputChannel.MSG_SENDER)
    MessageChannel msgSender();
    
}

2.3.2 消息消费通道

新建一个接口，这个接口中可以定义多个管道用来消费消息，可以实现从不同的exchange消费消息。

/**
 * 
 */
package com.StreamRabbitMQSelf.rabbitMQ.channels;

import org.springframework.cloud.stream.annotation.Input;
import org.springframework.messaging.SubscribableChannel;

/**
 * @author mazhen
 *
 */
public interface ReceiveInputChannel {
	// 这里可以定义不同的通道
	String MSG_RECEIVER = "msgReceiver"; // 通道名

	@Input(ReceiveInputChannel.MSG_RECEIVER)
	SubscribableChannel msgReceiver();
	
}

2.4 application.yml

server:
  port: 8086
spring:
  cloud:
    stream:
      binders: 
        defaultRabbit: 
          type: rabbit
          environment:                                      #配置rabbimq连接环境
            spring: 
              rabbitmq:
                host: xxx.xxx.xxx.xxx
                username: xxx
                password: xxx
                virtual-host: / 
      bindings: 
        msgSender:                                          #生产者绑定，这个是消息通道的名称
          destination: message-exchange                     #exchange名称，交换模式默认是topic
          content-type: application/json
        msgReceiver:                                        #消费者绑定 这个是接受消息通道的名称
          group: for-all                                    #持久化, 也就是指定队列名称，等同于rabbitmq中的 queue, 同一个服务不同的实例，使用相同的队列名称，处理消息                                   
          destination: message-exchange                     #和生产者的消息交换机要相同
          content-type: application/json 
          consumer: 
            max-attempts: 3                                 # The number of attempts to process the message (including the first) in the event of processing failures,Default: 3
            concurrency: 1                                  # The concurrency setting of the consumer. Default: 1.   
      rabbit: 
        bindings: 
          msgReceiver: 
            consumer: 
              max-concurrency: 4                            # maxumum concurrency of this consumer (threads)
              prefetch: 5                                   # number of prefetched messages pre consumer thread
              requeue-rejected: false                       # true to requeue rejected messages, false to discard (or route to DLQ)
              republish-to-dlq: true                        # republish failures to the DLQ with diagnostic headers

2.5 消息生产和消费类

2.5.1 消息生产和消费类–接口

/**
 * 
 */
package com.StreamRabbitMQSelf.rabbitMQ.service;

import org.springframework.messaging.Message;

/**
 * @author mazhen
 * 消息生产类--接口
 */
public interface SendMessage {
	 
	 public void sendMsgStr(String str);
}


/**
 * 
 */
package com.StreamRabbitMQSelf.rabbitMQ.service;

import org.springframework.messaging.Message;

/**
 * @author mazhen
 * 消息消费类--接口
 */
public interface ReceviveMessage {
	public void receiveStr(Message<String> message);
}

2.5.2 消息生产和消费类–实现类

/**
 * 
 */
package com.StreamRabbitMQSelf.rabbitMQ.service.impl;

import java.util.concurrent.TimeUnit;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.stream.annotation.EnableBinding;
import org.springframework.integration.support.MessageBuilder;
import org.springframework.messaging.Message;

import com.StreamRabbitMQSelf.rabbitMQ.channels.SendOutputChannel;
import com.StreamRabbitMQSelf.rabbitMQ.service.SendMessage;


/**
 * @author mazhen
 * 消息生产实现类
 */
@EnableBinding(SendOutputChannel.class)
public class SendMessageImpl implements SendMessage {
    
	/**
	 * 引入日志，注意都是"org.slf4j"包下
	 */
	private final static Logger logger = LoggerFactory.getLogger(SendMessageImpl.class);
	
	@Autowired
    private SendOutputChannel sendOutputChannel;

	@Override
	public void sendMsgStr(String str) {
		if (!sendOutputChannel.msgSender().send(MessageBuilder.withPayload(str).build())) {
			 logger.error("生产者消息发送失败：" + str);
		}
		logger.info("[sendMsgStr]生产者消息发送:"+str);
	}

}


/**
 * 
 */
package com.StreamRabbitMQSelf.rabbitMQ.service.impl;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.cloud.stream.annotation.EnableBinding;
import org.springframework.cloud.stream.annotation.StreamListener;
import org.springframework.messaging.Message;

import com.StreamRabbitMQSelf.model.CdkeyParameter;
import com.StreamRabbitMQSelf.rabbitMQ.channels.ReceiveInputChannel;
import com.StreamRabbitMQSelf.rabbitMQ.service.ReceviveMessage;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;

/**
 * @author mazhen
 * 消息消费实现类
 */
@EnableBinding(ReceiveInputChannel.class)
public class ReceviveMessageImpl implements ReceviveMessage {

	/**
	 * 引入日志，注意都是"org.slf4j"包下
	 */
	private final static Logger logger = LoggerFactory.getLogger(ReceviveMessageImpl.class);
	
	@Override
	@StreamListener(ReceiveInputChannel.MSG_RECEIVER)
	public void receiveStr(Message<String> message) {
		
		String s = message.getPayload();
		logger.info("[receiveStr]消息接收："+s);
		logger.info("[receiveStr]消息接收处理："+JSONObject.parseObject(s).getString("data"));
		
		CdkeyParameter cdkeyParameter = JSON.parseObject(JSONObject.parseObject(s).getString("data"), CdkeyParameter.class);
		logger.info("CdkeyParameter的参数："+cdkeyParameter.getVersion());
	}

}

2.6 启动类

package com.StreamRabbitMQSelf;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * 启动类
 *
 */
@SpringBootApplication
public class StreamRabbitMQSelfApplication {
    public static void main( String[] args ) {
       SpringApplication.run(StreamRabbitMQSelfApplication.class, args);
    }
}

2.7 其他

2.7.1 ParameterUtil

/**
 * 
 */
package com.StreamRabbitMQSelf.utils.common;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import javax.servlet.http.HttpServletRequest;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;


/**
 * @author mazhen
 * 获取post请求中的body内容
 */
public class ParameterUtil {

	public static String getParametersStr(HttpServletRequest request) throws IOException {
		//从request中以"UTF-8"形式获取输入流，避免中文乱码
		BufferedReader br = new BufferedReader(new InputStreamReader(request.getInputStream(),"UTF-8"));
		StringBuffer sb = new StringBuffer("");
		String temp;
		//一行一行读取并放入到StringBuffer中
		while((temp = br.readLine()) != null){
			sb.append(temp);
		}
		br.close();
		String acceptjson = sb.toString();
		return acceptjson;
	}
	
}

2.7.2 CdkeyParameter

package com.StreamRabbitMQSelf.model;

import java.util.Date;

public class CdkeyParameter {
    private Long id;

    private String telephone;

    private String cdkey;

    private Short messageStatus;

    private Short billStatus;

    private Date timeStamp;

    private String encode;

    private String version;

    private Short channel;

    private Short flowType;

    private Short flowSize;

    private Date rechargeTime;

    private String memberType;

    private String method;

    private String serialNumber;

    private String orderCodeWo;

    private String orderCode;

    private Short rechargeState;

    private Date createTime;

    private Date updateTime;

    private String flag1;

    private String flag2;

    private Integer flag3;

    private Integer flag4;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getTelephone() {
        return telephone;
    }

    public void setTelephone(String telephone) {
        this.telephone = telephone == null ? null : telephone.trim();
    }

    public String getCdkey() {
        return cdkey;
    }

    public void setCdkey(String cdkey) {
        this.cdkey = cdkey == null ? null : cdkey.trim();
    }

    public Short getMessageStatus() {
        return messageStatus;
    }

    public void setMessageStatus(Short messageStatus) {
        this.messageStatus = messageStatus;
    }

    public Short getBillStatus() {
        return billStatus;
    }

    public void setBillStatus(Short billStatus) {
        this.billStatus = billStatus;
    }

    public Date getTimeStamp() {
        return timeStamp;
    }

    public void setTimeStamp(Date timeStamp) {
        this.timeStamp = timeStamp;
    }

    public String getEncode() {
        return encode;
    }

    public void setEncode(String encode) {
        this.encode = encode == null ? null : encode.trim();
    }

    public String getVersion() {
        return version;
    }

    public void setVersion(String version) {
        this.version = version == null ? null : version.trim();
    }

    public Short getChannel() {
        return channel;
    }

    public void setChannel(Short channel) {
        this.channel = channel;
    }

    public Short getFlowType() {
        return flowType;
    }

    public void setFlowType(Short flowType) {
        this.flowType = flowType;
    }

    public Short getFlowSize() {
        return flowSize;
    }

    public void setFlowSize(Short flowSize) {
        this.flowSize = flowSize;
    }

    public Date getRechargeTime() {
        return rechargeTime;
    }

    public void setRechargeTime(Date rechargeTime) {
        this.rechargeTime = rechargeTime;
    }

    public String getMemberType() {
        return memberType;
    }

    public void setMemberType(String memberType) {
        this.memberType = memberType == null ? null : memberType.trim();
    }

    public String getMethod() {
        return method;
    }

    public void setMethod(String method) {
        this.method = method == null ? null : method.trim();
    }

    public String getSerialNumber() {
        return serialNumber;
    }

    public void setSerialNumber(String serialNumber) {
        this.serialNumber = serialNumber == null ? null : serialNumber.trim();
    }

    public String getOrderCodeWo() {
        return orderCodeWo;
    }

    public void setOrderCodeWo(String orderCodeWo) {
        this.orderCodeWo = orderCodeWo == null ? null : orderCodeWo.trim();
    }

    public String getOrderCode() {
        return orderCode;
    }

    public void setOrderCode(String orderCode) {
        this.orderCode = orderCode == null ? null : orderCode.trim();
    }

    public Short getRechargeState() {
        return rechargeState;
    }

    public void setRechargeState(Short rechargeState) {
        this.rechargeState = rechargeState;
    }

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    public Date getUpdateTime() {
        return updateTime;
    }

    public void setUpdateTime(Date updateTime) {
        this.updateTime = updateTime;
    }

    public String getFlag1() {
        return flag1;
    }

    public void setFlag1(String flag1) {
        this.flag1 = flag1 == null ? null : flag1.trim();
    }

    public String getFlag2() {
        return flag2;
    }

    public void setFlag2(String flag2) {
        this.flag2 = flag2 == null ? null : flag2.trim();
    }

    public Integer getFlag3() {
        return flag3;
    }

    public void setFlag3(Integer flag3) {
        this.flag3 = flag3;
    }

    public Integer getFlag4() {
        return flag4;
    }

    public void setFlag4(Integer flag4) {
        this.flag4 = flag4;
    }
}

2.7.3 TestController

/**
 * 
 */
package com.StreamRabbitMQSelf.controller;

import java.io.IOException;

import javax.servlet.http.HttpServletRequest;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import com.StreamRabbitMQSelf.rabbitMQ.service.SendMessage;
import com.StreamRabbitMQSelf.utils.common.ParameterUtil;



/**
 * @author mazhen
 *
 */
@RestController
public class TestController {
    
	/**
	 * 引入日志，注意都是"org.slf4j"包下
	 */
	private final static Logger logger = LoggerFactory.getLogger(TestController.class);
	
	@Autowired
	private SendMessage  sendMessage;
	
	@RequestMapping(value = "recevieCdkeyFrom",method = RequestMethod.POST)
	public String recevieCdkeyFrom(HttpServletRequest request){
		
		String jsonStr = null;
		try {
			jsonStr = ParameterUtil.getParametersStr(request);
			logger.info("----:"+jsonStr);
			sendMessage.sendMsgStr(jsonStr);
		} catch (IOException e) {
			logger.error("异常信息："+e);
			e.printStackTrace();
			return "IOException:"+e;
		}
		return jsonStr;
	}
	
}

3 测试

  • 启动RabbitMQ
  • 启动StreamRabbitMQSelf工程
  • 打开postman

通过postman测试：
在这里插入图片描述
控制台打印：
在这里插入图片描述
RabbitMQ的交换器：
在这里插入图片描述
RabbitMQ的消息队列：
在这里插入图片描述

欢迎关注我的微信公众号，不定期更新文章和大家一起学习共勉-在这里插入图片描述
mameng1998
关注
专栏目录
SpringCloudStream整合RabbitMq
09-04
spring-cloud之spring-cloud-stream，底层为rabbitmq实现，简单栗子，仅供参考。生产者、消费者配置及生产者、消费者代码实现。
介绍Spring Cloud Stream与RabbitMQ集成
王浩的技术博客
05-13 1万+
Spring Cloud Stream是一个建立在Spring Boot和Spring Integration之上的框架，有助于创建事件驱动或消息驱动的微服务。在本文中，我们将通过一些简单的例子来介绍Spring Cloud Stream的概念和构造。 1 Maven依赖 在开始之前，我们需要添加Spring Cloud Stream与RabbitMQ消息中间件的依赖。 &lt;de...
Spring Cloud Stream 入门与 RocketMQ 集成实践
最新发布
islautao的博客
09-14 818
是 Spring Cloud 生态系统中的一个子项目，专注于为构建基于消息驱动的微服务提供统一的编程模型。它通过抽象底层的消息中间件（如 Kafka、RabbitMQ、RocketMQ 等），帮助开发者更轻松地使用这些中间件，并专注于业务逻辑的实现，而不必担心具体的底层实现细节。通过 Spring Cloud Stream 与 RocketMQ 的集成，开发者可以简化消息驱动微服务的开发流程。
Spring Cloud Stream + RabbitMQ 消息生成和消息消费
lixiaxin200319的博客
10-02 5561
在本 DEMO中有两个节点互为消息的生产者和消息消费者。 一、节点1 1. pom.xml &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instanc...
RabbitMQ的stream流用法（output绑定消息到达处通道 / input获取并监听该通道的消息）
qq_25881443的博客
11-21 895
rabbitmq的stream绑定流
RabbitMQ - 快速入门（二）
陆氪和他的那些代码
04-11 805
使用stream发送和接收消息 1. 引入依赖 spring-cloud-starter-stream-rabbit 2. 配置 rabbitMq 3. 新建接口 StreamClient，分别定义 input() 和 output() 4. 接收端 5. 发送端 SpringCloud Stream 提供更方便的消息处理，达到代码层面对消息中间件的无感知的效果，支持 Rabb...
rabbitmq开发记录
weixin_43451374的博客
12-17 188
1.定义一个绑定类 public interface SyncSchoolBinding { String OUTPUT = "school-plan-center-syncSchool-output"; String INPUT = "school-plan-center-syncSchool-input"; /** * 消息订阅 * * @return 消息订阅 */ @Input(INPUT) Subscribable
消息中间件之RabbitMQ使用
Felix的小黑板
12-04 327
目录简介RabbitMQ生产者封装消费者封装父类消费者类 声明: 在本文以及本系列文中, 不会涉及公司内部相关内容,旨在能帮助到努力前进的人 本系列会依次涉及到ActiveMQ, RabbitMQ, kafka, RocketMQ 简介 什么是消息中间件? 一个进行消息传递的组件, 好比一个快递, 当你上网购买了一个东西, 传统方式是店家--------->顾客,也就是店家直接把东西...
(spring cloud stream 整合 rabbitmq , 自定义消息通道，既能发消息，)cloud-stream-rabbitmq-test.rar
06-26
在本项目"cloud-stream-rabbitmq-test"中，我们将探讨如何将Spring Cloud Stream与RabbitMQ整合，创建自定义的消息通道，以实现双向通信——既能发送消息，也能接收消息。 1. **Spring Cloud Stream基本概念**： -...
SpringCloudStreamAndRabbitMQ:SpringCloudStream整合RabbitMQ
04-27
###Spring Cloud Stream And RabbitMQ集成Demo ##provider为消息的提供者 ##consumer为消息的接受者 ###初始提交版本采用默认通道， ##加上自定义通道的版本 ##加上stream传输对象 ###TODO　最终版本做成一个日志...
spring cloud stream rabbitmq 资源
06-12
5. **发送消息**: 通过`MessageChannel`接口发送消息到输出通道，Spring Cloud Stream会自动将消息路由到对应的RabbitMQ队列。 了解这些基本概念后，我们可以进一步探讨RabbitMQ特定的功能，如交换机、队列、绑定和...
SpringCloud应用篇之SpringCloudStream（消息驱动）
01-27
接着，配置文件中设置`spring.cloud.stream.bindings.*.destination`，将输入和输出通道关联到RabbitMQ的特定主题。 接下来，定义消息通道绑定的接口，使用`@Input`和`@Output`注解声明输入和输出通道。不指定`...
RabbitMQ消息中间件(五) RabbitMQ整合Spring Cloud Stream
xy294636185的博客
03-04 368
RabbitMQ整合Spring Cloud实践：
SpringCloud Stream 整合RabbitMQ
qq_21067307的博客
01-05 9326
本篇简单介绍SpringCloud Stream 整合RabbitMQ基本步骤： 引入SpringCloud 引入SpringCloud Stream相关依赖 定义绑定接口: 消息生产者(Output…Binding) 、消息消费者(Input…Binding) @EnableBinding 在对应类上进行定义 @StreamListener 在对应方法上创建监听用来消费消息 调用output的...
springCloud 之 spring-cloud-stream 集成消息中间件rabbitmq
Mynah886的博客
09-23 3165
1、POM中引入spring-cloud-starter-stream-rabbit <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-stream-binder-rabbit</artifactId> &...
Spring Cloud 学习笔记 ——Spring Cloud Stream 自定义消息通道
XiaoMing学习分享博文
11-06 1259
15.3 自定义消息通道 在Spring Cloud 学习笔记 ——Spring Cloud Stream 概念及 HelloWorld中使用了默认的 Sink 通道，也可以自定义消息通道 1.创建一个自定义消息通道接口类，起名叫 MyChannel public interface MyChannel { String INPUT = "javaboy-input"; String OUTPUT = "javaboy-output"; @Output(OUTPUT) M
RabbitMQ开通STOMP通道
热门推荐
李虹柏的博客
08-18 2万+
进入到RabbitMQ安装目录下的sbin文件夹内 Shift加右键进入命令行 执行命令 rabbitmq-plugins enable rabbitmq_web_stomp rabbitmq-plugins enable rabbitmq_web_stomp_examples 成功后重启RabbitMQ &lt;!DOCTYPE HTML&gt; &lt;html...
spring cloud stream 自定义binder
一杯米酒
03-09 1027
记得，不要扫描到BinderConfiguration，xxBinderConfiguration 是在binderService动态配置的，具体构建Binder在这，如果扫描到BinderConfiguration类，此处binders.size就不是0了。中间件 --- binder --- channel --- sink --- （处理）---source ---channel ---binder ---中间件。但是有时候还需自己实现，官方也给出了响应步骤。cp了一网友的项目，我换成了maven，
SpringCloud-stream一体化MQ解决方案-函数式编程
qq_23095607的博客
06-17 1489
中文文档英文文档介绍：Learn标签选择对应版本说明文档→overview→Programming Model （Producing and Consuming Messages （ Spring Cloud Function support））Learn标签选择对应版本说明文档​​overview​​2.1.1 Stream函数式编程参考资料部分的二、Java8内置的四大核心函数式接口如果不会泛型的话可以参考或者参考具体原理参照上面的文档，下面只介绍怎么使用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值