平时工作中,消息中间件运用的场景较多,一般为了解耦,增加处理效率等考虑都会通过消息队列来实现,其中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的管理端看到有一条未被消费的消息,效果如下

Java rabbitmq 传参 java接收rabbitmq消息_Java

 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方法,就会进行消息的消费了,效果如下:

Java rabbitmq 传参 java接收rabbitmq消息_rabbitmq_02

Java rabbitmq 传参 java接收rabbitmq消息_rabbitmq_03

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

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