Springboot2.0 + RabbitMQ3.5.8搭建、配置、集成与使用

目录

应用场景

快速搭建

管理界面创建虚拟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依赖

        
        
            org.springframework.boot
            spring-boot-starter-amqp
        

• 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 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 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 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: 最大重试时间间隔

 

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