Spring和SpringBoot整合RabbitMQ

最新推荐文章于 2024-07-15 20:00:00 发布
最新推荐文章于 2024-07-15 20:00:00 发布
阅读量170 收藏
点赞数
分类专栏： MQ 文章标签： rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lossdate/article/details/117341563
版权

Spring和SpringBoot整合RabbitMQ

一、Spring整合RabbitMQ

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>11</maven.compiler.source>
    <maven.compiler.target>11</maven.compiler.target>
</properties>

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

1. Producer

1.1 Config

@Configuration
public class RabbitConfig {

    /**
     * 连接工厂
     */
    @Bean
    public ConnectionFactory connectionFactory() {
        return new CachingConnectionFactory(URI.create("amqp://root:123456@192.168.200.136:5672/%2f"));
    }

    /**
     * RabbitTemplate
     */
    @Bean
    @Autowired
    public RabbitTemplate rabbitTemplate(ConnectionFactory factory) {
        return new RabbitTemplate(factory);
    }

    /**
     * RabbitAdmin
     */
    @Bean
    @Autowired
    public RabbitAdmin rabbitAdmin(ConnectionFactory factory) {
        return new RabbitAdmin(factory);
    }

    /**
     * Queue
     */
    @Bean
    public Queue queue() {
        return QueueBuilder.nonDurable("queue.anno").build();
    }

    /**
     * Exchange
     */
    @Bean
    public Exchange fanoutExchange() {
        return new FanoutExchange("ex.anno.fanout", false, false, null);
    }

    /**
     * Binding
     */
    @Bean
    @Autowired
    public Binding binding(Queue queue, Exchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with("key,anno").noargs();
    }

}

1.1 Producer

public class ProducerApp {
    public static void main(String[] args) throws Exception {
        AbstractApplicationContext context = new AnnotationConfigApplicationContext(RabbitConfig.class);

        RabbitTemplate template = context.getBean(RabbitTemplate.class);

        MessageProperties messageProperties = MessagePropertiesBuilder
                .newInstance()
                .setContentType(MessageProperties.CONTENT_TYPE_TEXT_PLAIN)
                .setContentEncoding("gbk")
                .setHeader("myKey", "myValue")
                .build();

        Message msg = MessageBuilder.withBody("Hello World".getBytes("gbk"))
                .andProperties(messageProperties)
                .build();

        template.send("ex.anno.fanout", "key.anno", msg);

        context.close();
    }
}

2. Consumer拉取推送消息

2.1 Config

@Configuration
public class RabbitConfig {

    /**
     * 连接工厂
     */
    @Bean
    public ConnectionFactory connectionFactory() {
        return new CachingConnectionFactory(URI.create("amqp://root:123456@192.168.200.136:5672/%2f"));
    }

    /**
     * RabbitTemplate
     */
    @Bean
    @Autowired
    public RabbitTemplate rabbitTemplate(ConnectionFactory factory) {
        return new RabbitTemplate(factory);
    }

    /**
     * RabbitAdmin
     */
    @Bean
    @Autowired
    public RabbitAdmin rabbitAdmin(ConnectionFactory factory) {
        return new RabbitAdmin(factory);
    }

    /**
     * Queue
     */
    @Bean
    public Queue queue() {
        return QueueBuilder.nonDurable("queue.anno").build();
    }

}

2.2 Consumer

public class ConsumerApp {
    public static void main(String[] args) throws Exception {
        AbstractApplicationContext context = new AnnotationConfigApplicationContext(RabbitConfig.class);

        RabbitTemplate template = context.getBean(RabbitTemplate.class);

        Message receive = template.receive("queue.anno");

        System.out.println(new String(receive.getBody(), receive.getMessageProperties().getContentEncoding()));

        context.close();
    }
}

3. Consumer消息监听（用于推消息）

3.1 Config

@ComponentScan("demo") //扫描包
@Configuration
@EnableRabbit
public class RabbitConfig {

    /**
     * 连接工厂
     */
    @Bean
    public ConnectionFactory connectionFactory() {
        return new CachingConnectionFactory(URI.create("amqp://root:123456@192.168.200.136:5672/%2f"));
    }

    /**
     * RabbitTemplate
     */
    @Bean
    @Autowired
    public RabbitTemplate rabbitTemplate(ConnectionFactory factory) {
        return new RabbitTemplate(factory);
    }

    /**
     * RabbitAdmin
     */
    @Bean
    @Autowired
    public RabbitAdmin rabbitAdmin(ConnectionFactory factory) {
        return new RabbitAdmin(factory);
    }

    /**
     * Queue
     */
    @Bean
    public Queue queue() {
        return QueueBuilder.nonDurable("queue.anno").build();
    }

    /**
     * SimpleRabbitListenerContainerFactory
     */
    @Bean("rabbitListenerContainerFactory")
    @Autowired
    public SimpleRabbitListenerContainerFactory simpleRabbitListenerContainerFactory(ConnectionFactory connectionFactory) {
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        factory.setConnectionFactory(connectionFactory);
        factory.setAcknowledgeMode(AcknowledgeMode.AUTO);
//        factory.setAcknowledgeMode(AcknowledgeMode.MANUAL);
//        factory.setAcknowledgeMode(AcknowledgeMode.NONE);
        //最少允许多少个并发的消费者
        factory.setConcurrentConsumers(10);
        //最大允许多少个并发的消费者
        factory.setMaxConcurrentConsumers(15);
        //按照批次消费消息，一个批次多少个
        factory.setBatchSize(10);

        return factory;
    }
}

3.2 MessageListener

@Component
public class MyMessageListener {

    /**
     * RabbitListener : 监听消息队列
     * com.rabbitmq.client.Channel channel对象
     * org.springframework.amqp.core.Message message对象 可以直接操作原生的AMQP消息
     * org.springframework.messaging.Message to use the messaging abstraction counterpart
     * @Payload 注解方法参数，改参数的值就是消息体
     * @Header 注解方法参数，访问指定的消息头字段的值
     * @Headers 该注解的方法参数获取该消息的消息头的所有字段，参数类型对应于map集合。
     * MessageHeaders 参数类型，访问所有消息头字段
     * MessageHeaderAccessor or AmqpMessageHeaderAccessor 访问所有消息头字段
     */
//    @RabbitListener(queues = "queue.anno")
//    public void onMessage(Message message) {
//        System.out.println(new String(message.getBody(), message.getMessageProperties().getContentEncoding()));
//    }

    @RabbitListener(queues = "queue.anno")
    public void onMessage(@Payload String messageStr) {
        System.out.println(messageStr);
    }
}

3.3 Consumer

public class ConsumerListenerApp {
    public static void main(String[] args) {
        new AnnotationConfigApplicationContext(RabbitConfig.class);
    }
}

二、SpringBoot整合RabbitMQ

1. Producer

1.1 构建Springboot 2.5.0 + Spring for RabbitMQ + Spring Web

1.2 application.properties

spring.application.name=springboot_rabbit
spring.rabbitmq.host=192.168.200.136
spring.rabbitmq.virtual-host=/
spring.rabbitmq.username=root
spring.rabbitmq.password=123456
spring.rabbitmq.port=5672

1.3 Config

@Configuration
public class RabbitConfig {

    @Bean
    public Queue queue() {
        return new Queue("queue.boot", false, false, false, null);
    }

    @Bean
    public Exchange exchange() {
//        new Exchange()
//        return new TopicExchange("topic.ex", false, false, null);
//        return new DirectExchange("direct.ex", false, false, null);
//        return new FanoutExchange("fanout.ex", false, false, null);
//        return new HeadersExchange("header.ex", false, false, null);
        //交换器名称，交换器类型（），是否是持久化的，是否自动删除，交换器属性Map集合
//        return new CustomExchange("custom.ex", ExchangeTypes.DIRECT, false, false, null);
        return new TopicExchange("ex.boot", false, false, null);
    }

    @Bean
    public Binding binding() {
        //绑定的目的地，绑定的类型：到交换器还是到队列，交换器名称，路由key，绑定的属性
//        new Binding("", Binding.DestinationType.EXCHANGE, "", "", null);
        //绑定的目的地，绑定的类型：到交换器还是到队列，交换器名称，路由key，绑定的属性
//        new Binding("", Binding.DestinationType.QUEUE, "", "", null);
        //绑定了交换器ex.boot到队列queue.boot，路由key是key.boot
        return new Binding("queue.boot",
                Binding.DestinationType.QUEUE,
                "ex.boot",
                "key.boot",
                null);
    }

}

1.4 Controller

@RestController
public class MessageController {

    private final AmqpTemplate rabbitTemplate;

    @Autowired
    public MessageController(AmqpTemplate rabbitTemplate) {
        this.rabbitTemplate = rabbitTemplate;
    }

    @RequestMapping("/rabbit/{message}")
    public String receive(@PathVariable String message) {

        MessageProperties messageProperties = MessagePropertiesBuilder
                .newInstance()
                .setContentType(MessageProperties.CONTENT_TYPE_TEXT_PLAIN)
                .setContentEncoding("utf-8")
                .setHeader("Hello", "World")
                .build();

        Message msg = MessageBuilder
                .withBody(message.getBytes(StandardCharsets.UTF_8))
                .andProperties(messageProperties)
                .build();

        //exchange + routing key + msg
        rabbitTemplate.send("ex.boot", "key.boot", msg);

        return "ok";
    }
}

2. Consumer(监听模式)

2.1 构建Springboot 2.5.0 + Spring for RabbitMQ

2.2 application.properties

spring.application.name=springboot_rabbit_consumer
spring.rabbitmq.host=192.168.200.136
spring.rabbitmq.virtual-host=/
spring.rabbitmq.username=root
spring.rabbitmq.password=123456
spring.rabbitmq.port=5672

2.3 Config

@Configuration
public class RabbitConfig {

    @Bean
    public Queue queue() {
        return QueueBuilder.nonDurable("queue.boot").build();
    }

}

2.4 ConsumerListener

@Component
public class MyMessageListener {

    @RabbitListener(queues = "queue.boot")
    public void getMyMessage(@Payload String messageStr, 
                             @Header(name = "Hello") String headerValue) {
        System.out.println(messageStr);
        System.out.println("Hello -> " + headerValue);
    }

}

3. 测试

3.1 启动Consumer和Producer

3.2 访问http://localhost:8080/rabbit/testMsg

可以看到Consumer控制台输出：
testMsg
Hello -> World
Lossdate
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【SpringBoot】43、SpringBoot中整合RabbitMQ实现延时队列（延时插件篇）
Asurplus
02-21 21万+
一、介绍 1、什么是延时队列？ 延时队列即就是放置在该队列里面的消息是不需要立即消费的，而是等待一段时间之后取出消费 2、适用场景 （1）商城订单超时未支付，取消订单 （2）使用权限到期前十分钟提醒用户 （3）收益项目，投入后一段时间后产生收益 二、实现方式 从以上场景中，我们可以看出，延时队列的主要功能就是在指定的时间之后做指定的事情，那么，我们思考有哪些工具我们可以使用？ 1、Redis 监听过期 Key 可以参考我的博客【SpringBoot】三十五、SpringBoot整合Redis监听Ke
SpringBoot+RabbitMQ
Copy_i的博客
09-07 758
SpringBoot、RabbitMQ、SpringBoot+RabbitMQ
Springboot+rabbitmq集成
10-25
文件内包含了rabbit安装的必需文件以及springboot整合rabbitmq的完整代码，代码里包含了原生的rabbitmq使用代码和整合springboot后的使用代码，还有rabbit队列的所有消息队列模式，代码简单易懂，解压打开就可以使用
springboot+rabbitmq
zziamalei的专栏
09-27 356
mq消息持久化 配置消息队列 package com.example.demo.durable; import org.springframework.amqp.core.Queue; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Confi...
SpringBoot 集成 RabbitMQ
爱笑的boy的博客
03-04 9410
SpringBoot 集成 RabbitMQ
Spring 整合RabbitMQ
zyq13870585230的博客
11-05 2838
目录1. 搭建生产者工程1.1. 创建工程1.2. 添加依赖1.3. 配置整合1.4. 发送消息2. 搭建消费者工程2.1. 创建工程2.2. 添加依赖5.2.3. 配置整合5.2.4. 消息监听器1）队列监听器2）广播监听器13）广播监听器24）星号通配符监听器5）井号通配符监听器6）井号通配符监听器2 1. 搭建生产者工程 1.1. 创建工程 1.2. 添加依赖 两个工程的pom.xml文件内容为如下： <?xml version="1.0" encoding="UTF-8"?> <
Spring Boot(五)——RabbitMQ
热门推荐
林元煌
12-12 2万+
RabbitMq的介绍 RabbitMq的基本原理可以自行上网查阅，或者点击传送门：RabbitMQ的基本原理。 使用配置 1、老规矩，先在pom.xml中添加相关依赖： &lt;!--消息队列模块--&gt; &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;ar...
Springboot整合RabbitMQ最简单demo
07-11
Springboot整合RabbitMQ最简单demo,适用于springcloud项目,作为消息总线适用,需要安装RabbitMQ,Mac linux可以使用命令行一键安装,在项目配置文件配置好端口即可(已默认配置),启动项目访问8080端口,参数见controller.
springBoot整合RabbitMQ案例
04-07
SpringBoot整合RabbitMQ是一个常见的后端开发任务，它涉及到分布式消息传递和Java应用程序的集成。RabbitMQ是一个开源的消息代理和队列服务器，而SpringBoot是基于Spring框架的简化版，提供了快速构建应用程序的方式...
springboot整合rabbitmq项目
01-30
SpringBoot整合RabbitMQ项目是将流行的Spring Boot框架与企业级消息中间件RabbitMQ结合，以实现高效、可靠的异步通信和解耦。在这个项目中，我们将探讨如何配置Spring Boot应用来使用RabbitMQ，以及相关的核心概念和...
Springboot整合RabbitMQ简单demo
01-22
本文将详细讲解如何在Spring Boot项目中整合RabbitMQ，并通过一个简单的示例来展示其实现过程。 首先，我们需要了解RabbitMQ的基本概念。RabbitMQ是一个开源的消息代理和队列服务器，遵循AMQP（Advanced Message ...
SpringBoot+RabbitMQ+WebSocket
04-25
使用SpringBoot搭建的简单项目，通过RabbitMQ消息队列接收消息，使用WebSocket推送至前台页面；testWebSocket.html是用于接收的静态页面，直接用浏览器打开即可
Springboot+RabbitMQ
xin_xin_jie的博客
05-06 155
生产者 @RestController public class OrderController { @Autowired private RabbitTemplate rabbitTemplate; @GetMapping("order") public String order(){ try { Thread.sleep(5); } catch (InterruptedException e) {
Spring Boot 集成 RabbitMQ
最新发布
空明的博客
07-15 1496
Spring Boot 集成 RabbitMQ ,记录一些交换器类型、消息投递及消息确认方式的使用。
java SpringBoot+rabbitmq
weixin_45725946的博客
11-05 1158
yml配置文件 ```java rabbitmq: host: 127.0.0.1 password: 123 port: 5672 username: test_user virtual-host: testhost listener: simple: auto-startup: true 消息的消费 import com.rabbitmq.client.Channel; import org.springframework
Messaging：Spring for RabbitMQ
BLOG域名:programb.blog.csdn.net
05-27 231
Getting Started Reference Documentation For further reference, please consider the following sections: Official Apache Maven documentation Spring Boot Maven Plugin Reference Guide Create an OCI image Spring Integration Spring for RabbitMQ Guides The foll
SpringBoot整合RabbitMQ：示例代码与解析
"本文主要介绍如何在Spring Boot项目中整合RabbitMQ，提供示例代码，帮助读者理解和实践这一过程。" 在Spring Boot项目中整合RabbitMQ，首先需要了解RabbitMQ的基本概念。RabbitMQ是一个开源的消息代理和队列服务器...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值