Java implementa o modelo de fila simples rabbitmq, fila de mensagens do produtor e consumidor

Os produtores enviam mensagens para a fila, os consumidores aleatórios recebem mensagens da fila

1. Crie usuários e hosts virtuais

Você pode criar usuários e hosts virtuais facilmente por meio da interface de gerenciamento de usuário fornecida por rabbitmq e precisa vincular usuários aos hosts virtuais correspondentes. Com seu próprio guestusuário e /host virtual, você também pode usar diretamente essas duas informações existentes. Criamos um host virtual chamado wuwluser e /vh, observe que o host virtual precisa /começar.

2. Importar dependências

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

3. Crie uma conexão, em que ConnectionUtils é considerado uma classe de ferramenta e os produtores e consumidores precisam 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. Criar produtor

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. Crie um consumidor. Se o canal do consumidor e o objeto de conexão não estiverem fechados, ele sempre estará no estado de monitoramento. Somente o produtor envia uma nova mensagem para a fila de mensagens, e o consumidor a consumirá imediatamente

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. Teste
   o produtor sozinho, podemos ver a fila que definimos na interface de gerenciamento e os benefícios que não foram consumidos

Após iniciar o consumidor, a mensagem é consumida e monitorada continuamente

Neste momento, o número de mensagens a serem consumidas na fila é 0

Envie uma mensagem para a fila de mensagens através do produtor novamente, o consumidor consome diretamente, o número de mensagens a serem consumidas na fila é 0