springboot 集成 rabbitMQ 实例之rabbitMQ集成

最新推荐文章于 2024-05-28 22:59:18 发布
最新推荐文章于 2024-05-28 22:59:18 发布
阅读量637 收藏 1
点赞数
分类专栏： rabbitMQ springboot 文章标签： rabbitmq java spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_36665875/article/details/106500802
版权

springboot 集成 rabbitMQ 实例之rabbitMQ集成


本片主要简单讲一下 springboot 集成rabbitMQ ， 消息的简单发布， 消费， 体验rabbitMQ， 话不多说， 我们开始…

准备环境

  1. jdk 1.8
  2. maven 3.6.3（idea2019 可能不支持）
  3. springboot 2.*
  4. rabbitMQ 3.8.3
  5. rabbitMQ的环境搭建请参考Centos7安装rabbitMQ

集成背景

场景： 需要记录各大平台的订单记录， 为了以后统计做数据准备，假设，用户在淘宝， 天猫， 京东， 苏宁下单后，将这些订单都扔进rabbitmq， 暂时不考虑流量， 大并发，我们从对应的队列获取订单写入库里；

规则：有这四大品牌标志的归入各自里面， 没有明显标志的，四大品牌都加一单

创建项目

搭建一个springboot 2.3.0 为主的项目集成 rabbitmq

  1. 搭建项目引入主要依赖spring-boot-starter-amqp在这里插入图片描述
  2. 在application.yml配置相关配置在这里插入图片描述
  3. 再次拓展一下springboot 集成rabbitmq 的相关配置说明
# 基础信息
# 默认localhost
spring.rabbitmq.host=192.168.171.113
#端口号
spring.rabbitmq.port=15672
#用户名称
spring.rabbitmq.username=admin
#用户密码
spring.rabbitmq.password=admin
#连接到代理时用的虚拟主机
# spring.rabbitmq.virtual-host
# 客户端应连接到的地址的逗号分隔列表。设置后，主机和端口将被忽略
#spring.rabbitmq.addresses
#请求的心跳超时；无为零。如果未指定持续时间后缀，则将使用秒
#spring.rabbitmq.requested-heartbeat=0
#确认使用的发布者类型
#spring.rabbitmq.publisher-confirm-type=correlated
#是否启用发布者退货
#spring.rabbitmq.publisher-returns=false
#连接超时。将其设置为零以永远等待
#spring.rabbitmq.connection-timeout=0

# SSL 配置
#是否启用SSL支持
#spring.rabbitmq.ssl.enabled=false
#持有SSL证书的密钥库的路径
#spring.rabbitmq.ssl.key-store=
#用于访问密钥库的密码
#spring.rabbitmq.ssl.key-store-password=
#拥有SSL证书的信任库
#spring.rabbitmq.ssl.trust-store=
#用于访问信任库的密码
#spring.rabbitmq.ssl.trust-store-password=
#信任库类型
#spring.rabbitmq.ssl.trust-store-type=JKS
#要使用SSL算法。默认情况下，由Rabbit客户端库配置
#spring.rabbitmq.ssl.algorithm=
#是否启用服务器端证书验证
#spring.rabbitmq.ssl.validate-server-certificate=true
#是否启用主机名验证
#spring.rabbitmq.ssl.verify-hostname=true

# 缓存设置

#要保留在缓存中的通道数。当“检查超时”> 0时，每个连接的最大通道数
#spring.rabbitmq.cache.channel.size=1
#如果已达到高速缓存大小，则等待获取频道的持续时间。如果为0，则始终创建一个新通道
#spring.rabbitmq.cache.channel.checkout-timeout=0
#要缓存的连接数。仅在模式为“连接”时适用
#spring.rabbitmq.cache.connection.size=9
#连接工厂缓存模式
#spring.rabbitmq.cache.connection.mode

# Template模板配置
#是否启用强制性消息
#spring.rabbitmq.template.mandatory=false
#receive（）操作超时
#spring.rabbitmq.template.receive-timeout=
#sendAndReceive（）操作超时
#spring.rabbitmq.template.reply-timeout=
#是否启用发布重试
#spring.rabbitmq.template.retry.enabled=false
#传递邮件的最大尝试次数
#spring.rabbitmq.template.retry.max-attempts=3
#应用于前一个重试间隔的乘数
#spring.rabbitmq.template.retry.multiplier=1
#两次尝试之间的最大持续时间
#spring.rabbitmq.template.retry.max-interval=10000
#显式指定没有接收消息的默认队列的名称
#spring.rabbitmq.template.default-receive-queue=
#用于发送操作的默认交换的名称
#spring.rabbitmq.template.exchange=

暂时用到的还是几个基础的，如果想了更多的请参考spring官网rabbitMQ相关配置

  1. 创建相关数据库
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for tb_order
-- ----------------------------
DROP TABLE IF EXISTS `tb_order`;
CREATE TABLE `tb_order`  (
  `order_id` bigint(20) NOT NULL COMMENT '主键',
  `order_name` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '订单名称',
  `order_type` varchar(10) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '订单类型',
  `order_detail` varchar(500) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '订单详情',
  PRIMARY KEY (`order_id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Table structure for tb_user
-- ----------------------------
DROP TABLE IF EXISTS `tb_user`;
CREATE TABLE `tb_user`  (
  `user_id` bigint(20) NOT NULL COMMENT '主键',
  `user_name` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '姓名',
  `user_age` int(4) NULL DEFAULT NULL COMMENT '年龄',
  `user_resume` varchar(500) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '履历',
  PRIMARY KEY (`user_id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

SET FOREIGN_KEY_CHECKS = 1;
  1. 引入mybatis 代码生成器
    在这里插入图片描述
    生成相应的mapper.xml, mapper, pojo等在这里插入图片描述
    在这里插入图片描述
  2. 至此项目基础已经创建配置完成
    在这里插入图片描述

代码实战

  1. 创建rabbitmqConfig 配置类， 配置相关的队列， 交换器，制定绑定规则
/**
 * rabbit一些设置 队列 交换器等
 * @author :master
 * @date :20200611
 */
@Configuration
public class RabbitmqConfig {

    /**
     * 京东订单
     * @return queue
     */
    @Bean
    public Queue orderJd () {
        return new Queue(GlobalConstant.ORDER_JD);
    }

    /**
     * 淘宝订单
     * @return queue
     */
    @Bean
    public Queue orderTb () {
        return new Queue(GlobalConstant.ORDER_TB);
    }

    /**
     * 苏宁订单
     * @return queue
     */
    @Bean
    public Queue orderSn () {
        return new Queue(GlobalConstant.ORDER_SN);
    }

    /**
     * 天猫订单
     * @return queue
     */
    @Bean
    public Queue orderTm () {
        return new Queue(GlobalConstant.ORDER_TM);
    }


    /**
     * 创建交换器
     * @return TopicExchange
     */
    @Bean
    public TopicExchange exchangeWhole () {
        return  new TopicExchange(GlobalConstant.ORDER_EXCHANGE);
    }

    /**
     * 队列绑定到交换器 规则一 淘宝天猫的
     * @param orderTm 队列
     * @param exchangeWhole 交换器
     * @return 返回binding
     */
    @Bean
    public Binding bindingTbExchange(Queue orderTm, TopicExchange exchangeWhole) {
        return BindingBuilder.bind(orderTm).to(exchangeWhole).with(GlobalConstant.EXCHANGE_BINDING_RULE1);
    }

    /**
     * 队列绑定到交换器 规则一 淘宝天猫的
     * @param orderTm 队列
     * @param exchangeWhole 交换器
     * @return 返回binding
     */
    @Bean
    public Binding bindingTbExchange2(Queue orderTm, TopicExchange exchangeWhole) {
        return BindingBuilder.bind(orderTm).to(exchangeWhole).with(GlobalConstant.EXCHANGE_BINDING_RULE2);
    }

    /**
     * 队列绑定到交换器 规则二 淘宝的
     * @param orderTb 队列
     * @param exchangeWhole 交换器
     * @return 返回binding
     */
    @Bean
    public Binding bindingExchange(Queue orderTb, TopicExchange exchangeWhole) {
        return BindingBuilder.bind(orderTb).to(exchangeWhole).with(GlobalConstant.EXCHANGE_BINDING_RULE1);
    }

    @Bean
    public Binding bindingExchange2(Queue orderTb, TopicExchange exchangeWhole) {
        return BindingBuilder.bind(orderTb).to(exchangeWhole).with(GlobalConstant.EXCHANGE_BINDING_RULE2);
    }


    /**
     * 队列绑定到交换器 规则二 苏宁的
     * @param orderSn 队列
     * @param exchangeWhole 交换器
     * @return 返回binding
     */
    @Bean
    public Binding bindingSnExchange(Queue orderSn, TopicExchange exchangeWhole) {
        return BindingBuilder.bind(orderSn).to(exchangeWhole).with(GlobalConstant.EXCHANGE_BINDING_RULE3);
    }

    @Bean
    public Binding bindingSnExchange2(Queue orderSn, TopicExchange exchangeWhole) {
        return BindingBuilder.bind(orderSn).to(exchangeWhole).with(GlobalConstant.EXCHANGE_BINDING_RULE2);
    }

    /**
     * 队列绑定到交换器 规则二 京东的
     * @param orderJd 队列
     * @param exchangeWhole 交换器
     * @return 返回binding
     */
    @Bean
    public Binding bindingJdongExchange(Queue orderJd, TopicExchange exchangeWhole) {
        return BindingBuilder.bind(orderJd).to(exchangeWhole).with(GlobalConstant.EXCHANGE_BINDING_RULE4);
    }

    @Bean
    public Binding bindingJdongExchange2(Queue orderJd, TopicExchange exchangeWhole) {
        return BindingBuilder.bind(orderJd).to(exchangeWhole).with(GlobalConstant.EXCHANGE_BINDING_RULE2);
    }

/**
 * 全局常量
 * @author :master
 * @date :20200610
 */
public class GlobalConstant {

    /**京东 */
    public static final String ORDER_JD ="order.lqd.jd";

    /**淘宝 */
    public static final String ORDER_TB ="order.my.tb";

    /**苏宁 */
    public static final String ORDER_SN ="order.jm.sn";

    /**天猫 */
    public static final String ORDER_TM ="order.my.tm";

    /** 交换机 */
    public static final String ORDER_EXCHANGE = "exchangeWhole";

    /** 交换机绑定规则 */
    public static final String EXCHANGE_BINDING_RULE1 = "*.my.*";
    public static final String EXCHANGE_BINDING_RULE2 = "order.#";
    public static final String EXCHANGE_BINDING_RULE3 = "*.lj.*";
    public static final String EXCHANGE_BINDING_RULE4 = "*.lqd*";
}
  1. 创建对应的消费者
/**
 * 订单队列监听者
 * @author :master
 * @date :20200611
 */
@Service
public class OrderListener {

    @Autowired
    private OrderMapper orderMapper;

    /**
     * 京东订单处理
     * @param order 消息
     */
    @RabbitHandler
    @RabbitListener(queues = GlobalConstant.ORDER_JD)
    public void orderJdDeal (Order order) {
        System.out.println(GlobalConstant.ORDER_JD + "====>" + order);
        orderMapper.insertSelective(order);
    }

    /**
     * 苏宁订单处理
     * @param order 消息
     */
    @RabbitHandler
    @RabbitListener(queues = GlobalConstant.ORDER_SN)
    public void orderSnDeal (Order order) {
        System.out.println(GlobalConstant.ORDER_SN + "====>" + order);
        orderMapper.insertSelective(order);
    }

    /**
     * 淘宝订单处理
     * @param order 消息
     */
    @RabbitHandler
    @RabbitListener(queues = GlobalConstant.ORDER_TB)
    public void orderTbDeal (Order order) {
        System.out.println(GlobalConstant.ORDER_TB + "====>" + order);
        orderMapper.insertSelective(order);
    }

    /**
     * 天猫订单处理
     * @param order 消息
     */
    @RabbitHandler
    @RabbitListener(queues = GlobalConstant.ORDER_TM)
    public void orderTmDeal (Order order) {
        System.out.println(GlobalConstant.ORDER_TM + "====>" + order);
        orderMapper.insertSelective(order);
    }
}

// 提醒一下， 发送类对象需要类实现序列化
/**
 * 订单实例
 * @author :master
 * @date :20200611
 */

@Data
public class Order  implements Serializable {
    private static final long serialVersionUID = 1L;

    private Long orderId;

    private String orderName;

    private String orderType;

    private String orderDetail;

    @Override
    public String toString() {
        return "Order{" +
                "orderId=" + orderId +
                ", orderName='" + orderName + '\'' +
                ", orderType='" + orderType + '\'' +
                ", orderDetail='" + orderDetail + '\'' +
                '}';
    }
}
  1. 创建生产者
/**
 * 订单生成接口
 * @author :master
 * @date :200200611
 */
@RestController
@RequestMapping("/order")
public class OrderController {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    
    @RequestMapping(value = "/generateOrder", method = RequestMethod.POST)
    public String generateOrder(Order order) {
        System.out.println("生产者信息：" + order.toString());
        rabbitTemplate.convertAndSend(GlobalConstant.ORDER_EXCHANGE, "order.guoMei" ,order);
        return "成功";
    }
    
}
  1. postman测试 调用接口
localhost:8099/order/generateOrder

在这里插入图片描述
在这里插入图片描述

至此呢， 基本的操作已经完成， 谢谢观赏 奉上代码
springboot集成rabbitmq 基础代码

一路向阳向北
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot整合rabbitmq的配置文件详解
weixin_44012722的博客
09-10 3674
1.基础信息 spring.rabbitmq.host: 默认localhost spring.rabbitmq.port: 默认5672 spring.rabbitmq.username: 用户名 spring.rabbitmq.password: 密码 spring.rabbitmq.virtual-host: 连接到代理时用的虚拟主机 spring.rabbitmq.addresses: 连接到server的地址列表（以逗号分隔），先addresses后host spring.rabbitmq.re
微服务之RabbitMQ安装
风中使者的博客
06-16 801
RabbitMQ是流行的开源消息队列系统。
SpringBoot整合RabbitMQ的快速使用教程
weixin_50348837的博客
05-28 1212
在分布式系统中，消息队列是一种重要的通信方式，它能够有效地将消息从一个应用程序传递到另一个应用程序。RabbitMQ是一款流行的开源消息队列系统，简单易用且功能强大。本文将介绍如何使用SpringBoot快速整合RabbitMQ，实现消息的发送和接收。。Fanout交换机会将接收到的所有消息广播到它知道的所有队列中。这种类型的交换机不考虑路由键，只是简单地将消息复制到所有绑定的队列中。适用于不需要选择性地发送消息给特定队列的情况，例如，广播系统通知或有多个服务需要消费同一份数据的场景。
RabbitMQ的简单介绍、安装及与SpringBoot整合构建高可用的消息传递方案
12-06
RabbitMQ的简单介绍、安装及与SpringBoot整合构建高可用的消息传递方案
rabbitmq和spring框架集成
这个名字想了很久
05-20 739
spring对amqp做了支持，目前只是做了Rabbitmq的实现。 集成后分为两个项目,一个是生产者,一个是消费者,完全模拟真实开发中应用场景,完整项目打包下载。rabbitmq-spring为生产者，rabbitmq-spring2为消费者。 1.生产者配置 rabbitmq.properties rabbitmq.host=192.168.1.101 rabbitmq.port=
Spring集成消息队列RabbitMQ
写完了没
08-26 2639
1. RabbitMQ简介1.1. RabbitMQRabbitMQ是由Erlang(爱立信公司)语言开发，实现Advanced Message Queuing Protocol (AMQP高级消息队列协议)的消息中间件。消息中间件主要用于组件之间的解耦，消息的发送者无需知道消息使用者的存在，反之亦然。1.2. 结构图 • Broker：消息队列服务器实体，例如RabbitMQ服务 •
springboot集成rabbitMQ之对象传输的方法
08-28
本文将详细介绍 Spring Boot 集成 RabbitMQ 之对象传输的方法，从 RabbitMQ 的安装、依赖配置、生产者配置、消费者配置等方面进行讲解，并结合实例代码进行说明。 一、RabbitMQ 的安装 RabbitMQ 的安装方法网上有...
springboot-rabbitmq实例.rar
01-08
Spring Boot提供了一个简洁的框架，使得集成RabbitMQ变得简单易行。 首先，我们需要在Spring Boot项目中添加RabbitMQ的相关依赖。这通常通过在`pom.xml`文件中引入`spring-boot-starter-amqp`来完成。例如： ```...
springboot+rabbitmq
03-21
在本项目中，`springboot-rabbitmq`目录下包含了实现三种不同模式的代码： 1. 队列模式（Queue Mode）：在RabbitMQ中，队列是消息的接收者。生产者将消息发送到队列，而消费者从队列中接收和处理消息。队列模式是最...
基于SpringBoot整合RabbitMQ发送邮件通知
04-30
本话题主要关注如何利用 SpringBoot 集成 RabbitMQ 来实现邮件通知功能，这在微服务间进行异步通信或触发业务流程时非常有用。 首先，让我们深入了解 SpringBoot。SpringBoot 是由 Pivotal 团队提供的全新框架，它...
springboot与rabbitmq结合的实战、实例项目
04-15
下面我们将深入探讨Spring Boot与RabbitMQ结合的实际应用和实例项目。 1. **Spring Boot简介** Spring Boot是由Pivotal团队提供的全新框架，旨在简化Spring应用的初始搭建以及开发过程。它通过提供预设的默认配置...
rabbitmq_demo
03-02
rabbitmq_demo
若依集成企业微信步骤
weixin_42926893的博客
03-21 1624
企业微信消息提醒、若依
Spring boot集成RabbitMq
初心魏的博客
06-20 3811
一、搭建RabbitMq 1.1 参考 RabbitMQ教程 二、使用教程 2.1 打开服务端 cmd 打开 C:\Program Files\RabbitMQ Server\rabbitmq_server-3.8.0\sbin， 输入：rabbitmq-plugins enable rabbitmq_management 出现: The following plugins have been...
SpringBoot整合RabbitMQ
qq_55946937的博客
05-31 2019
测试类ProducerApplicationTests.class。2.使用相同的交换机名称和队列名称启动前在web控制台删除旧模式创建的交换机和队列。DirectRabbitConfig.class改为。spring-boot-starter-parent在3.0以下。基本代码与fanout差不错，修改部分代码。代码与direct模式差不多，修改部分如下。1.使用不同的模式尽量使用不同的交换机名称和队列名称。
【RabbitMQ】集成和实战
猫巳的博客
06-13 131
erlang v19.2rabbitmq_server v3.6.6 与Spring集成 具体代码实现，参见rq-spring-with和rq-spring-with-consumer模块 pom文件 统一配置配置文件中增加命名空间 连接相关配置 生产者端RabbitTemplate 或下面这种声明方式也是可以的。 队列和交...
SpringBoot集成RabbitMQ（生产者）
weixin_42606421的博客
06-10 146
前面三步省略。
Springboot 整合RabbitMq ，用心看完这一篇就够了
热门推荐
默默不代表沉默
09-04 49万+
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建............
SpringBoot 2.3.12.RELEASE整合RabittMQ 3.8.12
weixin_48974246的博客
07-21 613
代码】SpringBoot2.3.12.RELEASE整合RabittMQ3.8.12。
SpringBoot RabbitMQ使用
最新发布
06-29
Spring Boot 和 RabbitMQ 结合使用可以帮助你轻松地在 Java 应用中集成消息队列，实现异步处理和解耦通信。以下是一个简要的介绍： 1. **Spring Boot**: Spring Boot 是一个流行的框架，它简化了构建基于 Spring 框架的应用程序的过程。它提供了一套自动配置功能，使开发者能够快速启动并运行应用。 2. **RabbitMQ**: RabbitMQ 是一个开源的消息代理（Message Broker），用于在分布式系统中存储和转发消息。它支持多种协议，如 AMQP，提供高可用性和可扩展性。 3. **集成 Spring Boot with RabbitMQ**: - 配置 RabbitMQ: 在 `application.properties` 或 `application.yml` 中添加 RabbitMQ 的连接信息，如主机名、端口、用户名、密码等。 - 添加依赖: 在 `pom.xml` 或 `build.gradle` 文件中引入 Spring Boot 的 RabbitMQ Starter。 - 创建 RabbitMQ 连接工厂: 使用 `ConnectionFactory` 创建连接到 RabbitMQ 服务器的实例。 - 发送和接收消息: 创建 `RabbitTemplate` 对象用于发送消息，`MessageListenerContainer` 或 `RabbitListener` 注解用于接收消息。 4. **消息类型**: 可以使用不同类型的消息，如直接模式、主题模式、队列模式等。 5. **异步处理**: 使用消息队列可以让处理任务异步执行，提高系统的响应速度。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值