spring-boot & spring 实现 rabbitMq rpc模式的消息发送与接收

最新推荐文章于 2024-08-03 10:12:59 发布
最新推荐文章于 2024-08-03 10:12:59 发布
阅读量4k 收藏 4
点赞数 1
分类专栏： 学习笔记 文章标签： rabbitMq rpc spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wuqingbin/article/details/81133344
版权

简介：

      本篇文章是我个人最近学习rabbitMq的一次总结，通过实际框架中的项目配置和代码，来实现rpc风格的rabbitMq的使用，主要分为两个项目，分别实现发送，回复和接受回复的功能。

     本篇文章不是rabbitMq的入门篇，所有对于新入门的同学，对exchange，queue，routingKey这些概念还不懂的话，不建议看这篇文章。

主要分为两个项目：

1、spring框架的主要实现发送消息和接受回复消息的功能，以下简称生产者

2、spring boot框架的项目主要实现接受消息和回复消息的功能，以下简称消费者

 

废话不多说，直接上代码

1、生产者pom.xml片段，主要在原有框架中，添加spring-rabbit的依赖

		<dependency>
			<groupId>org.springframework.amqp</groupId>
			<artifactId>spring-rabbit</artifactId>
			<version>1.6.5.RELEASE</version>
		</dependency>

2、生产者配置文件，在resources下面新建rabbitMq.properties，内容如下

#rabbitMq
mq.ip=192.168.1.100
mq.port=5672
mq.userName=rabbitmq_producer
mq.password=123456
mq.virtualHost=test_vhosts

3、rabbit的spring配置文件，在resources下面新建spring-rabbitMq.xml，同时在web.xml中，像加载别的spring

配置文件一样配置一下。具体内容如下

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation=" http://www.springframework.org/schema/beans  http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
       http://www.springframework.org/schema/util
         http://www.springframework.org/schema/util/spring-util-4.0.xsd
         http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context-4.0.xsd" >

    <context:annotation-config/>

    <!-- 引入配置文件 ps:在别的配置文件中引入了，所有这里注释掉了
    <bean id="propertyConfigurer"
          class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="location" value="classpath:rabbitMq.properties" />
    </bean>
-->

    <!--从RabbitMQ Java Client创建RabbitMQ连接工厂对象-->
    <bean id="rabbitMQConnectionFactory" class="com.rabbitmq.client.ConnectionFactory">
        <property name="username" value="${mq.userName}" />
        <property name="password" value="${mq.password}" />
        <property name="host" value="${mq.ip}" />
        <property name="port" value="${mq.port}" />
        <property name="virtualHost" value="${mq.virtualHost}" />
    </bean>

    <!--基于RabbitMQ连接工厂对象构建spring-rabbit的连接工厂对象Wrapper-->
    <bean id="connectionFactory" class="org.springframework.amqp.rabbit.connection.CachingConnectionFactory">
        <constructor-arg name="rabbitConnectionFactory" ref="rabbitMQConnectionFactory" />
    </bean>
    <!--构建RabbitAmdin对象，它负责创建Queue/Exchange/Bind对象-->
    <bean id="rabbitAdmin" class="org.springframework.amqp.rabbit.core.RabbitAdmin">
        <constructor-arg name="connectionFactory" ref="connectionFactory" />
        <property name="autoStartup" value="true"/>
    </bean>

    <!--构建Rabbit Template对象，用于发送RabbitMQ消息，本程序使用它发送消息，并接收返回消息-->
    <bean id="rabbitTemplate" class="org.springframework.amqp.rabbit.core.RabbitTemplate">
        <constructor-arg name="connectionFactory" ref="connectionFactory" />
        <property name="useTemporaryReplyQueues" value="false"/>
        <property name="messageConverter" ref="serializerMessageConverter"/>
        <property name="messagePropertiesConverter" ref="messagePropertiesConverter"/>
        <property name="replyAddress" value="springReplyMessageQueue"/>
        <property name="receiveTimeout" value="60000"/>
        <property name="replyTimeout" value="1000000000" />

    </bean>



    <!--RabbitMQ消息转化器，用于将RabbitMQ消息转换为AMQP消息，我们这里使用基本的Message Converter -->
    <bean id="serializerMessageConverter"
          class="org.springframework.amqp.support.converter.SimpleMessageConverter" />

    <!--Message Properties转换器，用于在spring-amqp Message对象中的Message Properties和RabbitMQ的
     Message Properties对象之间互相转换 -->
    <bean id="messagePropertiesConverter"
          class="org.springframework.amqp.rabbit.support.DefaultMessagePropertiesConverter" />


    <!--定义AMQP Queue-->
    <bean id="springMessageQueue" class="org.springframework.amqp.core.Queue">
        <constructor-arg name="name" value="springMessageQueue" />
        <constructor-arg name="autoDelete" value="false" />
        <constructor-arg name="durable" value="true" />
        <constructor-arg name="exclusive" value="false" />
        <!--定义AMQP Queue创建所需的RabbitAdmin对象-->
        <property name="adminsThatShouldDeclare" ref="rabbitAdmin" />
        <!--判断是否需要在连接RabbitMQ后创建Queue-->
        <property name="shouldDeclare" value="true" />
    </bean>


    <!--定义AMQP Exchange-->
    <bean id="springMessageExchange" class="org.springframework.amqp.core.DirectExchange">
        <constructor-arg name="name" value="springMessageExchange" />
        <constructor-arg name="durable" value="true" />
        <constructor-arg name="autoDelete" value="false" />
        <!--定义AMQP Queue创建所需的RabbitAdmin对象-->
        <property name="adminsThatShouldDeclare" ref="rabbitAdmin" />
        <!--判断是否需要在连接RabbitMQ后创建Exchange-->
        <property name="shouldDeclare" value="true" />
    </bean>

    <util:map id="emptyMap" map-class="java.util.HashMap" />

    <!--创建Exchange和Queue之间的Bind-->
    <bean id="springMessageBind" class="org.springframework.amqp.core.Binding">
        <constructor-arg name="destination" value="springMessageQueue" />
        <constructor-arg name="destinationType" value="QUEUE" />
        <constructor-arg name="exchange" value="springMessageExchange" />
        <constructor-arg name="routingKey" value="springMessage" />
        <constructor-arg name="arguments" ref="emptyMap" />
    </bean>

    <!--侦听springMessageQueue队列消息的Message Listener-->
    <bean id="consumerListener"
          class="com.sime.rabbit.listener.RabbitMQConsumer" />

    <!--创建侦听springMessageQueue队列的Message Listener Container ，ps:也可以理解为，用来创建connection和通道以及绑定消费者到queue -->
  <bean id="messageListenerContainer"
          class="org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer">
        <property name="messageConverter" ref="serializerMessageConverter" />
        <property name="connectionFactory" ref="connectionFactory" />
        <property name="messageListener" ref="rabbitTemplate" />
        <property name="queues" ref="springReplyMessageQueue" />
        <!--  设置消息确认方式为手动确认  自动确认为AUTO 自动是 MANUAL-->
        <property name="acknowledgeMode" value="AUTO" />

   
</bean>

<bean id="consumerTagStrategy" class="com.sime.rabbit.bean.CustomConsumerTagStrategy"/>


<!--         ################################### rpc 模式   ######################################################################   -->

    <!--定义AMQP Reply Queue-->
    <bean id="springReplyMessageQueue" class="org.springframework.amqp.core.Queue">
        <constructor-arg name="name" value="springReplyMessageQueue" />
        <constructor-arg name="autoDelete" value="false" />
        <constructor-arg name="durable" value="true" />
        <constructor-arg name="exclusive" value="false" />
        <property name="adminsThatShouldDeclare" ref="rabbitAdmin" />
        <property name="shouldDeclare" value="true" />
    </bean>


    <!--定义AMQP Reply Exchange-->
    <bean id="springReplyMessageExchange" class="org.springframework.amqp.core.DirectExchange">
        <constructor-arg name="name" value="springReplyMessageExchange" />
        <constructor-arg name="durable" value="true" />
        <constructor-arg name="autoDelete" value="false" />
        <!--定义AMQP Queue创建所需的RabbitAdmin对象-->
        <property name="adminsThatShouldDeclare" ref="rabbitAdmin" />
        <property name="shouldDeclare" value="true" />
    </bean>

    <!--创建Reply Exchange和Reply Queue之间的Bind-->
    <bean id="springReplyMessageBind" class="org.springframework.amqp.core.Binding">
        <constructor-arg name="destination" value="springReplyMessageQueue" />
        <constructor-arg name="destinationType" value="QUEUE" />
        <constructor-arg name="exchange" value="springReplyMessageExchange" />
        <constructor-arg name="routingKey" value="springReplyMessage" />
        <constructor-arg name="arguments" ref="emptyMap" />
    </bean>





</beans>

需要注意的是，springReplyMessageQueue是专门用来回复的队列

4、SysRabbitProductTestController.java.  是写的一个用来测试发送消息并接收回复的测试类，这里面需要注意的是

 rabbitTemplate.sendAndReceive() 这个方法是默认等待5秒钟，如果在5秒内没有接收到回复的话，会返回一个空的message,这个默认的时间，实在spring-rabbit.xml中的rabbittemplete的配置的replyTimeout 来设置.

另外：使用sendAndReceive 这个方法发送消息时，消息的correlationId会变成系统动编制的1,2,3这个样子，而不是我们想要的

uuid的格式。

 

 


import com.rabbitmq.client.AMQP;
import com.sime.controller.base.BaseController;

import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageBuilder;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.support.MessagePropertiesConverter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import java.io.UnsupportedEncodingException;
import java.util.Date;
import java.util.UUID;


/*
*
 *  rabbitMq 发送测试
*/


@Controller
@RequestMapping("rabbitTest/")
public class SysRabbitProductTestController extends BaseController {

    @Autowired
    private MessagePropertiesConverter messagePropertiesConverter;


    @Autowired
    private RabbitTemplate rabbitTemplate;


    @RequestMapping("send")
    @ResponseBody
    public  String send(){
        String correlationId = UUID.randomUUID().toString();
        Date sendTime = new Date();
        AMQP.BasicProperties props =
                new AMQP.BasicProperties("text/plain",
                        "UTF-8",
                        null,
                        2,
                        0, correlationId, "springReplyMessageExchange", null,
                        null, sendTime, null, null,
                        "SpringProducer", null);


        MessageProperties sendMessageProperties =
                messagePropertiesConverter.toMessageProperties(props, null,"UTF-8");
         sendMessageProperties.setReceivedExchange("springReplyMessageExchange");
        sendMessageProperties.setReceivedRoutingKey("springReplyMessage");
        sendMessageProperties.setRedelivered(true);
         String message = "fa song xiaoxi ------------ 走你"; 
     

        try {
         //发送并接收回执
        Message sendMessage = MessageBuilder.withBody(message.getBytes("UTF-8"))
                     .andProperties(sendMessageProperties)
                    .build();


        Message replyMessage =   rabbitTemplate.sendAndReceive("springMessageExchange",
                        "springMessage", sendMessage);

        String replyMessageContent = null;
        replyMessageContent = new String(replyMessage.getBody(),"UTF-8");
        System.out.println("接收到回执:  "+replyMessageContent);
        return replyMessageContent;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "";
    }

}

 

6、下面是消费者的pom.xml 的重要片段

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>

 

7、application.yml 关于rabbitMq的配置

spring:  
    rabbitmq:
      username: rabbitmq_consumer
      host: 192.168.1.100
      port: 5672
      password: 123456
      virtual-host: test_vhosts

8、常量配置类AppConstants

public class AppConstants {
    public static final String SEND_QUEUE_NAME = "springMessageQueue";
    public static final String SEND_EXCHANGE_NAME = "springMessageExchange";
    public static final String SEND_MESSAGE_KEY = "springMessage"; 
 

}

 

 

9、配置类 RabbitConfig.java

 
import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.sime.constants.AppConstants;

import com.sime.rabbit.FinancMessageListener;
import com.sime.service.UserService;
import org.springframework.amqp.core.*;
import org.springframework.amqp.rabbit.config.AbstractRabbitListenerContainerFactory;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.ChannelAwareMessageListener;
import org.springframework.amqp.rabbit.core.RabbitAdmin;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.listener.MessageListenerContainer;
import org.springframework.amqp.rabbit.listener.RabbitListenerContainerFactory;
import org.springframework.amqp.rabbit.listener.RabbitListenerEndpoint;
import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer;
import org.springframework.amqp.rabbit.support.DefaultMessagePropertiesConverter;
import org.springframework.amqp.rabbit.support.MessagePropertiesConverter;
import org.springframework.amqp.support.converter.MessageConverter;
import org.springframework.amqp.support.converter.SimpleMessageConverter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.amqp.RabbitProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.HashMap;
import java.util.Map;

@Configuration
@EnableConfigurationProperties(RabbitProperties.class)
public class RabbitConfig {
    @Autowired
    private RabbitProperties rabbitProperties;


    @Bean("connectionFactory")
    public ConnectionFactory getConnectionFactory() {
        com.rabbitmq.client.ConnectionFactory rabbitConnectionFactory =
                new com.rabbitmq.client.ConnectionFactory();
        rabbitConnectionFactory.setHost(rabbitProperties.getHost());
        rabbitConnectionFactory.setPort(rabbitProperties.getPort());
        rabbitConnectionFactory.setUsername(rabbitProperties.getUsername());
        rabbitConnectionFactory.setPassword(rabbitProperties.getPassword());
        rabbitConnectionFactory.setVirtualHost(rabbitProperties.getVirtualHost());

        ConnectionFactory connectionFactory = new CachingConnectionFactory(rabbitConnectionFactory);
        return connectionFactory;

    }

    @Bean(name="rabbitAdmin")
    public RabbitAdmin getRabbitAdmin() {
        RabbitAdmin rabbitAdmin = new RabbitAdmin(getConnectionFactory());
        rabbitAdmin.setAutoStartup(true);
        return rabbitAdmin;

    }



    @Bean(name="serializerMessageConverter")
    public MessageConverter getMessageConverter(){
        return new SimpleMessageConverter();
    }

    @Bean(name="messagePropertiesConverter")
    public MessagePropertiesConverter getMessagePropertiesConverter()
    {
        return new DefaultMessagePropertiesConverter();
    }




    @Bean(name="rabbitTemplate")
    public RabbitTemplate getRabbitTemplate()
    {
        RabbitTemplate rabbitTemplate = new RabbitTemplate(getConnectionFactory());
        rabbitTemplate.setUseTemporaryReplyQueues(false);
        rabbitTemplate.setMessageConverter(getMessageConverter());
        rabbitTemplate.setMessagePropertiesConverter(getMessagePropertiesConverter());
    
        return rabbitTemplate;
    }

  

    @Bean(name="springMessageQueue")
    public Queue createQueue(@Qualifier("rabbitAdmin")RabbitAdmin rabbitAdmin)
    {
         Queue sendQueue = new  Queue(AppConstants.SEND_QUEUE_NAME,true,false,false);
        rabbitAdmin.declareQueue(sendQueue);
        return sendQueue;
    }

    @Bean(name="springMessageExchange")
    public Exchange createExchange(@Qualifier("rabbitAdmin")RabbitAdmin rabbitAdmin)
    {
        DirectExchange sendExchange = new DirectExchange(AppConstants.SEND_EXCHANGE_NAME,true,false);
        rabbitAdmin.declareExchange(sendExchange);
        return sendExchange;
    }

    @Bean(name="springMessageBinding")
    public Binding createMessageBinding(@Qualifier("rabbitAdmin")RabbitAdmin rabbitAdmin)
    {
        Map<String,Object> arguments = new HashMap<String,Object>();
        Binding sendMessageBinding =
                new Binding(AppConstants.SEND_QUEUE_NAME, Binding.DestinationType.QUEUE,
                        AppConstants.SEND_EXCHANGE_NAME, AppConstants.SEND_MESSAGE_KEY, arguments);
        rabbitAdmin.declareBinding(sendMessageBinding);
        return sendMessageBinding;
    }


}

 

10.消息接收Listener类


public class FinancMessageListener implements ChannelAwareMessageListener  {

    @Autowired
    private MessagePropertiesConverter messagePropertiesConverter;

  @Autowired
  private UserService userService;

  @Autowired
  private RabbitTemplate rabbitTemplate;

  @Override
  public void onMessage(Message message, Channel channel) throws Exception {
    System.out.println("+++++++++++++++++++++++++++++接收到消息了+++++++++++++++++++++++++++"+userService);
    System.out.println(new String(message.getBody(),"UTF-8"));
      try
      {

          MessageProperties messageProperties = message.getMessageProperties();
          AMQP.BasicProperties rabbitMQProperties =
                  messagePropertiesConverter.fromMessageProperties(messageProperties, "UTF-8");
          String messageContent = null;
          messageContent = new String(message.getBody(),"UTF-8");
          String consumerTag = messageProperties.getConsumerTag();
          System.out.println(consumerTag+ " get The message content is:" + messageContent);


          /**************************返回消息，5秒以内返回*************************************************/
            //RPC回复 ，发送消息
            String replyMessageContent = "Consumer1 返回的信息 '" + messageContent +" consumerTag:  "+consumerTag+ "'";


            String cId = rabbitMQProperties.getCorrelationId();
          AMQP.BasicProperties replyRabbitMQProps =
              new AMQP.BasicProperties("text/plain",
                      "UTF-8",
                      null,
                      2,
                      0, cId, null, null,
                      null, null, null, null,
                      consumerTag, null);
          Envelope replyEnvelope =
                  new Envelope(messageProperties.getDeliveryTag(), true,
                          "springReplyMessageExchange", "springReplyMessage");

          MessageProperties replyMessageProperties =
                  messagePropertiesConverter.toMessageProperties(replyRabbitMQProps,
                          replyEnvelope,"UTF-8");

          Message replyMessage = MessageBuilder.withBody(replyMessageContent.getBytes("UTF-8"))
                  .andProperties(replyMessageProperties)
                  .build();


          rabbitTemplate.send("springReplyMessageExchange","springReplyMessage", replyMessage);
          channel.basicAck(messageProperties.getDeliveryTag(), false);



      }
      catch (Exception e) {
            e.printStackTrace();
      }


  }
 }

 

 

截止到此，关键的部分的代码就完成了，仅做记录

参考：https://blog.csdn.net/u011126891/article/details/54376179

 

 

 

 

 

绿茵场上的程序猿
关注
专栏目录
RabbitMQ 发送和接收消息
m0_50163856的博客
09-03 373
依赖 <dependency> <groupId>com.rabbitmq</groupId> <artifactId>amqp-client</artifactId> <version>5.13.0</version> </dependency> public class MyRabbitFactory { public static Connection getConnect
Springboot整合RabbitMQ实现发送接收消息
逆流而上的博客
01-30 9260
一、发送消息的步骤 二、项目准备 新建两个springboot项目，分别取名为producer 和 consumer。新建项目的时候引入Rabbitmq依赖。或者手动添加。 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot...
SpringBoot整合RabbitMQ并实现消息发送与接收
心态的博客
10-18 2870
消息队列（Message Queue）是一种高效的异步通信机制，它在分布式应用系统中扮演着重要的角色。简单来说，消息队列将消息发送者和消息接收者解耦，消息发送者只需要将消息发送给队列，而不需要知道消息是如何被消费者处理的，同时，消息接收者也只需要从队列中订阅自己需要的消息，而不需要知道这些消息是由哪个发送者发送的。消息队列能够提高应用程序的可扩展性、可靠性以及灵活性，并且能够缓解高并发情况下的压力。 RabbitMQ 是一个开源的 AMQP 消息代理软件，它基于 Erlang/OTP 平台
【RabbitMQ】远程调用模式（RPC）
wosixiaokeai的博客
08-03 320
生产者（客户端）：发送RPC请求到RabbitMQ交换机。交换机：根据路由键将请求路由到相应的队列。消费者（服务端）：从队列中接收请求，处理请求，并将结果发送回生产者。回调队列：生产者需要设置一个临时的回调队列，以便服务端能够发送响应消息。：为每个请求设置唯一的标识符，以便生产者能够匹配响应与请求。
Spring整合rabbitmq---消息接收
datouniao1的博客
12-09 707
这两天一直在看rabbimq消息接收的设置。看到网上也有很多的例子，但是发现很多别人可以，到本地自己就不可以，也是比较让人苦恼，在前面的一篇文章中我们介绍了Spring-rabbitmq消息的发送，继续上一节中我们继续看消息的接收。 首先来看rabbitmq-receiver.xml的配置: &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;b...
简单Rabbitmq 发送消息和接收消息
DK微风的博客
09-12 7318
简单Rabbitmq 发送消息和接收消息 1 先在Rabbitmq配置文件中预先创建好交换器，队列，路由等信息。 2 创建生产者发送消息 @Autowired private RabbitTemplate rabbitTemplate; private void mqSendMessage(UserOperLog userOperLog) throws Exception{ rabbitTemplate.setExchange("test.file.ex.
RabbitMQ——消息发送和消息接收机制
★★光亭★★
06-24 9349
RabbitMQ——消息发送和消息接收机制
SpringBoot整合RabbitMQ（各个模式如何发送一个消息）
炫风丶小子
11-20 862
RabbitMQ作为一个消息中间件，在使用过程中我们需要保证生产端是否将消息发送到了MQ上，如何保证消费端
基于spring boot，集成了RPC、缓存、消息队列、分库分表、注册-spring-boot-bulking.zip
01-29
Spring Boot 提供了与这些消息队列的集成，使得消息的生产与消费可以通过简单的配置和API实现。消息队列可以处理高并发场景下的流量洪峰，同时实现任务的异步处理。 4. **分库分表**：随着数据量的增长，单表可能...
基于Spring Boot和RabbitMQ的消息处理系统.zip
最新发布
09-08
基于Spring Boot和RabbitMQ的消息处理系统 项目简介 本项目是一个基于Spring Boot框架和RabbitMQ消息队列的消息处理系统。它涵盖了消息的生产、消费、路由、交换机配置以及高级特性如发布确认和RPC调用。通过...
Springboot+rabbitmq如何实现高并发的rpc调用
热门推荐
CSDNOFZHC的博客
03-02 1万+
2019年5月最新更新：注意！并不推荐RPC式的mq调用，这么做完全没有发挥mq异步削峰的作用。之所以会有这篇文章完全是因为架构无法更改。 RPC式的mq调用，会使调用端的线程一直阻塞，中间还过了一层mq。虽然仍旧是rpc式的通信，但是效果还不如dubbo，建议需要同步的业务直接使用dubbo。 2018年8月： 一.背景 公司项目的收单前置服务A与收单服务B之间是通过ra...
spring集成rabbitmq实现rpc
05-03
本文将详细讲解如何在Spring项目中集成RabbitMQ，实现基于RPC（远程过程调用）的通信模式。 首先，我们需要在项目中引入Spring AMQP库，这是Spring对RabbitMQ的官方支持。可以通过在pom.xml文件中添加以下Maven依赖...
RabbitMQ的Java应用(3) -- 使用spring-boot-starter-amqp开发生产者应用
u011126891的博客
01-12 1万+
本篇讲述如何使用spring-boot-starter-amqp库开发基于Spring Boot的生产者应用
SpringBoot2.3整合RabbitMQ实现消息发送和接收
liu320yj的博客
09-03 1256
概述 RabbitMQ是一个接收，存储和转发消息数据的消息中间件。主要有四大核心部分，生产者、交换机、队列和消费者，工作原理如下图： 核心名称解释 Broker：接收和分发消息的应用 Connection：publisher/consumer和broker之间的TCP连接 Channel：在connection内部建立的逻辑连接，作为轻量级的connection极大减少了操作系统建立TCP connection的开销 Exchange：交换机，message到达broker的第一站，根据分发规则，匹配查.
RocketMQ快速入门：集成springboot实现各类消息发送｜异步、同步、顺序、单向、延迟、事务消息（六）附带源码
55555的博客
06-18 1148
上一节针对spring或其他框架集成rocketmq实现消息发送进行了讲解，而作为当前更加流行的springboot框架，实现rocketmq的集成则更加简单，本节我们就重点针对springboot集成rocketmq，实现异步、同步、单向、顺序、延迟、事务消息发送进行讲解，文末附上源码。
SpringBoot整合RabbitMQ
qq_41120971的博客
07-15 588
0.RabbitMq安装 不多介绍rabbitmq的安装过程，RabbitMq基于erlang开发，所以安装Rabbitmq之前需要先安装对应版本的erlang。 rabbitmq下载地址：https://www.rabbitmq.com/install-windows.html erlang下载地址：https://www.erlang-solutions.com/resources/download.html 安装完，打开localhost:15672,使用guest，guest可登录rabbitmq，
springboot项目使用rabbitMQ发送邮件
qq_44033725的博客
07-17 789
在springboot项目中使用rabbitmq发送消息，实现发送邮件，并且邮件内容设置字体等html样式
Spring Boot入门+深入(十一)-消息RabbitMQ
杀神lwz的博客
11-21 1827
一、Spring Boot与消息 1.概述 1. 大多应用中，可通过消息服务中间件来提升系统异步通信、扩展解耦能力 2. 消息服务中两个重要概念： 消息代理（message broker）和目的地（destination） 当消息发送者发送消息以后，将由消息代理接管，消息代理保证消息传递到指定目的地。 3. 消息队列主要有两种形式的目的地 1. 队列（queue）：点对点消息通信（point-to-point） 2. 主题（topic）：发布（publish）/...
RabbitMQ学习（一）.NET Client之Send/Receive
jiq•钦's technical Blog
08-30 4580
1 "Hello World!" The simplest thing that doessomething Python | Java | Ruby | PHP| C# Introduction 下面是RabbitMQ的一些术语：RabbitMQ是一个消息代理，实际上它从消息生产者接收消息，然后将其发送到消息消费者，在这之间可以根据特定规则对消息进行路由，缓冲，以
Spring Boot深度整合实战：Redis、RabbitMQ、ElasticSearch等
Spring Boot集成RabbitMQ，可以帮助开发者构建可扩展和高可用的系统，实现消息驱动的架构。 3. **检索整合Elasticsearch**：Elasticsearch是一个分布式搜索引擎，适合大规模数据索引和搜索。Spring Boot结合Elastic...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值