rabbitmq入门 五 exchange topic模式

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.Random;
import java.util.concurrent.TimeoutException;
/**
 * 现在：exchange交换机的topic模式
 * topic模式可以使用累心可以使用类似通配符一样的东西
 * 匹配规则：
 * 1.#代表零个或者多个字符
 * 2.*代表一个字符
 *
 * 场景
 * 红色，黄色，蓝色颜色的消息，分别发送到不同的队列，颜色只是其中的一个属性
 * 然后路由分别是：#.red.# 中间是红色的发送到red.queue队列
 * #.yellow.# 中间是黄色的发送到yellow.queue队列
 * *.blud.* 中间是蓝色的也发送到yellow.queue队列
 */
public class ExchangeTest {

    private static final String EXCHANGE_NAME = "topic.exchange";
    private static final String RED_QUEUE = "red.queue";
    private static final String YELLOW_QUEUE = "yellow.queue";

    private static final String RED_ROUTING = "#.red.#";
    private static final String YELLOW_ROUTING = "#.yellow.#";


    public static void main(String[] args) {

        new Thread(
                ()->{
                    /**
                     * 发送消息
                     */
                    ConnectionFactory factory = new ConnectionFactory();
                    factory.setHost("127.0.0.1");
                    factory.setUsername("rabbit");
                    factory.setPassword("rabbit");
                    //创建连接和通道
                    try(Connection conn = factory.newConnection(); Channel channel = conn.createChannel()){

                        //声明交换机  topic模式
                        channel.exchangeDeclare(EXCHANGE_NAME, "topic");
                        for(int i = 0; i <50; i++) {
                            Random random = new Random();
                            int flag = random.nextInt(2);
                            if(flag ==1) {
                                //发送到red.queue队列
                                String message = "red rabbitmq "+flag;
                                //发送到红色队列，匹配上面的路径#.red.#
                                channel.basicPublish(EXCHANGE_NAME,"red.less",null,message.getBytes(StandardCharsets.UTF_8));
                            } else {
                                //发送到red.queue队列
                                String message = "yellow rabbitmq "+flag;
                                //发送到黄色队列，匹配上面的路径#.yellow.#
                                channel.basicPublish(EXCHANGE_NAME,"three.yellow",null,message.getBytes(StandardCharsets.UTF_8));
                            }
                        }
                    } catch(Exception e) {
                        e.printStackTrace();
                    }
                }
        ).start();
        //消费者1
        new Thread(
                ()->{
                    //接收消息
                    ConnectionFactory comsumerFacotry = new ConnectionFactory();
                    comsumerFacotry.setHost("127.0.0.1");
                    comsumerFacotry.setUsername("rabbit");
                    comsumerFacotry.setPassword("rabbit");

                    Connection comsumerConn = null;
                    try {
                        //这里不手动关闭连接和通道，因为需要监听器一直监听是否有消息，所以需要一直保持连接
                        comsumerConn = comsumerFacotry.newConnection();
                        Channel channel = comsumerConn.createChannel();
                        //声明交换机  topic模式
                        channel.exchangeDeclare(EXCHANGE_NAME, "topic");
                        //声明队列RED_QUEUE
                        channel.queueDeclare(RED_QUEUE, false, false, false, null);
                        //绑定交换机和队列
                        channel.queueBind(RED_QUEUE, EXCHANGE_NAME, RED_ROUTING);
                        //消息监听器
                        boolean autoAck = true;//是否自动ack   接收到消息则认为成功

                        channel.basicConsume(RED_QUEUE, autoAck, (consumerTag, message) -> {
                            System.out.println("消费者 红色收到消息:" + new String(message.getBody(), StandardCharsets.UTF_8));
                        }, consumerTag -> {});
                    } catch (IOException e) {
                        e.printStackTrace();
                    } catch (TimeoutException e) {
                        e.printStackTrace();
                    }
                }
        ).start();

        //消费者1
        new Thread(
                ()->{
                    //接收消息
                    ConnectionFactory comsumerFacotry = new ConnectionFactory();
                    comsumerFacotry.setHost("127.0.0.1");
                    comsumerFacotry.setUsername("rabbit");
                    comsumerFacotry.setPassword("rabbit");

                    Connection comsumerConn = null;
                    try {
                        //这里不手动关闭连接和通道，因为需要监听器一直监听是否有消息，所以需要一直保持连接
                        comsumerConn = comsumerFacotry.newConnection();
                        Channel channel = comsumerConn.createChannel();
                        //创建时幂等的， 已存在不会再次创建
                        channel.exchangeDeclare(EXCHANGE_NAME, "topic");
                        channel.queueDeclare(YELLOW_QUEUE, false, false, false, null);
                        channel.queueBind(YELLOW_QUEUE, EXCHANGE_NAME, YELLOW_ROUTING);
                        //消息监听器
                        boolean autoAck = true;//是否自动ack   接收到消息则认为成功

                        channel.basicConsume(YELLOW_QUEUE, autoAck, (consumerTag, message) -> {
                            System.out.println("消费者 黄色 收到消息:" + new String(message.getBody(), StandardCharsets.UTF_8));
                        }, consumerTag -> {});
                    } catch (IOException e) {
                        e.printStackTrace();
                    } catch (TimeoutException e) {
                        e.printStackTrace();
                    }
                }
        ).start();

    }


}