消息队列篇-简单使用

最新推荐文章于 2023-04-05 17:26:41 发布
最新推荐文章于 2023-04-05 17:26:41 发布
阅读量276 收藏 1
点赞数
分类专栏： gulimal-谷粒商城学习笔记 文章标签： rabbitmq 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Simon_09010817/article/details/118101185
版权

文章目录

一、引入springboot-amqp启动器

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

二、查看配置类RabbitAutoConfiguration

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.springframework.boot.autoconfigure.amqp;

import com.rabbitmq.client.Channel;
import java.time.Duration;
import java.util.List;
import java.util.stream.Collectors;
import org.springframework.amqp.core.AmqpAdmin;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.connection.ConnectionNameStrategy;
import org.springframework.amqp.rabbit.connection.RabbitConnectionFactoryBean;
import org.springframework.amqp.rabbit.core.RabbitAdmin;
import org.springframework.amqp.rabbit.core.RabbitMessagingTemplate;
import org.springframework.amqp.rabbit.core.RabbitOperations;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.support.converter.MessageConverter;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.boot.autoconfigure.amqp.RabbitProperties.Ssl;
import org.springframework.boot.autoconfigure.amqp.RabbitProperties.Template;
import org.springframework.boot.autoconfigure.amqp.RabbitProperties.Cache.Connection;
import org.springframework.boot.autoconfigure.amqp.RabbitRetryTemplateCustomizer.Target;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.autoconfigure.condition.ConditionalOnSingleCandidate;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.boot.context.properties.PropertyMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

@Configuration(
    proxyBeanMethods = false
)
@ConditionalOnClass({RabbitTemplate.class, Channel.class})
@EnableConfigurationProperties({RabbitProperties.class})
@Import({RabbitAnnotationDrivenConfiguration.class})
public class RabbitAutoConfiguration {
    public RabbitAutoConfiguration() {
    }

    @Configuration(
        proxyBeanMethods = false
    )
    @ConditionalOnClass({RabbitMessagingTemplate.class})
    @ConditionalOnMissingBean({RabbitMessagingTemplate.class})
    @Import({RabbitAutoConfiguration.RabbitTemplateConfiguration.class})
    protected static class MessagingTemplateConfiguration {
        protected MessagingTemplateConfiguration() {
        }

        @Bean
        @ConditionalOnSingleCandidate(RabbitTemplate.class)
        public RabbitMessagingTemplate rabbitMessagingTemplate(RabbitTemplate rabbitTemplate) {
            return new RabbitMessagingTemplate(rabbitTemplate);
        }
    }

    @Configuration(
        proxyBeanMethods = false
    )
    @Import({RabbitAutoConfiguration.RabbitConnectionFactoryCreator.class})
    protected static class RabbitTemplateConfiguration {
        protected RabbitTemplateConfiguration() {
        }

        @Bean
        @ConditionalOnSingleCandidate(ConnectionFactory.class)
        @ConditionalOnMissingBean({RabbitOperations.class})
        public RabbitTemplate rabbitTemplate(RabbitProperties properties, ObjectProvider<MessageConverter> messageConverter, ObjectProvider<RabbitRetryTemplateCustomizer> retryTemplateCustomizers, ConnectionFactory connectionFactory) {
            PropertyMapper map = PropertyMapper.get();
            RabbitTemplate template = new RabbitTemplate(connectionFactory);
            messageConverter.ifUnique(template::setMessageConverter);
            template.setMandatory(this.determineMandatoryFlag(properties));
            Template templateProperties = properties.getTemplate();
            if (templateProperties.getRetry().isEnabled()) {
                template.setRetryTemplate((new RetryTemplateFactory((List)retryTemplateCustomizers.orderedStream().collect(Collectors.toList()))).createRetryTemplate(templateProperties.getRetry(), Target.SENDER));
            }

            templateProperties.getClass();
            map.from(templateProperties::getReceiveTimeout).whenNonNull().as(Duration::toMillis).to(template::setReceiveTimeout);
            templateProperties.getClass();
            map.from(templateProperties::getReplyTimeout).whenNonNull().as(Duration::toMillis).to(template::setReplyTimeout);
            templateProperties.getClass();
            map.from(templateProperties::getExchange).to(template::setExchange);
            templateProperties.getClass();
            map.from(templateProperties::getRoutingKey).to(template::setRoutingKey);
            templateProperties.getClass();
            map.from(templateProperties::getDefaultReceiveQueue).whenNonNull().to(template::setDefaultReceiveQueue);
            return template;
        }

        private boolean determineMandatoryFlag(RabbitProperties properties) {
            Boolean mandatory = properties.getTemplate().getMandatory();
            return mandatory != null ? mandatory : properties.isPublisherReturns();
        }

        @Bean
        @ConditionalOnSingleCandidate(ConnectionFactory.class)
        @ConditionalOnProperty(
            prefix = "spring.rabbitmq",
            name = {"dynamic"},
            matchIfMissing = true
        )
        @ConditionalOnMissingBean
        public AmqpAdmin amqpAdmin(ConnectionFactory connectionFactory) {
            return new RabbitAdmin(connectionFactory);
        }
    }

    @Configuration(
        proxyBeanMethods = false
    )
    @ConditionalOnMissingBean({ConnectionFactory.class})
    protected static class RabbitConnectionFactoryCreator {
        protected RabbitConnectionFactoryCreator() {
        }

        @Bean
        public CachingConnectionFactory rabbitConnectionFactory(RabbitProperties properties, ObjectProvider<ConnectionNameStrategy> connectionNameStrategy) throws Exception {
            PropertyMapper map = PropertyMapper.get();
            CachingConnectionFactory factory = new CachingConnectionFactory((com.rabbitmq.client.ConnectionFactory)this.getRabbitConnectionFactoryBean(properties).getObject());
            properties.getClass();
            map.from(properties::determineAddresses).to(factory::setAddresses);
            properties.getClass();
            map.from(properties::isPublisherReturns).to(factory::setPublisherReturns);
            properties.getClass();
            map.from(properties::getPublisherConfirmType).whenNonNull().to(factory::setPublisherConfirmType);
            org.springframework.boot.autoconfigure.amqp.RabbitProperties.Cache.Channel channel = properties.getCache().getChannel();
            channel.getClass();
            map.from(channel::getSize).whenNonNull().to(factory::setChannelCacheSize);
            channel.getClass();
            map.from(channel::getCheckoutTimeout).whenNonNull().as(Duration::toMillis).to(factory::setChannelCheckoutTimeout);
            Connection connection = properties.getCache().getConnection();
            connection.getClass();
            map.from(connection::getMode).whenNonNull().to(factory::setCacheMode);
            connection.getClass();
            map.from(connection::getSize).whenNonNull().to(factory::setConnectionCacheSize);
            connectionNameStrategy.getClass();
            map.from(connectionNameStrategy::getIfUnique).whenNonNull().to(factory::setConnectionNameStrategy);
            return factory;
        }

        private RabbitConnectionFactoryBean getRabbitConnectionFactoryBean(RabbitProperties properties) throws Exception {
            PropertyMapper map = PropertyMapper.get();
            RabbitConnectionFactoryBean factory = new RabbitConnectionFactoryBean();
            properties.getClass();
            map.from(properties::determineHost).whenNonNull().to(factory::setHost);
            properties.getClass();
            map.from(properties::determinePort).to(factory::setPort);
            properties.getClass();
            map.from(properties::determineUsername).whenNonNull().to(factory::setUsername);
            properties.getClass();
            map.from(properties::determinePassword).whenNonNull().to(factory::setPassword);
            properties.getClass();
            map.from(properties::determineVirtualHost).whenNonNull().to(factory::setVirtualHost);
            properties.getClass();
            map.from(properties::getRequestedHeartbeat).whenNonNull().asInt(Duration::getSeconds).to(factory::setRequestedHeartbeat);
            Ssl ssl = properties.getSsl();
            if (ssl.determineEnabled()) {
                factory.setUseSSL(true);
                ssl.getClass();
                map.from(ssl::getAlgorithm).whenNonNull().to(factory::setSslAlgorithm);
                ssl.getClass();
                map.from(ssl::getKeyStoreType).to(factory::setKeyStoreType);
                ssl.getClass();
                map.from(ssl::getKeyStore).to(factory::setKeyStore);
                ssl.getClass();
                map.from(ssl::getKeyStorePassword).to(factory::setKeyStorePassphrase);
                ssl.getClass();
                map.from(ssl::getTrustStoreType).to(factory::setTrustStoreType);
                ssl.getClass();
                map.from(ssl::getTrustStore).to(factory::setTrustStore);
                ssl.getClass();
                map.from(ssl::getTrustStorePassword).to(factory::setTrustStorePassphrase);
                ssl.getClass();
                map.from(ssl::isValidateServerCertificate).to((validate) -> {
                    factory.setSkipServerCertificateValidation(!validate);
                });
                ssl.getClass();
                map.from(ssl::getVerifyHostname).to(factory::setEnableHostnameVerification);
            }

            properties.getClass();
            map.from(properties::getConnectionTimeout).whenNonNull().asInt(Duration::toMillis).to(factory::setConnectionTimeout);
            factory.afterPropertiesSet();
            return factory;
        }
    }
}

往容器中自动配置了RabbitMessagingTemplate、RabbitTemplate、AmqpAdmin、CachingConnectionFactory四个组件。

三、AmqpAdmin

在这里插入图片描述
AmqpAdmin配置spring和RabbitMQ连接信息，从配置文件中读取，以spring.rabbitmq开头

1.配置gulimall-order模块的yml文件

添加RabbitMQ连接信息
在这里插入图片描述

2.在启动类添加@EnableRabbit注解

开启RabbitMQ服务
在这里插入图片描述

3.使用AmqpAdmin创建Exchange交换器

@Slf4j
@SpringBootTest
@RunWith(SpringRunner.class)
class GulimallOrderApplicationTests {

	@Autowired
	AmqpAdmin amqpAdmin;

	//创建交换器
	@Test
	public void  createExchange(){
		//创建Direct类型交换器
		DirectExchange directExchange = new DirectExchange("java-direct-exchange", true, false);
		amqpAdmin.declareExchange(directExchange);
		log.info("交换器创建成功");
	}
}

在这里插入图片描述
创建成功：
在这里插入图片描述

4.使用AmqpAdmin创建Queue队列

public void  createQueue(){
	//创建Queue
	Queue queue = new Queue("java-queue", true, false,false);
	amqpAdmin.declareQueue(queue);
	log.info("队列创建成功");
}

在这里插入图片描述
创建成功：
在这里插入图片描述

5.使用AmqpAdmin创建Binding绑定

//创建绑定
@Test
public void  createBinding(){
	//创建Queue
	//String destination,   需要绑定的Queue/Exchange名称
	// Binding.DestinationType destinationType,  需要绑定类型：Queue/Exchange
	// String exchange, 	需要绑定的Exchange名称
	// String routingKey,   路由键
	// @Nullable Map<String, Object> arguments  参数
	Binding binding = new Binding("java-queue",
			Binding.DestinationType.QUEUE,
			"java-direct-exchange",
			"hello-java",
			null);
	amqpAdmin.declareBinding(binding);
	log.info("绑定成功");
}

在这里插入图片描述
绑定成功：
在这里插入图片描述

四、RabbitTemplate

1.发送字符串纯文本消息

@Autowired
RabbitTemplate rabbitTemplate;

@Test
public void sendMessageTest(){

	/**
	 * 发送消息
	 */
	rabbitTemplate.convertAndSend("java-direct-exchange","hello-java","第一条消息");
}

在这里插入图片描述
消息发送成功：
在这里插入图片描述
在这里插入图片描述

2.发送对象消息

@Autowired
RabbitTemplate rabbitTemplate;

@Test
public void sendMessageTest(){

	/**
	 * 发送消息
	 */
	OrderReturnApplyEntity orderReturnApplyEntity = new OrderReturnApplyEntity();
	orderReturnApplyEntity.setId(1L);
	orderReturnApplyEntity.setCreateTime(new Date());
	orderReturnApplyEntity.setSkuName("iPhone");
	
	rabbitTemplate.convertAndSend("java-direct-exchange","hello-java",orderReturnApplyEntity);
	log.info("发送成功");
}

在这里插入图片描述
对象必须实现Serializable接口。

1.默认序列化机制是jdk字节流

获取消息：
在这里插入图片描述

在这里插入图片描述

2.修改RabbitMQ序列化机制为JSON序列化

新建RabbitConfig配置类，在容器中重启注入自定义的messageConverter

package com.simon.gulimall.order.config;

import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.amqp.support.converter.MessageConverter;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MyRabbitConfig {
    @Bean
    public MessageConverter messageConverter(){
        return  new Jackson2JsonMessageConverter();
    }
}

MessageConverter 接口的实现，其中就有JacksonMessageConverter
在这里插入图片描述

3.再次发送对象消息

结果：变为JSON格式了。
在这里插入图片描述

五、监听消息RabbitListener、RabbitHandler

使用 @RabbitListener @RabbitHandler必须在启动类上加@EnableRabbit

1.@RabbitListener

在这里插入图片描述

//监听消息  进行消费
 @RabbitListener(queues = "java-queue")
 public void  recivedMessage(Message msg){
     byte[] body = msg.getBody();
     MessageProperties messageProperties = msg.getMessageProperties();
     System.out.println("body:"+new String(body));
     System.out.println("messageProperties:"+messageProperties);

 }

在这里插入图片描述
此时获取的body就是对象转成的json。可以直接使用对象进行接收，spring自动转换：
在这里插入图片描述

2.@RabbitHandler

如果监听同一个队列的两种或多种消息，进行不同逻辑的处理，这时就需要@RabbitListener和@RabbitHandler组合使用。

在这里插入图片描述
@RabbitListener(queues = “java-queue”)放在类上进行标注
@RabbitHandler放在方法上标注，表明监听

@Service("orderItemService")
@RabbitListener(queues = "java-queue")
public class OrderItemServiceImpl extends ServiceImpl<OrderItemDao, OrderItemEntity> implements OrderItemService {
    //监听消息  进行消费

    /**
     * 监听java-queue队列中OrderReturnApplyEntity的消息
     * @param msg
     * @param orderReturnApplyEntity
     */
    @RabbitHandler
    public void  recivedMessage(Message msg, OrderReturnApplyEntity orderReturnApplyEntity){
        System.out.println("orderReturnApplyEntity:"+orderReturnApplyEntity);

    }

    /**
     * 监听java-queue队列中OrderEntity的消息
     * @param msg
     * @param OrderEntity
     */
    @RabbitHandler
    public void  recivedMessage2(Message msg, OrderEntity orderEntity){
        System.out.println("orderEntity:"+orderEntity);

    }
 }
__Simon'
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
消息队列的简单使用
weixin_33862514的博客
03-02 85
2019独角兽企业重金招聘Python工程师标准>>> ...
消息队列--RabbitMQ简单使用
weixin_38299404的博客
07-14 140
安装使用 地址：http://www.rabbitmq.com/ 需要根据不同的版本选择不同的erlang 安装erlang 安装RabbitMQ首先需要安装erlang环境，根据GitHub上erlang中README配置yum源 将上面的内容写入红线标注的文件中保存退出，然后安装erlang yum update -y yum install -y erlang-23.3.4 安装RabbitMQ 下载完成RabbitMQ的安装包后执行下面的命令安装 yum install rabbitmq-
消息队列的简单介绍（一）
weixin_43138692的博客
11-10 565
文章目录一、什么是消息队列二、为何使用消息队列1.解耦2.异步（减少响应所需时间）3.削峰/限流三、消息队列的缺点1.系统复杂性提高2.系统可用性降低3.数据一致性问题四、消息队列的相关概念五、 各种MQ产品的比较六、 RocketMQ模型部署模型注意事项同步刷盘与异步刷盘： 一、什么是消息队列 消息队列可以简单理解为：把要传输的数据放在队列中。当我们需要使用消息的时候可以取出消息供自己使用。消息队列是分布式系统中重要的组件。 二、为何使用消息队列 使用消息队列主要是为了通过异步处理提高系统性能和削峰、降低
消息队列应用
阿姆斯特哩的博客
05-31 375
二、消息队列应用场景 以下介绍消息队列在实际应用中常用的使用场景。异步处理，应用解耦，流量削锋和消息通讯四个场景 2.1异步处理 场景说明：用户注册后，需要发注册邮件和注册短信。传统的做法有两种 1.串行的方式；2.并行方式 （1）串行方式：将注册信息写入数据库成功后，发送注册邮件，再发送注册短信。以上三个任务全部完成后，返回给客户端 （2）并行方式：将注册信息写入数据库成功后，发送注册邮件的同时，发送注册短信。以上三个任务完成后，返回给客户端。与串行的差别是，并行的方式可以提高处理的时间 .
linux消息队列能同时读写吗,消息队列在Linux中过时了吗？
weixin_33445134的博客
05-14 224
I've been playing with message queues (System V, but POSIX should be ok too) in Linux recently and they seem perfect for my application, but after reading The Art of Unix Programming I'm not sure if t...
httpsqs-1.3.tar.gz_linux 消息队列_消息队列
09-21
一个简单的使用示例可能包括创建消息队列、发布消息、订阅消息以及接收消息等操作。通过HTTP API，开发人员可以轻松地与httpsqs-1.3进行交互，实现异步处理和解耦合的系统架构。 六、httpsqs-1.3与其他消息队列的...
基于python实现操作redis及消息队列
09-08
本篇文章将深入探讨如何使用Python操作Redis以及实现消息队列。 首先，连接Redis服务器，Python中常用的Redis客户端库是`redis`。通过`ConnectionPool`创建连接池，如以下示例所示： ```python import redis ...
php+redis实现消息队列功能示例
10-16
本篇文章将详细讲解如何利用PHP和Redis来实现一个简单但实用的消息队列功能。 首先，我们需要理解消息队列的基本概念。消息队列是一种中间件，用于在不同进程之间传递消息，它可以将高并发时期的瞬时请求转化为异步...
laravel-queues:了解如何在Laravel中使用消息队列
05-11
这是一个简单的项目，用于演示如何在Laravel中使用消息队列。 在这个项目中，当用户注册我们的应用程序时，我们会将要发送的电子邮件排队。 如果您对消息队列的概念没有足够的了解，建议您在这篇出色的文章然后再...
Java使用starling分布式消息队列异步处理事务
05-26
本篇将详细探讨如何使用Starling这一分布式消息队列来实现异步处理事务。 首先，Starling是一个基于Java的轻量级消息中间件，它提供了一个高性能、可伸缩的消息传递机制，常用于构建分布式系统中的解耦和异步通信。...
Linux进程间通信（ipc）——消息队列
没实力的码农写的渣渣博客
12-04 238
消息队列是全双工通信方式，双方可以同时读写数据，读写数据后，数据依然在队列中没有消失。进行通信的两个进程所用的消息队列代码基本一样。 消息队列进项通信的进程1： #include<stdio.h> #include<stdlib.h> #include <sys/types.h> #include <sys/ipc.h> #include <sys/msg.h> #include<string.h> //int msgget(key_
spring-rabbitmq：connection&channel
我有个同桌
07-26 1503
不多说，先上代码，后面有空再具体写 Rabbitmq配置 /** * RabbitMq配置 * @author pig/xiaofa */ @Configuration @Slf4j public class RabbitmqConfig { @Value("${spring.rabbitmq.connection.limit:5}") private Intege...
SpringBoot自动配置原理
m0_53402665的博客
03-24 1797
1、SpringBoot会自动扫描每一个jar包下的META-INF/spring.factories文件，读取其中的内容并实例化 其中org.springframework.boot:spring-boot-autoconfigure中的spring.factories包含许多自动配置包 2、以RabbitAutoConfiguration为例 //表明这是一个配置类 @Configuration( /** * proxyBeanMethods=true或不写，是
Springboot RabbitMq源码解析之配置类
翻身已碰头的博客
12-07 2980
1. RabbitAutoConfiguration类 RabbitAutoConfiguration类是springboot的自动配置类。 @Configuration @ConditionalOnClass({ RabbitTemplate.class, Channel.class }) @EnableConfigurationProperties(RabbitProperties.class...
RabbitTemplate的创建与配置
最新发布
qq_37436172的博客
04-05 3669
RabbitTemplate是我们在与SpringAMQP整合的时候进行发送消息的关键类该类提供了丰富的发送消息的方法，包括可靠性消息投递、回调监听消息接口ConfirmCallback、返回值确认接口ReturnCallback等等同样我们需要注入到Spring容器中，然后直接使用。在与spring整合时需要实例化，但是在与Springboot整合时，只需要添加配置文件即可首先将其注入到bean里面：如果自己不注入。
SpringBoot框架下RabbitMQ消息接受功能的实现
Ciao's blog
01-31 1625
SpringBoot实现RabbitMQ消息功能
消息队列的基本使用
weixin_69776547的博客
08-26 1403
RabbitMQ的基本使用
消息队列(kafka简单使用)
weixin_73849581的博客
02-20 876
kafka
kubernets---kubernetes-client的使用--java中提交argo工作流
热门推荐
直到世界的尽头
03-08 1万+
转载请注明出处：java中提交argo工作流 背景 argo是一个建立在k8s框架之上的工作流调度工具。 详见 工作流workflow任务调度工具argo 需求是通过api来进行argo的调度脚本提交，不通过shell的手动提交方式。 方案思路 argo的提交 通过argo sumbit命令如下: argo submit --watch https://raw.githubusercontent....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值