rabbitmq进阶一

已于 2022-02-15 15:54:11 修改
阅读量2.1k 收藏
点赞数
分类专栏： JAVA高级篇 文章标签： rabbitmq boot集成rabbitmq rabbitmq的各种模式
于 2022-01-22 20:53:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_26565861/article/details/122640058
版权

上一篇文章有讲到rabbitmq的安装、web管理端和springboot简单集成rabbitmq

本文重点介绍rabbitmq相关api的使用

按照官网常用的五种模式的顺序：HelloWorld、Work queues、Publish/Subscribe、Routing、Topics

模式简单介绍

HelloWorld

一个生产者，一个队列，一个消费者。

一个demo，实际很少使用。

Work queues

在多个消费者之间分配任务，竞争消费模式。

Publish/Subscribe

发布订阅模式，同时向多个消费者发送消息。

Routing

选择性的接收消息

Topics

基于表达式接收消息

模式具体使用（rabbitmqclient）

HelloWorld

创建maven项目并且引入依赖

    <dependencies>
        <dependency>
            <groupId>com.rabbitmq</groupId>
            <artifactId>amqp-client</artifactId>
            <version>5.9.0</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
        </dependency>
    </dependencies>

创建工具类，用于处理连接和信道的创建，以及他们的关闭

package org.cc;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class ConnectionUtils {
    public static Connection createConnection() throws IOException, TimeoutException {
        ConnectionFactory connectionFactory = new ConnectionFactory();
//        connectionFactory.setHost("localhost");//默认主机：localhost
//        connectionFactory.setPort(5672);//默认端口5672
//        connectionFactory.setUsername("guest");//默认用户名：guest
//        connectionFactory.setPassword("guest");//默认密码：guest
//        connectionFactory.setVirtualHost("/");//默认虚拟主机：/
        return connectionFactory.newConnection();
    }
    public static void closeConnection(Connection connection, Channel channel) throws IOException, TimeoutException {
        channel.close();
        connection.close();
    }
}

创建消费者

package org.cc;

import com.rabbitmq.client.*;
import org.junit.Test;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class HelloWorldConsumer {
    @Test
    public void sendMsg() throws IOException, TimeoutException {
        Connection connection = ConnectionUtils.createConnection();
        Channel channel = connection.createChannel();
        /*
            声明一个名称是my helloworld queue，持久化，非独享，非自动删除的队列
            durable – 是否持久化，为true时重启rabbitmq服务，会保留原有的队列
            exclusive – 是否独享，为true时连接一旦断开，会自动删除队列
            autoDelete 是否自动删除，为true时一旦队列被消费，会自动删除队列
         */
        //若队列已存在，这些参数必须与队列一致，若队列不存在则创建
        channel.queueDeclare("my helloworld queue",true,false,false,null);

        channel.basicConsume("my helloworld queue",true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("helloworld consumer接收到消息："+new String(body));
            }
        });

        System.in.read();//保持消费者一直监听队列
    }
}

创建生产者

package org.cc;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import org.junit.Test;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.TimeoutException;

public class HelloWorldProducer {
    @Test
    public void sendMsg() throws IOException, TimeoutException {
        Connection connection = ConnectionUtils.createConnection();
        Channel channel = connection.createChannel();
        /*
            声明一个名称是my helloworld queue，持久化，非独享，非自动删除的队列
            durable – 是否持久化，为true时重启rabbitmq服务，会保留原有的队列
            exclusive – 是否独享，为true时连接一旦断开，会自动删除队列
            autoDelete 是否自动删除，为true时一旦队列被消费，会自动删除队列
         */
        //若队列已存在，这些参数必须与队列一致，若队列不存在则创建
        channel.queueDeclare("my helloworld queue",true,false,false,null);


        channel.basicPublish("","my helloworld queue",null,"helloworld消息内容".getBytes(StandardCharsets.UTF_8));

        ConnectionUtils.closeConnection(connection,channel);
    }
}

 若要保证rabbitmq重启后消息仍然存在，生产者发送消息时需要设置props参数

channel.basicPublish("","my helloworld queue", MessageProperties.PERSISTENT_TEXT_PLAIN,"helloworld消息内容".getBytes(StandardCharsets.UTF_8));

 开启手动ack，消费者接收到消息时，需要手动发送ack确认后消息才会真正从队列中删除

        channel.basicConsume("my helloworld queue",false,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("helloworld consumer接收到消息："+new String(body));
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        });

Work queues

创建消费者，与上面helloworld模式代码基本一致，将原有的创建消费者的代码重复一遍

package org.cc;

import com.rabbitmq.client.*;
import org.junit.Test;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class HelloWorldConsumer {
    @Test
    public void sendMsg() throws IOException, TimeoutException {
        Connection connection = ConnectionUtils.createConnection();
        Channel channel = connection.createChannel();
        /*
            声明一个名称是my helloworld queue，持久化，非独享，非自动删除的队列
            durable – 是否持久化，为true时重启rabbitmq服务，会保留原有的队列
            exclusive – 是否独享，为true时连接一旦断开，会自动删除队列
            autoDelete 是否自动删除，为true时一旦队列被消费，会自动删除队列
         */
        //若队列已存在，这些参数必须与队列一致，若队列不存在则创建
        channel.queueDeclare("my helloworld queue",true,false,false,null);

        channel.basicConsume("my helloworld queue",true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("helloworld consumer接收到消息："+new String(body));
            }
        });

        System.in.read();//保持消费者一直监听队列
    }
}

创建生产者，与上面helloworld模式代码基本一致，这里连续发送10条消息

package org.cc;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.MessageProperties;
import org.junit.Test;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.TimeoutException;

public class WorkProducer {
    @Test
    public void sendMsg() throws IOException, TimeoutException {
        Connection connection = ConnectionUtils.createConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare("my work queue",true,false,false,null);

        for (int i = 0; i < 10; i++) {
            channel.basicPublish("","my work queue", MessageProperties.PERSISTENT_TEXT_PLAIN,("work消息内容"+i).getBytes(StandardCharsets.UTF_8));
        }

        ConnectionUtils.closeConnection(connection,channel);
    }
}

 从消费者的控制台可以看到两个消费者轮流接收到消息

Publish/Subscribe

消费者

package org.cc;

import com.rabbitmq.client.*;
import org.junit.Test;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Subscriber {
    @Test
    public void receive() throws IOException, TimeoutException {
        Connection connection = ConnectionUtils.createConnection();
        Channel channel = connection.createChannel();
        channel.exchangeDeclare("fanout exchange", BuiltinExchangeType.FANOUT);
        channel.queueDeclare("my fanout queue1",true,false,false,null);
        channel.queueBind("my fanout queue1","fanout exchange","");
        channel.basicConsume("my fanout queue1",true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("my fanout queue1 consumer接收到消息："+new String(body));
            }
        });

        Connection connection1 = ConnectionUtils.createConnection();
        Channel channel1 = connection1.createChannel();
        channel1.queueDeclare("my fanout queue2",true,false,false,null);
        channel.queueBind("my fanout queue2","fanout exchange","");
        channel1.basicConsume("my fanout queue2",true,new DefaultConsumer(channel1){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("my fanout queue2 consumer接收到消息："+new String(body));
            }
        });

        System.in.read();//保持消费者一直监听队列
    }
}

生产者

package org.cc;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.MessageProperties;
import org.junit.Test;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.TimeoutException;

public class Publisher {
    @Test
    public void sendMsg() throws IOException, TimeoutException {
        Connection connection = ConnectionUtils.createConnection();
        Channel channel = connection.createChannel();
        channel.exchangeDeclare("fanout exchange", BuiltinExchangeType.FANOUT);

        channel.basicPublish("fanout exchange","", MessageProperties.PERSISTENT_TEXT_PLAIN,"fanout exchange消息内容".getBytes(StandardCharsets.UTF_8));

        ConnectionUtils.closeConnection(connection,channel);
    }
}

 队列需要同交换机绑定，生产者向交换机发送消息

Routing

消费者 

package org.cc;

import com.rabbitmq.client.*;
import org.junit.Test;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class RoutingKeyConsumer {
    @Test
    public void receive() throws IOException, TimeoutException {
        Connection connection = ConnectionUtils.createConnection();
        Channel channel = connection.createChannel();
        channel.exchangeDeclare("direct exchange", BuiltinExchangeType.DIRECT);
        channel.queueDeclare("my direct queue1",true,false,false,null);
        channel.queueBind("my direct queue1","direct exchange","info");
        channel.basicConsume("my direct queue1",true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("my direct queue1 consumer接收到消息："+new String(body));
            }
        });

        Connection connection1 = ConnectionUtils.createConnection();
        Channel channel1 = connection1.createChannel();
        channel1.queueDeclare("my direct queue2",true,false,false,null);
        channel.queueBind("my direct queue2","direct exchange","info");
        channel.queueBind("my direct queue2","direct exchange","error");
        channel1.basicConsume("my direct queue2",true,new DefaultConsumer(channel1){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("my direct queue2 consumer接收到消息："+new String(body));
            }
        });

        System.in.read();//保持消费者一直监听队列
    }
}

生产者

package org.cc;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.MessageProperties;
import org.junit.Test;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.TimeoutException;

public class RoutingProducer {
    @Test
    public void sendMsg() throws IOException, TimeoutException {
        Connection connection = ConnectionUtils.createConnection();
        Channel channel = connection.createChannel();
        channel.exchangeDeclare("direct exchange", BuiltinExchangeType.DIRECT);

        channel.basicPublish("direct exchange","info", MessageProperties.PERSISTENT_TEXT_PLAIN,"direct exchange info消息内容".getBytes(StandardCharsets.UTF_8));
        channel.basicPublish("direct exchange","error", MessageProperties.PERSISTENT_TEXT_PLAIN,"direct exchange error消息内容".getBytes(StandardCharsets.UTF_8));

        ConnectionUtils.closeConnection(connection,channel);
    }
}

Topics

交换机路由消息给队列时基于表达式，*匹配1个，#配置0个或1个或多个

例如：当队列1的路由值设置user.*，队列2的路由值设置user.#时，向交换机分别发送四条消息，消息的路由值分别为user.insert、user.insert.a、user.、user

此时队列1会收到路由值为user.insert和user.的消息，队列1能收到上面全部四条消息

消费者代码

package org.cc;

import com.rabbitmq.client.*;
import org.junit.Test;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class TopicsConsumer {
    @Test
    public void receive() throws IOException, TimeoutException {
        Connection connection = ConnectionUtils.createConnection();
        Channel channel = connection.createChannel();
        channel.exchangeDeclare("topic exchange", BuiltinExchangeType.TOPIC);
        channel.queueDeclare("my topic queue1",true,false,false,null);
        channel.queueBind("my topic queue1","topic exchange","user.*");
        channel.basicConsume("my topic queue1",true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("my topic queue1 consumer接收到消息："+new String(body));
            }
        });

        Connection connection1 = ConnectionUtils.createConnection();
        Channel channel1 = connection1.createChannel();
        channel1.queueDeclare("my topic queue2",true,false,false,null);
        channel.queueBind("my topic queue2","topic exchange","user.#");
        channel1.basicConsume("my topic queue2",true,new DefaultConsumer(channel1){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("my topic queue2 consumer接收到消息："+new String(body));
            }
        });

        System.in.read();//保持消费者一直监听队列
    }
}

生产者代码

package org.cc;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.MessageProperties;
import org.junit.Test;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.TimeoutException;

public class TopicsProducer {
    @Test
    public void sendMsg() throws IOException, TimeoutException {
        Connection connection = ConnectionUtils.createConnection();
        Channel channel = connection.createChannel();
        channel.exchangeDeclare("topic exchange", BuiltinExchangeType.TOPIC);

        channel.basicPublish("topic exchange","user.insert", MessageProperties.PERSISTENT_TEXT_PLAIN,"topic exchange user.insert消息内容".getBytes(StandardCharsets.UTF_8));
        channel.basicPublish("topic exchange","user.insert.a", MessageProperties.PERSISTENT_TEXT_PLAIN,"topic exchange user.insert.a消息内容".getBytes(StandardCharsets.UTF_8));
        channel.basicPublish("topic exchange","user.", MessageProperties.PERSISTENT_TEXT_PLAIN,"topic exchange user.消息内容".getBytes(StandardCharsets.UTF_8));
        channel.basicPublish("topic exchange","user", MessageProperties.PERSISTENT_TEXT_PLAIN,"topic exchange user消息内容".getBytes(StandardCharsets.UTF_8));

        ConnectionUtils.closeConnection(connection,channel);
    }
}

模式具体使用（springboot集成rabbitmq）

使用idea构建项目，选择spring initializer，创建生产者项目springboot-rabbitmq-producer

  dependencies选择如下

 application.properties设置如下

 使用同样的方式创建消费者项目springboot-rabbitmq-consumer，将server.port设置为8081

当前springboot版本最新为2.6.3

HelloWorld

创建消费者并启动消费者应用

package com.example.springbootrabbitmqconsumer.helloworld;

import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * springboot-rabbitmq-producer
 *
 * @author v_choncheng
 * @description
 * @create 2022-02-15 14:42
 */
@Component
@RabbitListener(queuesToDeclare = @Queue("helloworld"))
public class HelloWorldConsumer {

    @RabbitHandler
    public void receive(String msg) {
        System.out.println("消费者接受到消息" + msg);
    }

}

创建生产者

package com.example.springbootrabbitmqproducer.helloworld;

import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * springboot-rabbitmq-producer
 *
 * @author v_choncheng
 * @description
 * @create 2022-02-15 14:42
 */
@Configuration
public class HelloWorldProducer {

    @Bean
    public Queue createQueue() {
        return new Queue("helloworld");
    }
}

生产者工程测试类中增加测试方法

 运行此测试方法后可以看到消费者接收到一条消息


Work queues

创建消费者并启动消费者应用

package com.example.springbootrabbitmqconsumer.workqueues;

import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * springboot-rabbitmq-consumer
 *
 * @author v_choncheng
 * @description
 * @create 2022-02-15 15:11
 */
@Component
public class WorkQueuesConsumer {

    @RabbitListener(queuesToDeclare = @Queue("workqueues"))
    public void receive1(String msg) {
        System.out.println("消费者1接受到消息" + msg);
    }

    @RabbitListener(queuesToDeclare = @Queue("workqueues"))
    public void receive2(String msg) {
        System.out.println("消费者2接受到消息" + msg);
    }
}

生产者工程测试类中增加测试方法

运行此测试方法后可以看到消费者1、2轮流接收到消息


Publish/Subscribe

创建消费者并启动消费者应用

package com.example.springbootrabbitmqconsumer.fanout;

import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * springboot-rabbitmq-consumer
 *
 * @author v_choncheng
 * @description
 * @create 2022-02-15 15:23
 */
@Component
public class FanoutConsumer {

    @RabbitListener(bindings = @QueueBinding(exchange = @Exchange(type = ExchangeTypes.FANOUT, name = "fanoutexchange"), value = @Queue("fanoutqueues1")))
    public void receive1(String msg) {
        System.out.println("消费者1接受到消息" + msg);
    }

    @RabbitListener(bindings = @QueueBinding(exchange = @Exchange(type = ExchangeTypes.FANOUT, name = "fanoutexchange"), value = @Queue("fanoutqueues2")))
    public void receive2(String msg) {
        System.out.println("消费者2接受到消息" + msg);
    }
}

生产者工程测试类中增加测试方法

 运行此测试方法后可以看到消费者1、2同时接收到消息


Routing

创建消费者并启动消费者应用

package com.example.springbootrabbitmqconsumer.routing;

import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * springboot-rabbitmq-consumer
 *
 * @author v_choncheng
 * @description
 * @create 2022-02-15 15:38
 */
@Component
public class RoutingConsumer {

    @RabbitListener(bindings = @QueueBinding(exchange = @Exchange(type = ExchangeTypes.DIRECT, name = "routingexchange"), value = @Queue("routingqueues1"), key = {
            "debug", "verbose", "notice", "warning"}))
    public void receive1(String msg) {
        System.out.println("消费者1接受到消息" + msg);
    }

    @RabbitListener(bindings = @QueueBinding(exchange = @Exchange(type = ExchangeTypes.DIRECT, name = "routingexchange"), value = @Queue("routingqueues2"), key = {
            "debug", "verbose"}))
    public void receive2(String msg) {
        System.out.println("消费者2接受到消息" + msg);
    }
}

生产者工程测试类中增加测试方法

 运行此测试方法后可以看到消费者1接收四条消息、消费者2只接收到debug和verbose消息


Topics

创建消费者并启动消费者应用

package com.example.springbootrabbitmqconsumer.topics;

import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * springboot-rabbitmq-consumer
 *
 * @author v_choncheng
 * @description
 * @create 2022-02-15 15:38
 */
@Component
public class TopicsConsumer {

    @RabbitListener(bindings = @QueueBinding(exchange = @Exchange(type = ExchangeTypes.TOPIC, name = "topicexchange"), value = @Queue("topicqueues1"), key = {
            "user.*"}))
    public void receive1(String msg) {
        System.out.println("消费者1接受到消息" + msg);
    }

    @RabbitListener(bindings = @QueueBinding(exchange = @Exchange(type = ExchangeTypes.TOPIC, name = "topicexchange"), value = @Queue("topicqueues2"), key = {
            "user.#", "verbose"}))
    public void receive2(String msg) {
        System.out.println("消费者2接受到消息" + msg);
    }
}

生产者工程测试类中增加测试方法

 运行此测试方法后可以看到消费者2接收四条消息、消费者1只接收到user.和user.insert消息

RabbitMQ进阶
liushaojiax的博客
03-16 1038
每个RabbitTemplate只能配置一个ReturnCallback，因此需要在项目加载时配置：@Slf4j@Override// 获取RabbitTemplate// 设置ReturnCallback// 投递失败，记录日志log.info("消息发送失败，应答码{}，原因{}，交换机{}，路由键{},消息{}",// 如果有业务需要，可以重发消息});ConfirmCallback可以在发送消息时指定，因为每个业务处理confirm成功或失败的逻辑不一定相同。// 1.消息体。
RabbitMQ进阶篇
最新发布
bill的博客
06-30 366
通过设置消息的超时时间，我们可以将那些未能在预期时间内被消费的消息自动转入死信队列。这种方法既利用了RabbitMQ的死信机制，又通过超时设置增加了一层保障，确保了消息在一定时间后得到妥善处理。消息超时是确保消息在一定时间内被消费的一种机制。如果消息在设定的时间内未被消费，它将根据配置被删除或进行其他处理。在某些场景下，我们可能需要确保消息在特定的时间后才能被消费，这就需要用到延迟队列的概念。通过上述策略，我们可以显著提高RabbitMQ消息传递的可靠性，确保消息在各种故障情况下都能得到妥善处理。
RabbitMq Queue/RabbitListener注解参数详解
u014792378的博客
08-12 1万+
@Queue注解为我们提供了队列相关的一些属性，具体如下： name: 队列的名称； durable: 是否持久化； exclusive: 是否独享、排外的； autoDelete: 是否自动删除； arguments：队列的其他属性参数，有如下可选项，可参看图2的arguments： x-message-ttl：消息的过期时间，单位：毫秒； x-expires：队列过期时间，队列在多长时间未被访问将被删除，单位：毫秒； x-max-
RabbitMQ的并发参数（concurrency和prefetch）
海子@幸福人
12-14 1万+
版本信息： JDK：8 SpringBoot 2.1.3.RELEASE RabbitMQ消费端配置： spring: rabbitmq: host: localhost port: 5672 username: guest password: guest listener: simple: # acknowledge-mode: manual # 手动确定（默认自动确认） concurrency: 1 # 消费.
RabbitMQ高级功能详解以及常用插件实战
Zhuxiaoyu_91的博客
07-25 1494
RabbitMQ高级功能详解以及常用插件实战
消息中间件RabbitMQ
xxy的博客
12-08 1667
MQ：Message Queue，消息队列 MOM：Message Oriented Middleware，面向消息的中间件 主流实现方式： JMS：Java Message Service，java消息服务。java规范；只能使用java实现；只有两种消息模型。（ActiveMQ） AMQP：Advanced Message Queueing Protocol，高级消息队列协议。本质上是协议，只规定了数据格式；任何语言都可以实现；可以有任意多种消息模型。（RabbitMQ） 三个主要作用： 1.异步 2.
SpringBoot整合RabbitMQ ——Direct模式
祝我飞黄腾达
03-22 3056
背景 上篇博文讲述了fanout广播模式，只要绑定该类型的交换机的所有队列，都会接收到该交换机的消息。而direct模式是针对广播模式的一种升级，对绑定的队列进行分类，投递消息时指定一个RountingKey，只有RountingKey 与 BindingKey 匹配的队列，消息才会被投递进去。 假设我们有一个订单系统，用户进行下单支付，下单成功后，根据业务处理一般都会消息通知用户相关信息。例如通过邮件+手机+qq 等方式进行消息推送支付成功信息。 由上图可知，每个队列与交换机都绑定
rabbitmq进阶
07-27
- *1* [Rabbitmq进阶](https://blog.csdn.net/weixin_46634416/article/details/124755747)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc...
rabbitmq进阶用法
09-15
1. 使用事务：事务能够解决消息发送方和RabbitMQ之间消息确认的问题。只有消息成功被RabbitMQ接收，事务才能提交成功，否则可以进行事务回滚，并进行消息重发。但是需要注意，使用事务机制可能会降低RabbitMQ的性能...
RabbitMQ 进阶 -- 阿里云服务器部署RabbitMQ集群
Huangjiazhen711的博客
10-29 1055
如果RabbitMQ集群只有一个broker节点，那么该节点的失效将导致整个服务临时性的不可用，并且可能会导致message的丢失（尤其是在非持久化message存储于非持久化queue中的时候）。可以将所有message都设置为持久化，并且使用持久化的queue，但是这样仍然无法避免由于缓存导致的问题：因为message在发送之后和被写入磁盘并执行fsync之间存在一个虽然短暂但是会产生问题的时间窗。
@RabbitListener常用总结
m0_67920613的博客
01-16 5143
是 Spring AMQP 提供的注解，用于简化 RabbitMQ 消息监听器的创建。通过在方法上添加注解，可以将方法注册为消息监听器，用于处理从 RabbitMQ 中接收到的消息。以下是。
(四) RabbitMQ实战教程(面向Java开发人员)之@RabbitListener消息消费
热门推荐
黄太洪的博客
03-13 1万+
使用RabbitListener注解进行消息消费在前一篇博客中我们往MessageListenerContainer设置了MessageListener进行消息的消费，本篇博客将介绍一种更为简单的消息消费方式:使用@RabbitListener注解方式。使用RabbitListener进行消息的消费步骤如下:1.在启动类上添加@EnableRabbit注解 2.在Spring容器中托管一个Rabbi
【RabbitMQ-2】RabbitMQ的并发参数（concurrency和prefetch）
m0_67401545的博客
03-29 2660
文章目录 1. 环境配置 2. prefetch属性 3. concurrency属性 4. prefetch和concurrency属性 推荐阅读 1. 环境配置 版本信息： JDK：8 SpringBoot 2.1.3.RELEASE RabbitMQ消费端配置 spring: rabbitmq: host: localhost port: 5672 username: guest password: guest listener:
RabbitMQ：@RabbitListener 与 @RabbitHandler 及 消息序列化
weixin_38081382的博客
08-10 2434
SimpleMessageConverter 对于要发送的消息体 body 为 byte[] 时不进行处理，如果是 String 则转成字节数组,如果是 Java 对象，则使用 jdk 序列化将消息转成字节数组，转出来的结果较大，含class类名，类相应方法等信息。@RabbitListener 标注在类上面表示当有收到消息的时候，就交给 @RabbitHandler 的方法处理，具体使用哪个方法处理，根据 MessageConverter 转换后的参数类型。...
Spring Cloud 学习笔记6——消息总线
wudiyong22的专栏
06-22 2833
消息总线和配置中心是微服务架构的两个重要组件 Spring Cloud Bus目前仅支持两款中间件产品：RabbitMQ和Kafka RabbitMQ及Kafka安装请看消息队列相关笔记 整合RabbitMQ 1、引入AMQP依赖 pom.xml文件中加入： &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot...
Spring Boot 整合RabbitMQ 解决分布式事务
weixin_38982591的博客
03-07 850
项目说明： 模拟外卖案例，用户下单之后，调用订单服务，然后订单服务间消息发给派送服务通知外卖人员送餐，订单系统与派单系统采用MQ异步通讯。 RabbitMQ解决分布式事务原理方案 确保生产者一定要将数据投递到MQ服务器中 生产者采用confirm，确认应答机制 如果失败，生产者进行重试。 MQ消费者消息能够正常消费消息。 采用手动ACK模式，使用补偿机制，注意幂等性问题。 ...
Springboot RabbitMq源码解析之RabbitListener注解
翻身已碰头的博客
02-19 1万+
Springboot RabbitMq源码解析之配置类 Springboot RabbitMq源码解析之消息发送 Springboot RabbitMq源码解析之消费者容器SimpleMessageListenerContainer Springboot RabbitMq源码解析之consumer管理和AmqpEvent ...
RabbitMQ:排他性队列（Exclusive Queue)
weixin_30505751的博客
06-28 1206
如果你想创建一个只有自己可见的队列，即不允许其它用户访问，RabbitMQ允许你将一个Queue声明成为排他性的（Exclusive Queue）。 该队列的特点是： 只对首次声明它的连接（Connection）可见 会在其连接断开的时候自动删除。 对于第一点，首先是强调首次声明，因为另外一个连接无法声明一个同样的排他性队列；其次是只区别连接（Connection）而不是通道（...
spring rabbitmq 整合配置
道德菩提
05-14 3506
以上是我的applicationContext-mq.xml 配置(对一些名称有一些手动的修改  因为有些不该出现的东东.so 希望亲人们在参考的时候注意下名称关联关系是否统一)
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值