RabbitMQ 学习(一) —— 概念和快速入门

最新推荐文章于 2021-05-12 16:54:15 发布

微笑看你哭

最新推荐文章于 2021-05-12 16:54:15 发布

阅读量163

点赞数

分类专栏： rabbitmq

本文链接：https://blog.csdn.net/hxyascx/article/details/104416066

版权

rabbitmq 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

RabbitMQ 初识

RabbitMQ 是一个开源的消息代理和队列服务器，用来通过普通协议在完全不同的应用之间共享数据，RabbitMQ 是使用Erlang语言来编写的，并且RabbitMQ是基于AMQP协议的。

Erlang语言最初在于交换机领域的架构模式，这样使得 RabbitMQ在Broker之间进行数据交互的性能是非常优秀的。它的优点是与原生Socket一样的延迟。

AMQP协议：具有现代特征的二进制协议。是一个提供统一消息服务的应用层标准高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。

AMQP的协议模型
在这里插入图片描述
AMQP核心概念：

Server： 又称Broker，接受客户端的连接，实现AMQP实体服务。
Connection： 连接，应用程序与Broker的网络连接。
Channel： 网络信道，几乎所有的操作都在Channel中进行，Channel是进行消息读写的通道。客户端可建立多个Channel，每个Channel代表一个会话任务。
Message： 消息，服务器和应用程序之间传送的数据，由Properties和Body组成。Properties可以对消息进行修饰，比如消息的优先级、延迟等高级特性；Body则就是消息体内容。
Virtual host： 虚拟地址，用于进行逻辑隔离，最上层的消息路由。一个Virtual Host里面可以有若干个Exchange和Queue，同一个Virtual Host里面不能有相同名称的Exchange或Queue。
Exchange： 交换机，接收消息，根据路由键转发消息到绑定的队列。
Binding： Exchange和Queue之间的虚拟连接，binding中可以包含routing key。
Rounting key： 一个路由规则，虚拟机可用它来确定如何路由一个特定消息。
Queue： 也称为Message Queue，消息队列，保存消息并将它们转发给消费者。

RabbitMQ消息流转：
在这里插入图片描述

RabbitMQ 简单实现生成和消费

docker 安装 RabbitMQ

拉取rabbitmq镜像
```
docker pull rabbitmq:management
```

创建并启动容器同时设置用户和密码 admin\admin

docker run -d --hostname my-rabbit --name rabbit -e RABBITMQ_DEFAULT_USER=admin -e RABBITMQ_DEFAULT_PASS=admin -p 15672:15672 -p 5672:5672 -p 25672:25672 -p 61613:61613 -p 1883:1883 rabbitmq:management

查看rabbitmq运行状况
```
docker logs rabbit
```

创建项目实现生产和消费消息

引入依赖

        <dependency>
            <groupId>com.rabbitmq</groupId>
            <artifactId>amqp-client</artifactId>
            <version>3.6.5</version>
        </dependency>

创建生产者

public class Producer {
    public static void main(String[] args) throws IOException, TimeoutException {
        // 1 创建一个connectionFactory，并进行配置
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("localhost");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");
        connectionFactory.setVirtualHost("/");

        // 2 通过连接工厂 创建连接
        Connection connection = connectionFactory.newConnection();

        // 3 通过 connection 创建一个 channel
        Channel channel = connection.createChannel();

        // 4 通过 channel 发送数据
        for(int i=0;i<5;i++) {
            String msg = "Hello RabbitMQ";
            //参数：1、交换机名称 2、路由键 
            //当不指定交换机时 则使用默认交换机，该交换机规则是发送到队列名相同的路由键
            channel.basicPublish("", "test001", null, msg.getBytes());
        }

        // 5 记得要关闭相关的连接
        channel.close();
        connection.close();

    }
}

创建消费者

public class Consumer {
    public static void main(String[] args) throws IOException, InterruptedException, TimeoutException {
        // 1 创建一个connectionFactory，并进行配置
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("localhost");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");
        connectionFactory.setVirtualHost("/");

        // 2 通过连接工厂 创建连接
        Connection connection = connectionFactory.newConnection();

        // 3 通过 connection 创建一个 channel
        Channel channel = connection.createChannel();

        // 4 声明（创建）一个队列
        // 参数分别是 1、test001 队列名称 2、是否进行持久化 3、是否独占模式（该队列只有这一个连接） 4、自动删除（当该队列没有其他关联时是否自动删除 5、扩展参数）
        String queueName = "test001";
        channel.queueDeclare(queueName, true, false, false, null);

        //5 创建消费者
        QueueingConsumer queueingConsumer = new QueueingConsumer(channel);

        //6 设置channel
        //参数分别是 1、队列名称 2、是否自动提交消费进度 3、消费者
        channel.basicConsume(queueName, true, queueingConsumer);

        //7 获取消息
        while (true) {
            QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
            String msg = new String(delivery.getBody());
            System.out.println(msg);
        }

    }
}

消息发送

首先启动消费者，在控制台上可以看到，已经自动创建了 connection、channel、queue、consumer。
在这里插入图片描述
再启动生产者，消费者会收到对应的消息。我们可以看到上面消费者设置的队列名称为test001，而生产者并没有指定exchange，而是将routingkey同样设置称test001。因为当没有指定exchange时，会使用默认当exchange，即为AMQP default，他会找到和routingkey相同的queue并将消费发送到它上面去，当没有找到相同当queue，会自动删除消息。

Exchange 交换机

接收消息，并根据路由键转发消息到所绑定的队列。

在这里插入图片描述

交换机属性

Name： 交换机名称
Tyep： 交换机类型 direct、topic、fanout、headers
Durability： 是否需要持久化，true为持久化。
Auto Delete： 当最后一个绑定到Exchange上到队列删除后，自动删除该Exchange。
Internal： 当前Exchange是否用于RabbitMQ内部使用，默认为false。
Arguments： 扩展参数，用于扩展AMQP协议自制定化使用。

Direct Exchange

所有发送到 Direct Exchange 的消息被转发到 RouteKey 中指定的 Queue。

注意：Direct 模式可以使用 RabbitMQ自带的 Exchange：default Exchange，所以不需要将Exchange 进行任何绑定(binding)操作，消息传递时，RouteKey必须完全匹配才会被队列接收，否则该消息会被抛弃。

在这里插入图片描述
生产者：

public class Producer4DirectExchange {
    public static void main(String[] args) throws IOException, TimeoutException {
        // 1 创建一个connectionFactory，并进行配置
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("localhost");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");
        connectionFactory.setVirtualHost("/");

        // 2 通过连接工厂 创建连接
        Connection connection = connectionFactory.newConnection();

        // 3 通过 connection 创建一个 channel
        Channel channel = connection.createChannel();

        // 4 声明
        String exchangeName = "test_direct_exchange";
        String routingKey = "test.direct";

        //5 发送
        String msg = "Hello World RabbitMQ 4 Direct Exchange Message...";
        channel.basicPublish(exchangeName, routingKey, null, msg.getBytes());

        //6 记得要关闭相关的连接
        channel.close();
        connection.close();
    }
}

消费者：

public class Consumer4DirectExchange {
    public static void main(String[] args) throws IOException, InterruptedException, TimeoutException {
        // 1 创建一个connectionFactory，并进行配置
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("localhost");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");
        connectionFactory.setVirtualHost("/");

        //自动重连 和 每3秒钟重连一次
        connectionFactory.setAutomaticRecoveryEnabled(true);
        connectionFactory.setNetworkRecoveryInterval(3000);

        // 2 通过连接工厂 创建连接
        Connection connection = connectionFactory.newConnection();

        // 3 通过 connection 创建一个 channel
        Channel channel = connection.createChannel();

        //4 声明
        String exchangeName = "test_direct_exchange";
        String exchangeType = "direct";
        String queueName = "test_direct_queue";
        String routingKey = "test.direct";

        //5、声明一个交换机 1、交换机名称 2、交换机类型 3、是否进行持久化  4、自动删除（当该队列没有其他关联时是否自动删除 5、是否是内部交换机 6、扩展参数
        channel.exchangeDeclare(exchangeName, exchangeType, true, false, false, null);

        //6、声明一个队列 1、test001 队列名称 2、是否进行持久化 3、是否独占模式（该队列只有这一个连接） 4、自动删除（当该队列没有其他关联时是否自动删除 5、扩展参数
        channel.queueDeclare(queueName,false, false, false, null);

        //7、建立一个绑定关系
        channel.queueBind(queueName, exchangeName, routingKey);

        //8、创建消费者
        QueueingConsumer consumer = new QueueingConsumer(channel);

        //6 设置channel
        //参数分别是 1、队列名称 2、是否自动提交消费进度 3、消费者
        channel.basicConsume(queueName, true, consumer);

        //循环获取消息
        while (true) {
            //获取消息
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String msg = new String(delivery.getBody());
            System.out.println(msg);
        }
    }
}

Direct Exchange 的交换机，主要是生产者的 routingKey 要和发送的交换机设置与队列绑定的 routingKey一致，才能投递到指定的队列中。

Topic Exchange

所有发送到Topic Exchange 的消息被转发到所有关心 RouteKey 中指定 Topic 的 Queue 上。Exchange 将 RouteKey 和某Topic进行模糊匹配，此时队列需要绑定一个Topic。

注意：可以使用通配符进行模糊匹配
符号 “#” 匹配一个或多个词
符号 “” 匹配不多不少一个词
例如：“log.#” 能狗匹配到 “log.info.oa” "log.“只会匹配到 “log.erro”

在这里插入图片描述
生产者：

public class Producer4TopicExchange {
    public static void main(String[] args) throws Exception {
        // 1 创建一个connectionFactory，并进行配置
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("localhost");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");
        connectionFactory.setVirtualHost("/");

        // 2 通过连接工厂 创建连接
        Connection connection = connectionFactory.newConnection();

        // 3 通过 connection 创建一个 channel
        Channel channel = connection.createChannel();

        // 4 声明
        String exchangeName = "test_topic_exchange";
        String routingKey1 = "user.save";
        String routingKey2 = "user.update";
        String routingKey3 = "user.delete.abc";

        //5 发送
        String msg = "Hello World RabbitMQ 4 Topic Exchange Message ...";
        channel.basicPublish(exchangeName, routingKey1, null, msg.getBytes());
        channel.basicPublish(exchangeName, routingKey2, null, msg.getBytes());
        channel.basicPublish(exchangeName, routingKey3, null, msg.getBytes());
        channel.close();
        connection.close();
    }
}

消费者：

public class Consumer4TopicExchange {
    public static void main(String[] args) throws Exception {
        // 1 创建一个connectionFactory，并进行配置
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("localhost");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");
        connectionFactory.setVirtualHost("/");

        //自动重连 和 每3秒钟重连一次
        connectionFactory.setAutomaticRecoveryEnabled(true);
        connectionFactory.setNetworkRecoveryInterval(3000);

        // 2 通过连接工厂 创建连接
        Connection connection = connectionFactory.newConnection();

        // 3 通过 connection 创建一个 channel
        Channel channel = connection.createChannel();

        //4 声明
        String exchangeName = "test_topic_exchange";
        String exchangeType= "topic";
        String queueName = "test_topic_queue";
        String routingKey = "user.#";

        //5 声明交换机
        channel.exchangeDeclare(exchangeName, exchangeType, true, false, false, null);
        //6 声明队列
        channel.queueDeclare(queueName, false, false, false, null);
        //7 建立交换机和队列的绑定关系
        channel.queueBind(queueName, exchangeName, routingKey);

        //8、创建消费者
        QueueingConsumer consumer = new QueueingConsumer(channel);

        //6 设置channel
        //参数分别是 1、队列名称 2、是否自动提交消费进度 3、消费者
        channel.basicConsume(queueName, true, consumer);

        //循环获取消息
        while (true) {
            //获取消息
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String msg = new String(delivery.getBody());
            System.out.println(msg);
        }
    }
}

Topic Exchange 交换机主要是通过生产者发送的 routingKey 与交换机绑定队列的 routingKey 的进行规则匹配。

Fanout Exchange

不处理路由键，只需要简单的将队列绑定到交换机上。发送到交换机的消息都会被转发到与该交换机绑定到所有队列上。Fanout 交换机转发消息是最快的。

在这里插入图片描述
生产者：

public class Producer4FanoutExchange {
    public static void main(String[] args) throws Exception {
        // 1 创建一个connectionFactory，并进行配置
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("localhost");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");
        connectionFactory.setVirtualHost("/");

        // 2 通过连接工厂 创建连接
        Connection connection = connectionFactory.newConnection();

        // 3 通过 connection 创建一个 channel
        Channel channel = connection.createChannel();

        // 4 声明
        String exchangeName = "test_fanout_exchange";

        //5 发送
        String msg = "Hello World RabbitMQ 4 fanout Exchange Message...";
        channel.basicPublish(exchangeName, "", null, msg.getBytes());

        //6 记得要关闭相关的连接
        channel.close();
        connection.close();
    }
}

消费者：

public class Consumer4FanoutExchange {
    public static void main(String[] args) throws Exception {
        // 1 创建一个connectionFactory，并进行配置
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("localhost");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");
        connectionFactory.setVirtualHost("/");

        // 2 通过连接工厂 创建连接
        Connection connection = connectionFactory.newConnection();

        // 3 通过 connection 创建一个 channel
        Channel channel = connection.createChannel();

        //4 声明
        String exchangeName = "test_fanout_exchange";
        String exchangeType = "fanout";
        String queueName = "test_fanout_queue";
        String routingKey = ""; //不设置路由键

        //5、声明一个交换机 1、交换机名称 2、交换机类型 3、是否进行持久化  4、自动删除（当该队列没有其他关联时是否自动删除 5、是否是内部交换机 6、扩展参数
        channel.exchangeDeclare(exchangeName, exchangeType, true, false, false, null);

        //6、声明一个队列 1、test001 队列名称 2、是否进行持久化 3、是否独占模式（该队列只有这一个连接） 4、自动删除（当该队列没有其他关联时是否自动删除 5、扩展参数
        channel.queueDeclare(queueName,false, false, false, null);

        //7、建立一个绑定关系
        channel.queueBind(queueName, exchangeName, routingKey);

        //8、创建消费者
        QueueingConsumer consumer = new QueueingConsumer(channel);

        //6 设置channel
        //参数分别是 1、队列名称 2、是否自动提交消费进度 3、消费者
        channel.basicConsume(queueName, true, consumer);

        //循环获取消息
        while (true) {
            //获取消息
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String msg = new String(delivery.getBody());
            System.out.println(msg);
        }
    }
}

Fanout exchange 交换机是不考虑 rountingKey的发送到 exchange上的消息都会直接转发到绑定到queue上。

Bingding 绑定

Exchange 和 Exchange、Queue 之间的连接关系。
Binding 中可以包含 RoutingKey 或者参数。

Queue 消息队列

消息队列，实际存储消息数据。

主要参数：

Durability： 是否持久化，Durable：是，Transient：否。
Auto delete： 如选yes，代表当最后一个监听被移除之后，该Queue会自动被删除。

Message 消息

服务器和应用程序之间传送当数据。本质上就是一段数据，由Properties和Payload（Body）组成。

常用属性： delivery mode(送达模式：持久化或非持久化)、headers(自定义属性)
其他属性： content_type、content_encoding、priority(优先级)、correlation_id(唯一id)、reply_to(消息失败返回到哪个队列)、expiration(未被消费的存活时间)、message_id、timestamp、type、user_id、app_id、cluster_id

发送消息：

        AMQP.BasicProperties properties = new AMQP.BasicProperties.Builder()
                .deliveryMode(2) //1 代表非持久化 2 代表持久化
                .contentEncoding("UTF-8")
                .expiration("10000") //未被消费 10秒钟自动清楚
                .headers(headers)
                .build();

        String msg = "Hello RabbitMQ";
        channel.basicPublish("", "test001", properties, msg.getBytes());

接收消息：

            QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
            String msg = new String(delivery.getBody());
            System.out.println(msg);

            Map<String, Object> headers = delivery.getProperties().getHeaders();
            System.out.println(headers.get("my1"));

Virtual host - 虚拟主机

虚拟地址，用于进行逻辑隔离，最上层的消息路由
一个Virtual Host里面可以有若干个Exchange和Queue
同一个Virtual Host里面不能有相同名称的Exchange或Queue

微笑看你哭

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
RabbitMQ 学习(一) —— 概念和快速入门

RabbitMQ 初识RabbitMQ 是一个开源的消息代理和队列服务器，用来通过普通协议在完全不同的应用之间共享数据，RabbitMQ 是使用Erlang语言来编写的，并且RabbitMQ是基于AMQP协议的。Erlang语言最初在于交换机领域的架构模式，这样使得 RabbitMQ在Broker之间进行数据交互的性能是非常优秀的。它的优点是与原生Socket一样的延迟。AMQP协议：具有现...
复制链接

扫一扫