springboot整合rabbitmq

较真的菜鸟

已于 2024-07-16 19:02:57 修改

阅读量1.2k

点赞数

分类专栏：服务器和MQ 文章标签： rabbitmq java spring boot

于 2021-10-07 18:19:15 首次发布

本文链接：https://blog.csdn.net/weixin_43790613/article/details/120638895

版权

服务器和MQ 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

导入依赖

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

使用连接对象前的准备

创建用户和虚拟机，此处用的是admin用户创建的虚拟机
在这里插入图片描述

消费模型

直连模型

当多个消费者对应一个生产者时，消息会被平均分配到多个消费者上

任务模型

多个消费者绑定到一个生产者时，会是能者多劳的情况

创建连接对象（代码）

连接对象的工具类

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

public class RabbitMqUtil {
    private static ConnectionFactory connectionFactory;
    static {
        // 重量级资源 ，让其类加载是执行一次即可
        connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("192.168.10.166");
        connectionFactory.setPort(5672);
        // 设置虚拟主机
        connectionFactory.setVirtualHost("ems");
        // 设置访问虚拟主机的用户名和密码
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");
    }

    // 获取连接对象的方法
    public static Connection getConnection() {
        try {
            // 创建连接
            return connectionFactory.newConnection();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    // 关闭通道和关闭连接的方法
    public static void closeConnection(Channel channel, Connection connection) {
        try {
            if (channel != null) {
                channel.close();
            }
            if (connection != null) {
                connection.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

生产消息代码

public static void main(String[] args) throws IOException, TimeoutException {
        // 创建连接
        Connection connection = RabbitMqUtil.getConnection();
        // 获取连接通道
        Channel channel = connection.createChannel();
        // 通道绑定对应消息队列,生成者和消费者这个方法的参数要严格一致才能消费到
        // 参数1 队列名称 ，此处不能决定发往哪个队列，需要下面basicPublish第二个参数决定
        // 参数2 用来定义队列特性是否要持久化 true 持久化 false 不持久化，此处只是队列的持久化，并不是消息的持久化，消息的持久化需要设置下面basicPublish方法的第三个参数
        // 参数3 exclusive 是否独占队列 true 独占队列 false 不独占队列
        // 参数4 autoDelete 是否在消费完成后自动删除，true 自动删除 false 不自动删除,消费者只有关闭连接后队列才会删除
        // 参数5 额外附加参数
        channel.queueDeclare("topic",true,false,true,null);
        // 发布消息 参数1 交换机名 参数2 队列名 参数3传递消息的额外设置 配合queueDeclare方法的地二个参数设置可以设置消息的持久化， 参数4 消息内容
        channel.basicPublish("","topic",MessageProperties.PERSISTENT_TEXT_PLAIN,"hellomq2".getBytes());
        RabbitMqUtil.closeConnection(channel, connection);
    }

管理界面和代码参数的对应关系
在这里插入图片描述

消费者代码 - 自动确认消息

// 创建连接
        Connection connection = RabbitMqUtil.getConnection();
        // 获取连接通道
        Channel channel = connection.createChannel();
        // 通道绑定对象
        channel.queueDeclare("topic",true,false,true,null);
        // 消费消息 参数1 队列名称 参数2 开始消息的自动确认机制 参数3 消费时的回调接口
        channel.basicConsume("topic",true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("======" + new String(body));
            }
        });

消费者代码-手动确认消息
如果代码没有走到channel.basicAck(envelope.getDeliveryTag(),false);这一步，则消息会重新回到消息队列中给其他消费者消费，如果消费者在消费过程中异常了，则不会再消费信息，处于停止状态
修改的地方，

将生产者和消费者的channel.queueDeclare("topic",true,false,false,null);代码的第四个参数也需要设置为false
将消费者的channel.basicConsume的第二个参数是否自动确认消息设置为false，
最后将消息手动确认channel.basicAck(envelope.getDeliveryTag(),false);

// 创建连接
        Connection connection = RabbitMqUtil.getConnection();
        // 获取连接通道
        Channel channel = connection.createChannel();
        channel.basicQos(1); // 一次只接受一条未确认的消息，需要配合下面envelope手动确认消息
        // 通道绑定对象
        channel.queueDeclare("topic",true,false,true,null);
        // 消费消息 参数1 队列名称 参数2 开始消息的自动确认机制 参数3 消费时的回调接口
        channel.basicConsume("topic",false,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("======" + new String(body));
                // 参数1 ：确认队列中哪个具体消息 ，参数2： 是否开启多个消息同时确认，true，可以同时处理信道中的多条消息确认，false 处理完成后确认当前消息消费完成
                channel.basicAck(envelope.getDeliveryTag(),false); // 单条消息处里确认
                // channel.basicReject(envelope.getDeliveryTag(),false); // 拒绝改消息，不处理该消息，第二个参数为是否重回队列，false为不重新回到队列，true为重新回到队列，消息会再次被消费，一般设置为false
            }
        });

第三个模型广播

在广播模式下，消息发送流程是这样的：

可以有多个消费者。消息会被所有绑定此交换机的消费者消费
每个消费者有自己的临时队列
消费者的队列都要绑定到交换机上
生产者生产消息时，只能发送到交换机上，交换机决定发送到哪

生产者代码

// 创建连接
Connection connection = RabbitMqUtil.getConnection();
// 获取连接通道
Channel channel = connection.createChannel();
// 将通道指定交换机，参数1交换机名称 参数2 交换机类型   fanout 广播类型 参数固定为fanout
channel.exchangeDeclare("logs", "fanout");
// 发送消息
channel.basicPublish("logs", "", null, "fanout type message".getBytes());
// 释放资源
RabbitMqUtil.closeConnection(channel, connection);

消费者代码

// 创建连接
Connection connection = RabbitMqUtil.getConnection();
// 获取连接通道
Channel channel = connection.createChannel();
// 通道绑定交换机
channel.exchangeDeclare("logs","fanout");
// 临时队列
String queue = channel.queueDeclare().getQueue();
// 绑定临时队列
channel.queueBind(queue,"logs","");
// 消费消息 参数1 队列名称 参数2 开始消息的自动确认机制 参数3 消费时的回调接口
channel.basicConsume(queue,true,new DefaultConsumer(channel){
    @Override
    public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
        System.out.println("======" + new String(body));
    }
});

基于路由的直连模式

在direct模式下

队列与交换机的的绑定，不能是任意绑定了，而是要指定一个RoutingeKey，只有RoutingeKey完全一致的消费者才会消费到消息

生产者代码

// 创建连接
Connection connection = RabbitMqUtil.getConnection();
// 获取连接通道
Channel channel = connection.createChannel();
// 将通道指定交换机，参数1交换机名称 参数2 交换机类型   direct路由类型  direct固定写死
channel.exchangeDeclare("logs_direct", "direct");
// 发送消息
String routingKey = "info";
channel.basicPublish("logs_direct", routingKey, null, "基于direct发布的消息".getBytes());
// 释放资源
RabbitMqUtil.closeConnection(channel, connection);

消费者代码

// 创建连接
Connection connection = RabbitMqUtil.getConnection();
// 获取连接通道
Channel channel = connection.createChannel();
// 通道绑定交换机
channel.exchangeDeclare("logs_direct","direct");
// 临时队列
String queue = channel.queueDeclare().getQueue();
// 绑定临时队列和交换机，可同时绑定多个
channel.queueBind(queue,"logs_direct","info");
channel.queueBind(queue,"logs_direct","warn");
// 消费消息 参数1 队列名称 参数2 开始消息的自动确认机制 参数3 消费时的回调接口
channel.basicConsume(queue,true,new DefaultConsumer(channel){
    @Override
    public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
        System.out.println("======" + new String(body));
    }
});

RoutingKey路由之订阅模式topic

topic类型的Exchange与Direct相比，都是可以根据RoutingKey把消息路由到不同的队列。只不过topic类型Exchange可以让队列在绑定RoutingKey的时候使用通配符，这种模型RoutingKey一般是由一个或多个单词组成，多个单词之间用"."分割，例如item.insert

通配符

* 匹配任何一个词
#匹配一个或多个词

生产者代码

// 创建连接
 Connection connection = RabbitMqUtil.getConnection();
 // 获取连接通道
 Channel channel = connection.createChannel();
 // 将通道指定交换机，参数1交换机名称 参数2 交换机类型   fanout 广播类型
 channel.exchangeDeclare("topics", "topic");
 // 发送消息
 String routingKey = "user.save.findAll";
 channel.basicPublish("topics", routingKey, null, "基于topic发布的消息".getBytes());
 // 释放资源
 RabbitMqUtil.closeConnection(channel, connection);

消费者代码

// 创建连接
Connection connection = RabbitMqUtil.getConnection();
// 获取连接通道
Channel channel = connection.createChannel();
// 通道绑定交换机
String exchange = "topics";
channel.exchangeDeclare(exchange,"topic");
// 临时队列
String queue = channel.queueDeclare().getQueue();
// 绑定临时队列和交换机，可同时绑定多个
channel.queueBind(queue,exchange,"user.*"); // 可以消费到 ，user.*消费不到，只能是user.save.*才能消费到
// 消费消息 参数1 队列名称 参数2 开始消息的自动确认机制 参数3 消费时的回调接口
channel.basicConsume(queue,true,new DefaultConsumer(channel){
    @Override
    public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
        System.out.println("======" + new String(body));
    }
});