springRabbitMQ

最新推荐文章于 2025-02-27 12:35:09 发布
原创 最新推荐文章于 2025-02-27 12:35:09 发布 · 332 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#springRabbitMQ

本文介绍RabbitMQ的基础概念，包括JMS与AMQP的区别，并详细讲解如何使用Spring框架整合RabbitMQ实现消息队列功能。从搭建环境到发送、接收消息，再到不同模式的运用，适合初学者快速上手。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

前言：学习rabbitMQ应知道

1.什么是JMS

JMS即Java消息服务（Java Message Service）应用程序接口，是一个Java平台中关于面向消息中间件（MOM）的API，用于在两个应用程序之间，或分布式系统中发送消息，进行异步通信。Java消息服务是一个与具体平台无关的API，绝大多数MOM提供商都对JMS提供支持。
JMS是一种与厂商无关的 API，用来访问消息收发系统消息，它类似于JDBC。这里，JDBC 是可以用来访问许多不同关系数据库的API，而JMS则提供同样与厂商无关的访问方法，以访问消息收发服务。

2.什么是AMQP

AMQP，即Advanced Message Queuing Protocol（高级消息队列协议）,一个提供统一消息服务的应用层标准高级消息队列协议,是应用层协议的一个开放标准,为面向消息的中间件设计。基于此协议的客户端与消息中间件可传递消息，并不受客户端/中间件不同产品，不同的开发语言等条件的限制。Erlang中的实现有 RabbitMQ等。
在异步通讯中，消息不会立刻到达接收方，而是被存放到一个容器中，当满足一定的条件之后，消息会被容器发送给接收方，这个容器即消息队列，而完成这个功能需要双方和容器以及其中的各个组件遵守统一的约定和规则，AMQP就是这样的一种协议，消息发送与接受的双方遵守这个协议可以实现异步通讯。这个协议约定了消息的格式和工作方式。

3.JMS和AMQP的区别

总结来说：
1）JMS是定义了统一的接口，来对消息操作进行统一；AMQP是通过规定协议来统一数据交互的格式
2）JMS限定了必须使用Java语言；AMQP只是协议，不规定实现方式，因此是跨语言的。
3）JMS规定了两种消息模型；而AMQP的消息模型更加丰富
JMS两种模型：
点对点：Point-to-Point（P2P）
(1) 每个消息只有一个消费者(Consumer)(即一旦被消费，消息就不再在消息队列中)
(2) 发送者和接收者之间在时间上没有依赖性，也就是说当发送者发送了消息之后，不管接收者有没有正在运行，它不会影响到消息被发送到队列。
(3) 接收者在成功接受消息之后需要向队列应答成功
发布订阅：Publish/Subscribe（Pub/Sub）
(1) 每个消息可以有多个消费者
(2) 发布者和订阅者之间有时间上的依赖性。针对某个主题(Topic)的订阅者，它必须创建一个订阅之后，才能消费发布者的消息，而且，为了消费消息，订阅者必须保持运行的状态。

简介

rabbitMQ 支持6中消息队列 但是rpc不属于mq 所有 只剩5 种 分别是 简单队列，工作队列，订阅模式，路由模式，通配符模式
我们的消息发出后是否被成功消费 rabbitMq给我们提供了 ack确认机制 可以手动确认，也可以自动确认，

简单队列：一对一 即 生产者：消费者（绑定同一个队列queue）
工作队列：一对多（一个队列queue多个消费者） 即 生产者：｛消费者,消费者,…｝ 但是可根据其消费的能力，使用能者多劳政策（即一次只给一个信息消费，消费完再给）

订阅模式：我们将消息(生产者)交给交换机，由交换机在转交给多个队列 即 一个生产者发送的消息会被多个消费者获取

路由模式：生产者发送消息到交换机并且要指定路由key，消费者将队列绑定到交换机时需要指定路由key，两者key相匹配，则消息会发送到对应队列中

通配符模式：生产者发送消息到交换机并且要指定路由key，消费者将队列绑定到交换机时需要指定路由key
通配符模式 生产者P发送消息到交换机X，type=topic，交换机根据绑定队列的routing key的值进行通配符匹配；符号#：匹配一个或者多个词lazy.# 可以匹配lazy.irs或者lazy.irs.cor 符号*：只能匹配一个词lazy.* 可以匹配lazy.irs或者lazy.cor

Spring整合rabbitMQ

引入依赖

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

我们需要两个项目，一个生产者每一个消费者，或多个消费者

编写生产者发送消息
在resources下编写
rabbit.properties

rabbitmq.host=localhost
rabbitmq.port=5672
rabbitmq.username=guest
rabbitmq.password=guest
rabbitmq.vhost=/

表写applicationContext-rabbit.xml

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:rabbit="http://www.springframework.org/schema/rabbit"
       xsi:schemaLocation="http://www.springframework.org/schema/rabbit
	http://www.springframework.org/schema/rabbit/spring-rabbit-1.4.xsd
	http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans-4.1.xsd">

    <!-- 创建连接工厂 -->
    <rabbit:connection-factory id="connectionFactory"
                               host="${rabbitmq.host}" port="${rabbitmq.port}" username="${rabbitmq.username}"
                               password="${rabbitmq.password}" virtual-host="${rabbitmq.vhost}" />

    <!-- admin管理工具 -->
    <rabbit:admin connection-factory="connectionFactory" />

    <!-- 交换机 durable是否持久化 -->
    <rabbit:topic-exchange name="TAOTAO_ITEM_EXCHANGE"
                           auto-declare="true" durable="true" />

    <!-- 模板对象 -->
    <rabbit:template id="taotao_template" exchange="TAOTAO_ITEM_EXCHANGE"
                     connection-factory="connectionFactory" />

</beans>

连接我们的rabbitMQ :

在这里插入图片描述

指定我们的交换机:
在这里插入图片描述

交换机绑定到模板对象:

在这里插入图片描述
记得在spring主配置文件中读取 ：
在这里插入图片描述

编写RabbitService 发送消息工具

package com.dxsysg.service;

import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

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

/**
 * @author zhaozeren
 * @version 1.0
 * @date 2019/3/29
 */
@Service
public class RabbitService {
    
    private final ObjectMapper objectMapper = new ObjectMapper();

    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void sendMsg(Long id, String type){

        try {
            //根据实际业务传送消息
            Map<String, Object> map = new HashMap<>();
            map.put("id", id);//商品的ID
            map.put("type", type);//所做操作，update,delete...
            map.put("date", System.currentTimeMillis());//发送时间
            this.rabbitTemplate.convertAndSend("item." + type, objectMapper.writeValueAsString(map));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

测试当商品有改动后发送消息：
在这里插入图片描述
启动项目：
我们会发现在rabbit的管理界面http://localhost:15672
发现多出了交换机
在这里插入图片描述

编写消费者

引入依赖

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

在resources下编写
rabbit.properties

rabbitmq.host=localhost
rabbitmq.port=5672
rabbitmq.username=guest
rabbitmq.password=guest
rabbitmq.vhost=/

表写applicationContext-rabbit.xml

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:rabbit="http://www.springframework.org/schema/rabbit"
       xsi:schemaLocation="http://www.springframework.org/schema/rabbit
	http://www.springframework.org/schema/rabbit/spring-rabbit-1.4.xsd
	http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans-4.1.xsd">

    <!-- 创建连接工厂 -->
    <rabbit:connection-factory id="connectionFactory"
                               host="${rabbitmq.host}" port="${rabbitmq.port}" username="${rabbitmq.username}"
                               password="${rabbitmq.password}" virtual-host="${rabbitmq.vhost}" />

    <!-- admin管理工具 -->
    <rabbit:admin connection-factory="connectionFactory" />

    <!-- 队列 durable是否持久化 -->
    <rabbit:queue name="TAOTAO_WEB_ITEM_QUEUE" auto-declare="true" durable="false" />

    <!-- 监听 -->
    <rabbit:listener-container connection-factory="connectionFactory">
        <rabbit:listener ref="itemMQListener" method="consume" queue-names="TAOTAO_WEB_ITEM_QUEUE"/>
    </rabbit:listener-container>

    <!-- 消费者 -->
    <bean id="itemMQListener" class="com.example.rabbit.ItemMQListener"/>

</beans>

声明队列：
在这里插入图片描述
定义消费者：
在这里插入图片描述
监听：
在这里插入图片描述

表写消费者类ItemMQListener：

package com.example.rabbit;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.io.IOException;

/**
 * @author zhaozeren
 * @version 1.0
 */
public class ItemMQListener {

    private static final ObjectMapper MAPPER = new ObjectMapper();

    public void consume(String msg){

        Long itemId = null;
        String type = null;
        try {
            JsonNode jsonNode = MAPPER.readTree(msg);
            //获取消费信息中的id
            itemId = jsonNode.get("id").asLong();
            //获取消费信息中的type
            type = jsonNode.get("type").toString();
        } catch (IOException e) {
            e.printStackTrace();
        }
      System.out.println(itemId);
      System.out.println(type);
    }
}

启动项目：
我们会发现在rabbit的管理界面http://localhost:15672
我们发现多处了个队列：
在这里插入图片描述

队列绑定交换机

在界面管理工具中完成绑定关系
在这里插入图片描述
找到Exchange管理页面：
在这里插入图片描述
点击TAOTAO-ITEM-EXCHANGE，即可进入管理页，在这里绑定队列：
在这里插入图片描述
指定我们的队列，我们所需要的key， 绑定队列.(我们采用了通配符模式)
在这里插入图片描述

测试，分别起动消费者，生产者项目；

发送消息：
在这里插入图片描述
消费者：
在这里插入图片描述

RabbitMQ：第二章：Spring整合RabbitMQ（简单模式，广播模式，路由模式，通配符模式，消息可靠性投递，防止消息丢失
2401_83329402的博客
04-16 873
TTL 全称 Time To Live（存活时间/过期时间），当消息到达存活时间后，还没有被消费，会被自动清除。RabbitMQ可以对消息设置过期时间，也可以对整个队列（Queue）设置过期时间。小编也是很有感触，如果一直都是在中小公司，没有接触过大型的互联网架构设计的话，只靠自己看书去提升可能一辈子都很难达到高级架构师的技术和认知高度。向厉害的人去学习是最有效减少时间摸索、精力浪费的方式。我们选择的这个行业就一直要持续的学习，又很吃青春饭。
spring rabbitmq
09-04
The Spring AMQP project applies core Spring concepts to the development of AMQP-based messaging solutions. We provide a "template" as a high-level abstraction for sending and receiving messages. We ...
RabbitMQ整合 SpringCloud实战
LIN_17970的博客
12-09 390
文章目录RabbitMQ整合 SpringCloud实战 RabbitMQ整合 SpringCloud实战 注意一点，在发送消息的时候对template进行配置mandatory=true保证监听有效 生产端还可以配置其他属性，比如发送重试，超时时间、次数、间隔等 消费端核心配置 首先配置手工确认模式，用于ACK的手工处理，这样我们可以保证消息的可靠性送达，或者在消费端消费失败的时候可以做到重回...
Spring整合RabbitMQ
Mr_yu_shao的博客
08-31 3831
超简单！入门级SpringBoot整合RabbitMQ，一看就会！
Spring整合RabbitMq
m0_62943934的博客
12-16 1141
多个消费者绑定到一个队列，可以加快消息处理速度，同一条消息只会被一个消费者处理。通过设置prefetch来控制消费者预取的消息数量。
Springboot整合RabbitMQ详解
m0_54853503的博客
07-28 2973
队列，交换机和绑定统称为AMQP实体（AMQPentities）这是RabbitMQ的一种保护机制。防止当消息激增的时候，海量的消息进入consumer而引发consumer宕机。该值定义通道上允许的未确认消息的最大数量，这是为了防止Unacked消息缓冲区存在过多的Unacked消息。一旦数量达到配置的数量，RabbitMQ将停止在通道上传递更多消息。RabbitMQ支持为队列设置优先级，从而达到优先级高的队列中消息被优先消费。惰性队列支持更多的消息存储。消息回退会增加生产者的复杂性；...
Spring RabbitMQ死信机制原理实例详解
08-24
Spring RabbitMQ 死信机制原理实例详解 Spring RabbitMQ 死信机制是指在消息队列中，消息没有被及时消费的机制。这种机制可以提高系统的稳定性，当消息消费失败后，消息进入死信队列，可以对消息进行补偿，达到...
Spring RabbitMQ Actuator监控工具.zip
09-12
这是一个基于Spring Boot和RabbitMQ的健康检查和指标监控工具。它提供了队列指标和健康检查的端点，有助于监控和分析RabbitMQ队列的状态。通过该工具，用户可以方便地获取队列的消息数量、消费者数量、最大消息数等...
spring rabbitmq rpc 测试代码
09-13
Spring RabbitMQ RPC（远程过程调用）是一种使用RabbitMQ实现客户端与服务器间通信的方式，它允许客户端发送请求到服务器，然后服务器处理请求并返回结果。在这个场景中，RabbitMQ作为一个消息中间件，帮助解耦应用...
spring rabbitmq amqp
03-16
Spring RabbitMQ AMQP 是一个基于Java的开源框架，它整合了RabbitMQ消息中间件，实现了高级消息队列协议（AMQP）。这个框架是Spring生态的一部分，为Spring Boot应用程序提供了强大的消息处理能力。AMQP是一种标准的...
spring整合rabbit mq的jar包
10-27
spring-rabbit-1.5.1.RELEASE.jar， spring-amqp-1.5.1.RELEASE.jar， rabbitmq-client.jar spring-retry-1.1.2.RELEASE.jar 四个包 之前的资源不好意思传错了一个
rabbitmq+spring3 jar包及配置
06-07
spring3 + rabbitmq 包含配置文件demo,用到了fastjson 。消息生产者使用了消息确认，消费者使用了事务 用到的包基本都是最近的新版本：spring-amqp-1.6.0.RELEASE.jar spring-rabbit-1.3.5.RELEASE.jar spring-retry-1.1.2.RELEASE.jar amqp-client-3.6.2.jar
spring事物和rabbitMQ的例子
08-15
spring的2个数据源的配置，并且每个数据源都配置了事物管理。还有rabbitMQ的发送端代码。本人项目亲自用到的，可以运行。
RabbitMQ消息中间件快速入门
欢迎来到编程小栈
07-19 2703
文章目录一、同步和异步通讯1. 同步通讯2. 异步通讯二、RabbitMQ1. MessageQueue对比2. RabbitMQ快速入门【1】安装与启动【2】基本结构3. 五种消息模型介绍【1】入门案例1）publisher实现2）consumer实现4. SpringAMQP实现【1】Basic Queue 基本消息队列1）消息发送2）消息接收3）测试【2】WorkQueue工作消息队列1）消息发送2）消息接收3）测试4）prefetch提前获取【3】发布订阅三种模式1）Fanout[1] 声明队列和交
三、在Spring中使用RabbitMQ
qq_36412195的博客
04-17 1401
添加RabbitMQ到Spring中 1.添加RabbitMQ依赖 在使用Spring发送和接收RabbitMQ消息之前，我们需要将Spring Boot的AMQPstarter依赖添加到构建文件中 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency&g
12_Spring rabbit mq 整合
架构师的成长之路的博客
03-19 794
12_Spring rabbit mq 整合更多干货分布式实战（干货）spring cloud 实战（干货）mybatis 实战（干货）spring boot 实战（干货）React 入门实战（干货）构建中小型互联网企业架构（干货）python 学习持续更新简介为了更好更快速的去开发 Rabbitmq 应用,spring 封装 client ;目的是简化我们的使用.https://projects...
SpringBoot集成RabbitMq
Blueeyedboy521的博客
04-07 8477
一、初识MQ RabbitMQ是一个开源的消息代理和队列服务器，用来通过普通协议在完全不同的应用之间共享数据，RabbitMQ是使用Erlang语言来编写的，并且是基于AMQP协议的。 AMQP：Advanced Message Queuing Protocol，高级消息队列协议。是具有现代特征的二进制协议，是一个提供统一消息服务的应用层标准高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。 1、同步调用的问题 2、异步调用方案 优势一：服务解耦 优势二：性能提升，吞吐量提高 优势三
浅谈Spring结合RabbitMQ的使用
weixin_42679286的博客
05-22 1172
确保消息在 RabbitMQ 中安全保存，必须开启消息持久化机制，即。默认情况下，SpringAmqp 声明的交换机，队列，消息都是持久化的，并不需要我们特意指定，即 Durability 属性都为 Durable。
Spring Boot 中 RabbitMQ 的使用
最新发布
m0_74824635的博客
02-27 1360
在中，我们学习了 RabbitMQ 的，接下来，在本篇文章中，我们就来在中实现常见的工作模式（由于 RPC 模式 和 发布确认模式 使用较少，因此在这里就不进行介绍了），进而学习在 Spring Boot 中如何使用 RabbitMQ在编写代码之前，我们需要先创建项目，引入依赖，并配置基本信息。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值