您当前的位置： 首页 > 慢生活 > 程序人生 网站首页程序人生

尚硅谷RabbitMQ视频-007-基础篇-HelloWorld(生产者与消费者)

发布时间：2026-10-19 02:45:56编辑：雪饮阅读（）

首先当然是用IntelliJ IDEA建立一个基于maven的java项目

首先是定义消息的发送者producer
Producer.java：
package org.example;

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

public class Producer {
    public static void main(String[] args) throws Exception {
        // 创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();

        // 设置主机地址，改成你自己RabbitMQ服务器IP
        connectionFactory.setHost("localhost");
        // 设置连接端口号：默认为 5672
        connectionFactory.setPort(5672);
        // 虚拟主机名称：默认为 /
        connectionFactory.setVirtualHost("/");
        // 设置连接用户名，默认为guest
        connectionFactory.setUsername("guest");
        // 设置连接密码，默认为guest
        connectionFactory.setPassword("123456");

        // 创建连接
        Connection connection = connectionFactory.newConnection();
        // 创建信道
        Channel channel = connection.createChannel();

        // 声明（创建）队列
        // 参数1：队列名称
        // 参数2：durable 是否定义持久化队列，当MQ重启之后还在
        // 参数3：exclusive 是否独占本次连接。若独占，只能有一个消费者监听这个队列且Connection关闭时删除这个队列
        // 参数4：autoDelete 是否在不使用的时候自动删除队列，也就是在没有Consumer时自动删除
        // 参数5：arguments 队列其它参数
        channel.queueDeclare("simple_queue", true, false, false, null);

        // 要发送的信息
        String message = "你好，小兔子！";

        // 参数1：交换机名称,如果没有指定则使用默认Default Exchange
        // 参数2：路由key,简单模式可以传递队列名称
        // 参数3：配置信息
        // 参数4：消息内容
        channel.basicPublish("", "simple_queue", null, message.getBytes());

        System.out.println("已发送消息：" + message);

        // 关闭资源
        channel.close();
        connection.close();
    }
}
这个需要maven依赖
<dependencies>
    <dependency>
        <groupId>com.rabbitmq</groupId>
        <artifactId>amqp-client</artifactId>
        <version>5.16.0</version>
    </dependency>
</dependencies>
这个消息生产者执行后会生产消息，然后可以在http://localhost:15672/#/进行观察面板中的变化。

接下来是接收代码也就是消费者
Consumer.java：

package org.example;



import com.rabbitmq.client.*;



import java.io.IOException;



public class Consumer {

    public static void main(String[] args) throws Exception {

        // 1.创建连接工厂

        ConnectionFactory factory = new ConnectionFactory();

        // 2. 设置参数

        factory.setHost("localhost");

        factory.setPort(5672);

        factory.setVirtualHost("/");

        factory.setUsername("guest");

        factory.setPassword("123456");



        // 3. 创建连接 Connection

        Connection connection = factory.newConnection();

        // 4. 创建Channel

        Channel channel = connection.createChannel();



        // 5. 创建队列

        // 如果没有一个名字叫simple_queue的队列，则会创建该队列，如果有则不会创建

        // 参数1. queue: 队列名称

        // 参数2. durable: 是否持久化。如果持久化，则当MQ重启之后还在

        // 参数3. exclusive: 是否独占。

        // 参数4. autoDelete: 是否自动删除。当没有Consumer时，自动删掉

        // 参数5. arguments: 其它参数。

        channel.queueDeclare("simple_queue",true,false,false,null);



        // 接收消息

        DefaultConsumer consumer = new DefaultConsumer(channel){

            // 回调方法，当收到消息后，会自动执行该方法

            // 参数1. consumerTag：标识

            // 参数2. envelope：获取一些信息，交换机，路由key...

            // 参数3. properties: 配置信息

            // 参数4. body：数据

            @Override

            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

                System.out.println("consumerTag: "+consumerTag);

                System.out.println("Exchange: "+envelope.getExchange());

                System.out.println("RoutingKey: "+envelope.getRoutingKey());

                System.out.println("properties: "+properties);

                System.out.println("body: "+new String(body));

            }

        };



        // 参数1. queue：队列名称

        // 参数2. autoAck：是否自动确认，类似咱们发短信，发送成功会收到一个确认消息

        // 参数3. callback：回调对象

        // 消费者类似一个监听程序，主要是用来监听消息

        channel.basicConsume("simple_queue",true,consumer);

    }

}

然后运行消费者就能消费刚才生产者所产生的消息，那么实际情况正确顺序应该是先运行消费者（理论常驻），然后运行生产者，但是由于这里的示例中消息是持久化的，所以当后运行的消费者也能消费到之前生产者的消息。接下来你不断执行生产者发现消费者也在不断消费。