使用Java体验RabbitMQ消息的发送与消费过程

        平时工作中，消息中间件运用的场景较多，一般为了解耦，增加处理效率等考虑都会通过消息队列来实现，其中rabbitmq应该是使用得最多了。但是平时都是别人spring整合好了，其中的一些底层连接其实并不清楚。这篇文章通过Java来体验rabbitmq的一个体验过程，可以更好的了解rabbitmq在发送的过程中，需要哪些步骤。

1. 引入rabbitmq的jar包

        因为我们只通过Java来体验rabbitmq的消息发送和消费的过程，所以我们就不引入spring整合rabbitmq的jar包，只引入amqp-client的包。

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

引入了amqp客户端的jar包后就可以体验了。这里有个注意的地方，我这个是在安装好了环境的情况下的操作，如果没有安装过rabbitmq的环境，就需要先去服务器上安装rabbitmq的环境了，我是docker下安装的，直接一条命令就可以了。docker环境安装rabbitmq命令

[root@VM-4-16-centos ~]# docker run -di --name myrabbit -e RABBITMQ_DEFAULT_USER=admin -e RABBITMQ_DEFAULT_PASS=password -p 15672:15672 -p 5672:5672 -p 25672:25672 -p 61613:61613 -p 1883:1883 rabbitmq:management

2. 消息生产者

        创建一个生产者类SimpleProducer，用来模拟发送消息，类的内容如下

package com.edu.spring.study.rabbitmq;

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

/**
 * @Author alen
 * @DATE 2022/6/5 16:16
 * Java体验rabbitmq之生产者
 */
public class SimpleProducer {

    public static void main(String[] args) {
        //1. 创建连接工程
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //1.1 设置连接IP
        connectionFactory.setHost("127.0.0.1");
        //1.2 设置连接端口
        connectionFactory.setPort(5672);
        //1.3 设置用户名
        connectionFactory.setUsername("admin");
        //1.4 设置密码
        connectionFactory.setPassword("admin123123");
        //1.5 设置虚拟访问节点，就是消息发送的目标路径
        connectionFactory.setVirtualHost("/");

        Connection connection = null;
        Channel channel = null;
        try {
            //2. 创建连接Connection
            connection = connectionFactory.newConnection("生产者");
            //3. 通过连接获取通道Channel
            channel = connection.createChannel();
            //4. 通过通道创建交换机，声明队列，绑定关系，路由key，发送消息，接收消息
            String queueName = "myFirstQueue";
            /**
             * channel.queueDeclare有5个参数
             * params1: 队列的名称
             * params2: 是否要持久化， false：非持久化 true：持久化
             * params3: 排他性，是否独占队列
             * params4: 是否自动删除，如果为true，队列会随着最后一个消费消费完后将队列自动删除，false：消息全部消费完后，队列保留
             * params5: 携带的附加参数
             */
            channel.queueDeclare(queueName, true, false, false, null);
            //5. 消息内容
            String message = "Java体验rabbitmq发送消息";
            //6. 将消息发送到队列
            channel.basicPublish("", queueName, null, message.getBytes());
            System.out.println("消息发送成功");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //7. 关闭通道
            if (channel != null && channel.isOpen()) {
                try {
                    channel.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            //8. 关闭连接
            if (connection != null && connection.isOpen()) {
                try {
                    connection.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

执行main方法，可以看到rabbitmq的管理端看到有一条未被消费的消息，效果如下

 3. 消息消费者

        消息消费者的内容类似，前面的创建连接等步骤都是需要的，消费者的类详情如下

package com.edu.spring.study.rabbitmq;

import com.rabbitmq.client.*;

import java.io.IOException;

/**
 * @Author alent
 * @DATE 2022/6/5 16:18
 * Java体验rabbitmq之消费者
 */
public class SimpleConsumer {

    public static void main(String[] args) {
        //1. 创建连接工程
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //1.1 设置连接IP
        connectionFactory.setHost("127.0.0.1");
        //1.2 设置连接端口
        connectionFactory.setPort(5672);
        //1.3 设置用户名
        connectionFactory.setUsername("admin");
        //1.4 设置密码
        connectionFactory.setPassword("admin123123");
        //1.5 设置虚拟访问节点，就是消息发送的目标路径
        connectionFactory.setVirtualHost("/");

        Connection connection = null;
        Channel channel = null;
        try {
            //2. 创建连接Connection
            connection = connectionFactory.newConnection("生产者");
            //3. 通过连接获取通道Channel
            channel = connection.createChannel();
            //4. 通过通道创建交换机，声明队列，绑定关系，路由key，发送消息，接收消息
            String queueName = "myFirstQueue";
            //5. 接收消息并消费消息
            channel.basicConsume(queueName, true, new DeliverCallback() {
                @Override
                public void handle(String consumerTag, Delivery message) throws IOException {
                    System.out.println("接收到的消息内容是：" + new String(message.getBody(), "UTF-8"));
                }
            }, new CancelCallback() {
                @Override
                public void handle(String consumerTag) throws IOException {
                    System.out.println("消息接手失败。。。");
                }
            });
            System.out.println("开始接受消息。。。。");
            //阻断程序
            System.in.read();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //7. 关闭通道
            if (channel != null && channel.isOpen()) {
                try {
                    channel.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            //8. 关闭连接
            if (connection != null && connection.isOpen()) {
                try {
                    connection.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

执行消费者的main方法，就会进行消息的消费了，效果如下：

消息消费成功，当然这个是一个最简单的流程，主要是用来了解rabbitmq消息的原生代码怎么写

后续在把spring的整合学习总结后再分享。