消息队列 - Springboot2.0 + RabbitMQ3.8.5搭建、配置、集成与使用_spring.rabbitmq.virtual-host

作者：盐析白兔 | 2024-05-14 12:57:59

踩

spring.rabbitmq.virtual-host

目录

应用场景

快速搭建

管理界面创建虚拟host

SpringBoot2.x + RabbitMq3.8.5

---direct exchange一对一直连型交换机

测试

---Topic Exchange主题交换机

消息的回调

生产者的消息确认

消费者接收到消息的消息确认

RabbitMQ的一些yml参数:

应用场景

RabbitMQ遵循AMQP协议，RabbitMQ的broker由Exchange,Binding,queue组成，其中exchange和binding组成了消息的路由键；客户端Producer通过连接channel和server进行通信，Consumer从queue获取消息进行消费（长连接，queue有消息会推送到consumer端，consumer循环从输入流读取数据）。rabbitMQ以broker为中心；有消息的确认机制。
rabbitMQ在吞吐量方面稍逊于kafka，他们的出发点不一样，rabbitMQ支持对消息的可靠的传递，支持事务，不支持批量的操作；基于存储的可靠性的要求存储可以采用内存或者硬盘，rabbitMQ的负载均衡需要单独的loadbalancer进行支持。

相比较kafka，rabbitmq适合可靠，对速度要求不高的场景

kafka具有高的吞吐量，内部采用消息的批量处理，zero-copy机制，数据的存储和获取是本地磁盘顺序批量操作，具有O(1)的复杂度，消息处理的效率很高。kafka遵从一般的MQ结构，producer，broker，consumer，以consumer为中心，消息的消费信息保存的客户端consumer上，consumer根据消费的点，从broker上批量pull数据；无消息确认机制。

快速搭建

rabbitMq的安装-liunx：https://blog.csdn.net/qq_44695727/article/details/107381694

流程：消息推送服务，将消息推送到 rabbitMq的服务器，然后经过服务器里面的交换机、队列等各种关系将数据处理入列后，最终消费者获取对应监听的消息。

常用的交换机有三种:

Direct Exchange
直连型交换机，根据消息携带的路由键将消息投递给对应队列。一对一，多台监听绑定到同一个直连交互的同一个队列，会轮询的方式对消息进行消费，不存在重复消费
Fanout Exchange
扇型交换机，这个交换机没有路由键概念，就算你绑了路由键也是无视的。这个交换机在接收到消息后，会直接转发到绑定到它上面的所有队列。
Topic Exchange
主题交换机，这个交换机其实跟直连交换机流程差不多，但是它的特点就是在它的路由键和绑定键之间是有规则的。
简单地介绍下规则：
* (星号) 用来表示一个单词 (必须出现的),例如 绑定键为 *.TT.* ，对应消息携带的路由键为 A.TT.B
# (井号) 用来表示任意数量（零个或多个）单词，例如绑定键为TT.#，对应消息携带的路由键为TT.AA.B，队列的绑定键为 "#"（井号）的时候，这个队列将会无视消息的路由键，接收所有的消息

管理界面创建虚拟host

1、超级管理员(administrator),可登陆管理控制台，可查看所有的信息，并且可以对用户，策略(policy)进行操作。
2、监控者(monitoring),可登陆管理控制台，同时可以查看rabbitmq节点的相关信息(进程数，内存使用情况，磁盘使用情况等)
3、策略制定者(policymaker),可登陆管理控制台, 同时可以对policy进行管理。但无法查看节点的相关信息
4、普通管理者(management),仅可登陆管理控制台，无法看到节点信息，也无法对策略进行管理。
5、其他,无法登陆管理控制台，通常就是普通的生产者和消费者。

创建完回到admin管理界面点击新建的账户名称admin

SpringBoot2.x + RabbitMq3.8.5

maven依赖
        
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
application.yml
spring:
  rabbitmq:
    host: 192.168.1.114
    port: 5672
    username: root
    password: root
    # 虚拟host 可以不设置,使用server默认host
    # virtual-host: AdminHosts
    virtual-host: /
---direct exchange一对一直连型交换机
RabbiMQConfig配置类
 
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
/**
 * durable:是否持久化,默认是false,持久化队列：会被存储在磁盘上，当消息代理重启时仍然存在，暂存队列：当前连接有效
 * exclusive:默认也是false，只能被当前创建的连接使用，而且当连接关闭后队列即被删除。此参考优先级高于durable
 * autoDelete:是否自动删除，当没有生产者或者消费者使用此队列，该队列会自动删除。
 * @Author: szw
 * @Date: 2020/7/16 20:06
 */
@Configuration
public class RabbiMQConfig {
 
    public static final String ITEM_ROUTING_KEY = "myQueue";
 
    /**
     * 声明队列
     * @return Queue
     */
    @Bean("itemQueue")
    public Queue itemQueue() {
        // return new Queue("TestDirectQueue",true,true,false); 一般设置一下队列的持久化就好,其余两个就是默认false
        return new Queue("myQueue", true);
    }
 
    /**
     * 声明交换机-direct exchange一对一直连型交换机
     * @return DirectExchange
     */
    @Bean("directExchange")
    public DirectExchange directExchange() {
        return new DirectExchange("myDirectExchange", true, false);
    }
 
    /**
     * 绑定队列和交换机
     * @return Binding
     */
    @Bean
    public Binding binding() {
        return BindingBuilder.bind(itemQueue()).to(directExchange()).with(ITEM_ROUTING_KEY);
    }
}
RabbitConsumer消费者
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
 
/**
 * @Author: szw
 * @Date: 2020/7/16 19:45
 */
 
@Component
public class RabbitConsumer {
    protected static final Log LOGGER = LogFactory.getLog(RabbitConsumer.class);
 
    @RabbitListener(queues = "myQueue")
    public void onMessage(String content) {
        LOGGER.info("收到Rabbit消息：" + content);
    }
}
TestController测试生产者
    @RequestMapping("/send")
    @ResponseBody
    public int send(Integer index) {
        for (int i = 0; i < index; i++){
            String content = UUID.randomUUID().toString();
            rabbitTemplate.convertAndSend("myQueue",i + 1 + "---" + content);
        }
 
        return index;
    }
测试

Postman

console

---Topic Exchange主题交换机

Topic Exchange同时也拥有扇形交换机和直连交换机的功能。
TopicRabbitConfig配置
 
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
/**
 * @Author: szw
 * @Date: 2020/7/17 14:48
 */
@Configuration
public class TopicRabbitConfig {
 
    //绑定键
    public final static String TOPIC_MAN = "topic.man";
    public final static String TOPIC_WOMAN = "topic.woman";
    //主题交换机
    public final static String TOPIC_EXCHANGE = "topicExchange";
 
    @Bean
    public Queue firstQueue() {
        return new Queue(TopicRabbitConfig.TOPIC_MAN);
    }
 
    @Bean
    public Queue secondQueue() {
        return new Queue(TopicRabbitConfig.TOPIC_WOMAN);
    }
 
    @Bean
    TopicExchange exchange() {
        return new TopicExchange(TOPIC_EXCHANGE);
    }
 
    //将firstQueue和topicExchange绑定,而且绑定的键值为topic.man
    //这样只要是消息携带的路由键是topic.man,才会分发到该队列
    @Bean
    Binding bindingExchangeMessage() {
        return BindingBuilder.bind(firstQueue()).to(exchange()).with(TOPIC_MAN);
    }
 
    //将secondQueue和topicExchange绑定,而且绑定的键值为用上通配路由键规则topic.#
    // 这样只要是消息携带的路由键是以topic.开头,都会分发到该队列
    @Bean
    Binding bindingExchangeMessage2() {
        return BindingBuilder.bind(secondQueue()).to(exchange()).with("topic.#");
    }
}
消费者
TopicTotalConsumer queues = TOPIC_WOMAN
TopicManConsumer queues = TOPIC_MAN
 
import com.awb.init.TopicRabbitConfig;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
 
import java.util.Map;
 
/**
 * @Author: szw
 * @Date: 2020/7/17 14:57
 */
@Component
@RabbitListener(queues = TopicRabbitConfig.TOPIC_WOMAN)
public class TopicTotalConsumer {
    protected static final Log LOGGER = LogFactory.getLog(TopicTotalConsumer.class);
 
    @RabbitHandler
    public void process(Map testMessage) {
        LOGGER.info("TopicTotalConsumer消费者收到消息  : " + testMessage.toString());
    }
}
 
import com.awb.init.TopicRabbitConfig;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
 
import java.util.Map;
 
/**
 * @Author: szw
 * @Date: 2020/7/17 15:02-
 */
@Component
@RabbitListener(queues = TopicRabbitConfig.TOPIC_MAN)
public class TopicManConsumer {
    protected static final Log LOGGER = LogFactory.getLog(TopicManConsumer.class);
 
    @RabbitHandler
    public void process(Map testMessage) {
        LOGGER.info("TopicManConsumer消费者收到消息  : " + testMessage.toString());
    }
}
TestController测试接口
    @RequestMapping("/send/topic/man")
    @ResponseBody
    public String sendTopicMessage1() {
        String messageId = String.valueOf(UUID.randomUUID());
        String messageData = "message: TOPIC_MAN ";
        Map<String, Object> manMap = new HashMap<>();
        manMap.put("messageId", messageId);
        manMap.put("messageData", messageData);
        rabbitTemplate.convertAndSend(TopicRabbitConfig.TOPIC_EXCHANGE, TopicRabbitConfig.TOPIC_MAN, manMap);
        return "ok";
    }
 
    @RequestMapping("/send/topic/woman")
    @ResponseBody
    public String sendTopicMessage2() {
        String messageId = String.valueOf(UUID.randomUUID());
        String messageData = "message: TOPIC_WOMAN is all ";
        Map<String, Object> womanMap = new HashMap<>();
        womanMap.put("messageId", messageId);
        womanMap.put("messageData", messageData);
        rabbitTemplate.convertAndSend(TopicRabbitConfig.TOPIC_EXCHANGE, TopicRabbitConfig.TOPIC_WOMAN, womanMap);
        return "ok";
    }
Postman测试

消息的回调

生产者的消息确认

（生产者推送消息成功，消费者接收消息成功）
回调函数：
   ConfirmCallback，推送到交换机返回true，没有返回false
   RetrunCallback，消费者接收消息失败false
①消息推送到server，但是在server里找不到交换机       ConfirmCallback(false)
②消息推送到server，找到交换机了，但是没找到队列   ConfirmCallback (true)，RetrunCallback
③消息推送到sever，交换机和队列啥都没找到 ConfirmCallback(false)
④消息推送成功                                   ConfirmCallback (true)
yml
spring:
  application:
    name: rebbitmq-demo
  rabbitmq:
    host: 192.168.1.114
    port: 5672
    username: admin
    password: admin
    # 虚拟host 可以不设置,使用server默认host
    virtual-host: AdminHosts
 
    #消息确认配置项
    # 消息发送到交换机确认机制,是否确认回调(Exchange)
    publisher-confirms: true
    # 确认消息已发送到队列(Queue)
    publisher-returns: true
RabbitConfig
 
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
/**
 * 发布者消息确认
 *
 * @Author: szw
 * @Date: 2020/7/17 16:16
 */
@Configuration
public class RabbitConfig {
    protected static final Log LOGGER = LogFactory.getLog(RabbitConfig.class);
 
    @Bean
    public RabbitTemplate createRabbitTemplate(ConnectionFactory connectionFactory) {
        RabbitTemplate rabbitTemplate = new RabbitTemplate();
        rabbitTemplate.setConnectionFactory(connectionFactory);
        //设置开启Mandatory,才能触发回调函数,无论消息推送结果怎么样都强制调用回调函数
        rabbitTemplate.setMandatory(true);
 
//        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
//        @Override
//        public void confirm(CorrelationData correlationData, boolean ack, String cause) {
//            LOGGER.debug("ConfirmCallback:     "+"相关数据："+correlationData);
//            LOGGER.debug("ConfirmCallback:     "+"确认情况："+ack);
//            LOGGER.debug("ConfirmCallback:     "+"原因："+cause);
//        });
        rabbitTemplate.setConfirmCallback((correlationData, ack, cause) -> {
            LOGGER.debug("ConfirmCallback:     " + "相关数据：" + correlationData);
            LOGGER.debug("ConfirmCallback:     " + "确认情况：" + ack);
            LOGGER.debug("ConfirmCallback:     " + "原因：" + cause);
        });
 
        rabbitTemplate.setReturnCallback((message, replyCode, replyText, exchange, routingKey) -> {
            LOGGER.debug("ReturnCallback:     " + "消息：" + message);
            LOGGER.debug("ReturnCallback:     " + "回应码：" + replyCode);
            LOGGER.debug("ReturnCallback:     " + "回应信息：" + replyText);
            LOGGER.debug("ReturnCallback:     " + "交换机：" + exchange);
            LOGGER.debug("ReturnCallback:     " + "路由键：" + routingKey);
        });
 
        return rabbitTemplate;
    }
}
消费者接收到消息的消息确认

消息接收的确认机制常用的两种模式：

①自动确认，这也是默认的消息确认情况。 AcknowledgeMode.NONE
RabbitMQ成功将消息发出（即将消息成功写入TCP Socket）中立即认为本次投递已经被正确处理，不管消费者端是否成功处理本次投递。

如果消费端消费逻辑抛出异常，也就是消费端没有处理成功这条消息，那么就相当于丢失了消息。
可以使用try catch捕捉异常后，打印日志用于追踪数据，这样找出对应数据再做后续处理

② 手动确认 ，配置接收消息确认机制时，多数选择的模式。
消费者收到消息后，手动调用basic.ack/basic.nack/basic.reject后，RabbitMQ收到这些消息后，才认为本次投递成功。
basic.ack用于肯定确认
basic.nack用于否定确认（注意：这是AMQP 0-9-1的RabbitMQ扩展）
basic.reject用于否定确认，但与basic.nack相比有一个限制:一次只能拒绝单条消息

消费者端以上的3个方法都表示消息已经被正确投递，但是basic.ack表示消息已经被正确处理。而basic.nack,basic.reject表示没有被正确处理：

channel.basicReject(deliveryTag, true); 拒绝消费当前消息，

如果第二参数传入true，就是将数据重新丢回队列里，那么下次还会消费这消息。使用这个确认模式要谨慎，使用不当会导致消息积压
设置false，就是告诉服务器，我已经知道这条消息数据了，因为一些原因拒绝它，而且服务器也把这个消息丢掉就行。下次不想再消费这条消息了。

channel.basicNack(deliveryTag, false, true);

第一个参数依然是当前消息到的数据的唯一id;
第二个参数是指是否针对多条消息；如果是true，也就是说一次性针对当前通道的消息的tagID小于当前这条消息的，都拒绝确认。
第三个参数是指是否重新入列，也就是指不确认的消息是否重新丢回到队列里面去。使用不确认后重新入列这个确认模式同样要谨慎同上

手动确认代码：

最终yml

-----------基于主题交换机
spring:
  application:
    name: rebbitmq-demo
  rabbitmq:
    host: 192.168.1.114
    port: 5672
    username: admin
    password: admin
    # 虚拟host 可以不设置,使用server默认host
    virtual-host: AdminHosts
 
    #消息确认配置项
    # 消息发送到交换机确认机制,是否确认回调(Exchange)
    publisher-confirms: true
    # 确认消息已发送到队列(Queue)
    publisher-returns: true
    # 开启ACK,三种配置方式，分别是none、manual和auto；默认auto
    # manual每条消息必须手工确认
    listener:
      direct:
        acknowledge-mode: manual
      simple:
        acknowledge-mode: manual
TopicTotalConsumer消费者中添加
 
import com.awb.init.TopicRabbitConfig;
import com.rabbitmq.client.Channel;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
 
import java.util.Map;
 
/**
 * 消费者消息确认
 * Ack手动确认
 *
 * @Author: szw
 * @Date: 2020/7/17 14:57
 */
@Component
@RabbitListener(queues = TopicRabbitConfig.TOPIC_WOMAN)
public class TopicTotalConsumer {
    protected static final Log LOGGER = LogFactory.getLog(TopicTotalConsumer.class);
 
    @RabbitHandler
    public void process(Message message, Map<String, Object> msgMap, Channel channel) throws Exception {
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        try {
            LOGGER.debug("TopicTotalConsumer消费者收到消息  : " + msgMap.toString());
            String messageId = (String) msgMap.get("messageId");
            String messageData = (String) msgMap.get("messageData");
            LOGGER.debug("消息成功消费到  messageId:" + messageId + "  messageData:" + messageData);
 
            if ("topic.man".equals(message.getMessageProperties().getConsumerQueue())) {
                System.out.println("消息来自的队列名为：" + message.getMessageProperties().getConsumerQueue());
                System.out.println("消息成功消费到  messageId:" + messageId + "  messageData:" + messageData);
                System.out.println("执行topic.man中的消息的业务处理流程......");
                channel.basicAck(deliveryTag, false);
            }
 
            if ("topic.woman".equals(message.getMessageProperties().getConsumerQueue())) {
                System.out.println("消息来自的队列名为：" + message.getMessageProperties().getConsumerQueue());
                System.out.println("消息成功消费到  messageId:" + messageId + "  messageData:" + messageData);
                System.out.println("执行topic.woman中的消息的业务处理流程......");
                channel.basicAck(deliveryTag, false);
            }
 
            // channel.basicReject(deliveryTag, true);//为true会重新放回队列
        } catch (Exception e) {
            channel.basicReject(deliveryTag, false);
            e.printStackTrace();
        }
    }
}
消费者如果不手动确认会一直消费，直到调用方法确认。

// 获取消息的唯一id：
long deliveryTag = message.getMessageProperties().getDeliveryTag();
// 消息来自的队列名为
message.getMessageProperties().getConsumerQueue()
//为true会重新放回队列
channel.basicReject(deliveryTag, false);

RabbitMQ的一些yml参数:

# base
spring.rabbitmq.host: 服务Host
spring.rabbitmq.port: 服务端口
spring.rabbitmq.username: 登陆用户名
spring.rabbitmq.password: 登陆密码
spring.rabbitmq.virtual-host: 连接到rabbitMQ的vhost
spring.rabbitmq.addresses: 指定client连接到的server的地址，多个以逗号分隔(优先取addresses，然后再取host)
spring.rabbitmq.requested-heartbeat: 指定心跳超时，单位秒，0为不指定；默认60s
spring.rabbitmq.publisher-confirms: 是否启用【发布确认】
spring.rabbitmq.publisher-returns: 是否启用【发布返回】
spring.rabbitmq.connection-timeout: 连接超时，单位毫秒，0表示无穷大，不超时
spring.rabbitmq.parsed-addresses:

# ssl
spring.rabbitmq.ssl.enabled: 是否支持ssl
spring.rabbitmq.ssl.key-store: 指定持有SSL certificate的key store的路径
spring.rabbitmq.ssl.key-store-password: 指定访问key store的密码
spring.rabbitmq.ssl.trust-store: 指定持有SSL certificates的Trust store
spring.rabbitmq.ssl.trust-store-password: 指定访问trust store的密码
spring.rabbitmq.ssl.algorithm: ssl使用的算法，例如，TLSv1.1

# cache
spring.rabbitmq.cache.channel.size: 缓存中保持的channel数量
spring.rabbitmq.cache.channel.checkout-timeout: 当缓存数量被设置时，从缓存中获取一个channel的超时时间，单位毫秒；如果为0，则总是创建一个新channel
spring.rabbitmq.cache.connection.size: 缓存的连接数，只有是CONNECTION模式时生效
spring.rabbitmq.cache.connection.mode: 连接工厂缓存模式：CHANNEL 和 CONNECTION

# listener
spring.rabbitmq.listener.simple.auto-startup: 是否启动时自动启动容器
spring.rabbitmq.listener.simple.acknowledge-mode: 表示消息确认方式，其有三种配置方式，分别是none、manual和auto；默认auto
spring.rabbitmq.listener.simple.concurrency: 最小的消费者数量
spring.rabbitmq.listener.simple.max-concurrency: 最大的消费者数量
spring.rabbitmq.listener.simple.prefetch: 指定一个请求能处理多少个消息，如果有事务的话，必须大于等于transaction数量.
spring.rabbitmq.listener.simple.transaction-size: 指定一个事务处理的消息数量，最好是小于等于prefetch的数量.
spring.rabbitmq.listener.simple.default-requeue-rejected: 决定被拒绝的消息是否重新入队；默认是true（与参数acknowledge-mode有关系）
spring.rabbitmq.listener.simple.idle-event-interval: 多少长时间发布空闲容器时间，单位毫秒

spring.rabbitmq.listener.simple.retry.enabled: 监听重试是否可用
spring.rabbitmq.listener.simple.retry.max-attempts: 最大重试次数
spring.rabbitmq.listener.simple.retry.initial-interval: 第一次和第二次尝试发布或传递消息之间的间隔
spring.rabbitmq.listener.simple.retry.multiplier: 应用于上一重试间隔的乘数
spring.rabbitmq.listener.simple.retry.max-interval: 最大重试时间间隔
spring.rabbitmq.listener.simple.retry.stateless: 重试是有状态or无状态

# template
spring.rabbitmq.template.mandatory: 启用强制信息；默认false
spring.rabbitmq.template.receive-timeout: receive() 操作的超时时间
spring.rabbitmq.template.reply-timeout: sendAndReceive() 操作的超时时间
spring.rabbitmq.template.retry.enabled: 发送重试是否可用
spring.rabbitmq.template.retry.max-attempts: 最大重试次数
spring.rabbitmq.template.retry.initial-interval: 第一次和第二次尝试发布或传递消息之间的间隔
spring.rabbitmq.template.retry.multiplier: 应用于上一重试间隔的乘数
spring.rabbitmq.template.retry.max-interval: 最大重试时间间隔

本篇博客到此结束了，后续需要再补充

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/盐析白兔/article/detail/568772