Java implementa el modelo de cola simple rabbitmq, la cola de mensajes del consumidor del productor

Los productores envían mensajes a la cola, los consumidores aleatorios reciben mensajes de la cola

1. Crea usuarios y hosts virtuales

Puede crear fácilmente usuarios y hosts virtuales a través de la interfaz de administración de usuarios proporcionada por rabbitmq, y debe vincular a los usuarios a los hosts virtuales correspondientes. Con su propio guestusuario y /host virtual, también puede utilizar directamente estos dos datos existentes. Creamos un host virtual llamado wuwlusuario y /vhtenga en cuenta que el host virtual debe /comenzar con.

2. Importar dependencias

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

3. Cree una conexión, donde ConnectionUtils se considera una clase de herramienta, y tanto los productores como los consumidores necesitan conectar objetos

public class ConnectionUtils {
    
    
    public static Connection getConnection() throws IOException, TimeoutException {
    
    
        // 创建连接mq的连接工厂对象
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 设置连接rabbitmq主机
        connectionFactory.setHost("192.168.20.128");
        // 设置端口号
        connectionFactory.setPort(5672);
        // 设置虚拟主机
        connectionFactory.setVirtualHost("/vh");
        // 设置用户名和密码
        connectionFactory.setUsername("wuwl");
        connectionFactory.setPassword("123456");

        // 获取连接对象
        return connectionFactory.newConnection();
    }
}

4. Crear productor

public class Provider {
    
    
    public void send() throws IOException, TimeoutException {
    
    
        Connection connection = null;
        Channel channel = null;
        try {
    
    
            connection = ConnectionUtils.getConnection();
            // 获取连接通道
            channel = connection.createChannel();

            /** 通道绑定对应的消息队列
             * 参数一：队列名称，如果队列不存在，自动创建队列
             * 参数二：定义队列是否持久化
             * 参数三：是否独占队列
             * 参数四：是否在消费完成后自动删除队列
             */
            channel.queueDeclare("wuwl",true,false,false,null);

            /**
             * 发布消息
             * 参数一： 交换机名称
             * 参数二：队列名称
             * 参数三：传递消息额外设置
             * 参数四：消息的具体内容
             */
            channel.basicPublish("","wuwl",null,"hello rabbitmq".getBytes());
        }finally {
    
    
            if (channel !=null && channel.isOpen()) {
    
    
                channel.close();
            }
            if (connection != null && connection.isOpen()) {
    
    
                connection.close();
            }
        }
    }

    public static void main(String[] args) throws IOException, TimeoutException {
    
    
        Provider provider = new Provider();
        provider.send();
    }
}

5. Crea un consumidor. Si el canal del consumidor y el objeto de conexión no están cerrados, siempre estará en el estado de monitoreo. Solo el productor envía un nuevo mensaje a la cola de mensajes y el consumidor lo consumirá inmediatamente.

public class Consumer {
    
    
    public void consume() throws IOException, TimeoutException {
    
    
        Connection connection = null;
        Channel channel = null;
        try {
    
    
            connection = ConnectionUtils.getConnection();
            // 获取连接通道
            channel = connection.createChannel();

            /** 通道绑定对应的消息队列
             * 参数一：队列名称，如果队列不存在，自动创建队列
             * 参数二：定义队列是否持久化
             * 参数三：是否独占队列
             * 参数四：是否在消费完成后自动删除队列
             */
            channel.queueDeclare("wuwl", true, false, false, null);

            /**
             * 消费
             * 参数一： 交换机名称
             * 参数二：队列名称
             * 参数三：传递消息额外设置
             * 参数四：消息的具体内容
             */
            channel.basicConsume("wuwl",true,new DefaultConsumer(channel){
    
    
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
    
    
                    System.out.println("消费消息：" + new String(body));
                }
            });
        } finally {
    
    
//            if (channel != null && channel.isOpen()) {
    
    
//                channel.close();
//            }
//            if (connection != null && connection.isOpen()) {
    
    
//                connection.close();
//            }
        }
    }

    public static void main(String[] args) throws IOException, TimeoutException {
    
    
        Consumer consumer = new Consumer();
        consumer.consume();
    }

}

6. Prueba
   Ejecutar solo el productor, podemos ver la cola que definimos en la interfaz de gestión, y los beneficios que no se han consumido

Después de iniciar el consumidor, el mensaje se consume y se monitorea continuamente.

En este momento, la cantidad de mensajes que se consumirán en la cola es 0

Enviar un mensaje a la cola de mensajes a través del productor nuevamente, el consumidor consume directamente, la cantidad de mensajes que se consumirán en la cola es 0