RabbitMQ模式の发布订阅模式

目录

• 1、说明
• 2、模型图
• 3、示例代码
  • 3.1、生成者
  • 3.2、消费者
    • 3.2.1、生成者A
    • 3.2.2、生成者B

1、说明

功能：一个生产者发送的消息会被多个消费者获取。一个生产者、一个交换机、多个队列、多个消费者
生产者：可以将消息发送到队列或者是交换机。
消费者：只能从队列中获取消息。如果消息发送到没有队列绑定的交换机上，那么消息将丢失。交换机不能存储消息，消息存储在队列中

2、模型图

3、示例代码

3.1、生成者

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import org.apache.commons.lang3.StringUtils;

import java.io.IOException;
import java.util.Objects;
import java.util.concurrent.TimeoutException;

import static java.nio.charset.StandardCharsets.UTF_8;

public class Publisher {

    private static final String MQ_VIRTUAL_HOST     = "VHOST::TUTORIAL";
    private static final String MQ_EXCHANGE_NAME    = "EXCHANGE::TUTORIAL::FANOUT";

    public static void main(String[] args) {
        Connection connection = null;
        Channel channel = null;
        try {
            final ConnectionFactory factory = new ConnectionFactory();
            factory.setHost("127.0.0.1");
            factory.setPort(5672);
            factory.setUsername("admin");
            factory.setPassword("romens");
            factory.setVirtualHost(MQ_VIRTUAL_HOST);

            connection = factory.newConnection();
            channel = connection.createChannel();

            channel.basicPublish(MQ_EXCHANGE_NAME, StringUtils.EMPTY, null, "Hello Kitty".getBytes(UTF_8));
        } catch (IOException | TimeoutException e) {
            e.printStackTrace();
        } finally {
            if (Objects.nonNull(channel)) {
                try {
                    channel.close();
                } catch (IOException | TimeoutException e) {
                    e.printStackTrace();
                }
            }
            if (Objects.nonNull(connection)) {
                try {
                    connection.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

3.2、消费者

3.2.1、生成者A

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.Objects;
import java.util.concurrent.TimeoutException;

import static java.nio.charset.StandardCharsets.UTF_8;
import static org.apache.commons.lang3.StringUtils.EMPTY;

public class ConsumerA {

    private static final String MQ_VIRTUAL_HOST     = "VHOST::TUTORIAL";
    private static final String MQ_EXCHANGE_NAME    = "EXCHANGE::TUTORIAL::FANOUT";
    private static final String MQ_QUEUE_NAME       = "QUEUE::TUTORIAL::A";

    public static void main(String[] args) {
        Connection connection = null;
        Channel channel = null;
        try {
            final ConnectionFactory factory = new ConnectionFactory();
            factory.setHost("127.0.0.1");
            factory.setPort(5672);
            factory.setUsername("admin");
            factory.setPassword("romens");
            factory.setVirtualHost(MQ_VIRTUAL_HOST);

            connection = factory.newConnection();
            channel = connection.createChannel();

            channel.queueBind(MQ_QUEUE_NAME, MQ_EXCHANGE_NAME, EMPTY);

            System.out.println("[*] Waiting for messages. To exits press CTRL+C");

            final DefaultConsumer consumer = new DefaultConsumer(channel) {

                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) {
                    System.out.println(" [X] Received '" + new String(body, UTF_8) + "'");
                }

            };
            channel.basicConsume(MQ_QUEUE_NAME, true, consumer);
            while (true) {
                synchronized (consumer) {
                    try {
                        consumer.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        } catch (IOException | TimeoutException e) {
            e.printStackTrace();
        } finally {
            if (Objects.nonNull(channel)) {
                try {
                    channel.close();
                } catch (IOException | TimeoutException e) {
                    e.printStackTrace();
                }
            }
            if (Objects.nonNull(connection)) {
                try {
                    connection.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

3.2.2、生成者B

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.Objects;
import java.util.concurrent.TimeoutException;

import static java.nio.charset.StandardCharsets.UTF_8;
import static org.apache.commons.lang3.StringUtils.EMPTY;

/**
 * 发布订阅模式
 */
public class ConsumerB {

    private static final String MQ_VIRTUAL_HOST     = "VHOST::TUTORIAL";
    private static final String MQ_EXCHANGE_NAME    = "EXCHANGE::TUTORIAL::FANOUT";
    private static final String MQ_QUEUE_NAME       = "QUEUE::TUTORIAL::B";

    public static void main(String[] args) {
        Connection connection = null;
        Channel channel = null;
        try {
            final ConnectionFactory factory = new ConnectionFactory();
            factory.setHost("127.0.0.1");
            factory.setPort(5672);
            factory.setUsername("admin");
            factory.setPassword("romens");
            factory.setVirtualHost(MQ_VIRTUAL_HOST);

            connection = factory.newConnection();
            channel = connection.createChannel();

            channel.queueBind(MQ_QUEUE_NAME, MQ_EXCHANGE_NAME, EMPTY);

            System.out.println("[*] Waiting for messages. To exits press CTRL+C");

            final DefaultConsumer consumer = new DefaultConsumer(channel) {

                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) {
                    System.out.println(" [X] Received '" + new String(body, UTF_8) + "'");
                }

            };
            channel.basicConsume(MQ_QUEUE_NAME, true, consumer);
            while (true) {
                synchronized (consumer) {
                    try {
                        consumer.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        } catch (IOException | TimeoutException e) {
            e.printStackTrace();
        } finally {
            if (Objects.nonNull(channel)) {
                try {
                    channel.close();
                } catch (IOException | TimeoutException e) {
                    e.printStackTrace();
                }
            }
            if (Objects.nonNull(connection)) {
                try {
                    connection.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}