RabbitMQ概念、以及第一个rabbit的demo


概念认识

Broker：简单来说就是消息队列服务器实体。

  • Exchange：消息交换机，它指定消息按什么规则，路由到哪个队列。
  • Queue：消息队列载体，每个消息都会被投入到一个或多个队列。
  • Binding：绑定，它的作用就是把exchange和queue按照路由规则绑定起来。
  • Routing Key：路由关键字，exchange根据这个关键字进行消息投递。
  • vhost：虚拟主机，一个broker里可以开设多个vhost，用作不同用户的权限分离。
  • producer：消息生产者，就是投递消息的程序。
  • consumer：消息消费者，就是接受消息的程序。
  • channel：消息通道，在客户端的每个连接里，可建立多个channel，每个channel代表一个会话任务。

消息队列的使用过程大概如下：

  1. 客户端连接到消息队列服务器，打开一个channel。
  2. 客户端声明一个exchange，并设置相关属性。
  3. 客户端声明一个queue，并设置相关属性。
  4. 客户端使用routing key，在exchange和queue之间建立好绑定关系。
  5. 客户端投递消息到exchange。

exchange接收到消息后，就根据消息的key和已经设置的binding，进行消息路由，将消息投递到一个或多个队列里。

exchange也有几个类型，完全根据key进行投递的叫做Direct交换机，例如，绑定时设置了routing key为”abc”，那么客户端提交的消息，只有设置了key为”abc”的才会投递到队列。对key进行模式匹配后进行投递的叫做Topic交换机，符号”#”匹配一个或多个词，符号”*”匹配正好一个词。例如”abc.#”匹配”abc.def.ghi”，”abc.*”只匹配”abc.def”。还有一种不需要key的，叫做Fanout交换机，它采取广播模式，一个消息进来时，投递到与该交换机绑定的所有队列。

RabbitMQ支持消息的持久化，也就是数据写在磁盘上，为了数据安全考虑，我想大多数用户都会选择持久化。消息队列持久化包括3个部分：

exchange持久化，在声明时指定durable => 1
queue持久化，在声明时指定durable => 1
消息持久化，在投递时指定delivery_mode => 2（1是非持久化）

如果exchange和queue都是持久化的，那么它们之间的binding也是持久化的。如果exchange和queue两者之间有一个持久化，一个非持久化，就不允许建立绑定。

rabbitmq官方说明文档地址：

https://www.rabbitmq.com/getstarted.html

通信方式主要可以分为两种：

其一：点对点（即没有交换机）

其二：发布订阅（有交换机exchange）

常用的两种：

其一：Routing路由方式

其二：Topics比较灵活，路径匹配

服务启动及配置

首先启动rabbitmq-server

1
service rabbitmq-server start

本地端口访问: http://192.168.239.129:15672

访问成功，则证明安装成功。才能进入后续操作

创建一个新的用户：

创建一个虚拟主机

设置虚拟主机的权限permissions，和用户绑定

点击虚拟主机的名字

选择刚刚创建的用户

退出登录，用刚刚的用户登录成功即可

可参考：

https://blog.51cto.com/13877966/2297056

https://blog.csdn.net/qq_38455201/article/details/80308771

demo

导入依赖：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<dependencies>
        <!--rabbitmq-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

创建Send 生产者

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
package com.ldgroup.rabbitmqdemo.service;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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

/**
 * @Description
 * @Author by mocar小师兄
 * @Date 2020/4/25 0:58
 **/
public class Send {
    private final Logger logger = LoggerFactory.getLogger(this.getClass());
    public static final String QUEUE_A = "QUEUE_A";


    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("192.168.239.129");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("mocar");
        connectionFactory.setPassword("mocar");
        connectionFactory.setVirtualHost("/mocar");
        Connection connection = connectionFactory.newConnection();
        Channel channel = connection.createChannel();
        //队列声明，队列不存在则创建，否则不做处理
        //exclusive:独有的，是否只允许当前连接使用此队列
        channel.queueDeclare(QUEUE_A,true,false,false,null);
        String msg="第一次发送消息rabbitmq";
        channel.basicPublish("",QUEUE_A,null,msg.getBytes());
        System.out.println("发送完成");

    }
}

发送成功，产生一条带消费的消息

创建Receiving消费者

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
package com.ldgroup.rabbitmqdemo.service;

import com.rabbitmq.client.*;

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

/**
 * @Description
 * @Author by mocar小师兄
 * @Date 2020/4/25 1:56
 **/
public class Receiving {
    public static final String QUEUE_A = "QUEUE_A";

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("192.168.239.129");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("mocar");
        connectionFactory.setPassword("mocar");
        connectionFactory.setVirtualHost("/mocar");
        Connection connection = connectionFactory.newConnection();
        Channel channel = connection.createChannel();
       //创建消费者
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            //等待队列有消息之后，自动回调
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //super.handleDelivery(consumerTag, envelope, properties, body);
                //消费消息
                String msg = new String(body,"utf-8");
                System.out.println("消费消息：\t" + msg);
            }
        };
        //让消费者监听队列
        //消费后ACK确认消息成功消费
        channel.basicConsume(QUEUE_A,true,defaultConsumer);
        System.out.println("成功消费");
    }
}

消息成功被消费