交换机

1.概念

假设的是工作队列背后，每个任务都恰好交付给一个消费者(工作进程)。
在这一部分中，我们将做一些完全不同的事情我们将消息传达给多个消费者。
这种模式称为”发布/订阅”.
为了说明这种模式，我们将构建一个简单的日志系统。 它将由两个程序组成:第一个程序将发出日志消息,第二个程序是消费者。
其中我们会启动两个消费者,其中一个消费者接收到消息后把日志存储在磁盘,另外一个消费者接收到消息后把消息打印在屏幕上,事实上第一个程序发出的日志消息将广播给所有消费者

2.Exchanges

RabbitMQ消息传递模型的核心思想是:生产者生产的消息从不会直接发送到队列。
实际上,通常生产者甚至都不知道这些消息传递传递到了哪些队列中。
相反，生产者只能将消息发送到交换机(exchange),交换机工作的内容非常简单，
一方面它接收来自生产者的消息，另一方面将它们推入队列。交换机必须确切知道如何处理收到的消息。
是应该把这些消息放到特定队列还是说把他们到许多队列中还是说应该丢弃它们。这就的由交换机的类型来决定。

3.类型

直接(direct),主题(topic) ,标题(headers) ,扇出(fanout)

3.1 无名Exchanges

使用的是默认交换，我们通过空字符串(")进行标识。

 channel.basicPublish("",QUEUE_NAME,null,message.getBytes(StandardCharsets.UTF_8));

第一个参数是交换机的名称。空字符串表示默认或无名称交换机:
消息能路由发送到队列中其实是由routingKey(bindingkey)绑定key指定的，如果它存在的话

3.2 临时队列

每当我们连接到Rabbit时，我们都需要一个全新的空队列
为此我们可以创建一个具有随机名称的队列，或者能让服务器为我们选择一个随机队列名称那就更好了。
其次一旦我们断开了消费者的连接,队列将被自动删除。
创建临时队列的方式如下:

String gueueName = chanel.queueDedare().getQueue();

4.绑定

什么是bingding呢，binding其实是exchange和queue之间的桥梁，它告诉我们exchange和那个队列进行了绑定关系。

5.fanout类型实现

• 生产者

 public static void main(String[] args) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");
        factory.setUsername("guest");
        factory.setPassword("guest");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        channel.exchangeDeclare("logs", "fanout");

        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            String message = sc.next();
            channel.basicPublish("logs","",null,message.getBytes(StandardCharsets.UTF_8));
        }
    }

• 消费者

public static void main(String[] args) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");
        factory.setUsername("guest");
        factory.setPassword("guest");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        //生明交换机
        channel.exchangeDeclare("logs", "fanout");
        //声明临时队列(名称随机，断开连接自动删除）
        String name = channel.queueDeclare().getQueue();
        //绑定交换机和队列
        channel.queueBind(name, "logs", "");

        DeliverCallback deliverCallback = (counsumerTag , message) -> {
            System.out.println(new String(message.getBody()));
        };
        CancelCallback cancelCallback = counsumerTag -> {
            System.out.println("消息被中断");
        };
        channel.basicConsume(name, true, deliverCallback,cancelCallback);
    }

6.direct类型

我们希望将日志消息写入磁盘的程序仅接收严重错误(error)，而不存储哪些警告(warning)或信息(info)日志消息避免浪费磁盘空间。
Fanout 这种交换类型并不能给我们带来很大的灵活性：它只能进行无意识的广播,
在这里我们将使用direct这种类型来进行替换，这种类型的工作方式是，消息只去到它绑定的routingKey队列中去。
交换机X绑定了两个队列,绑定类型是direct.
队列Q1绑定键为orange,
队列Q2绑定键有两个:一个绑定键为black,另一个绑定键为 green.
在这种绑定情况下，生产者发布消息到exchange上，绑定键为orange的消息会被发布到队列Q1。
绑定键为blackgreen和的消息会被发布到队列Q2,其他消息类型的消息将被丢弃。
当然如果exchange的绑定类型是direct,但是它绑定的多个队列的key如果都相同，在这种情
况下虽然绑定类型是direct但是它表现的就和fanout有点类似了，就跟广播差不多

• work1

public static void main(String[] args) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");
        factory.setUsername("guest");
        factory.setPassword("guest");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        //生明交换机
        channel.exchangeDeclare("direct_log", BuiltinExchangeType.DIRECT);
        //声明队列
        channel.queueDeclare("console", false,false,false, null);
        //绑定交换机和队列(队列名，交换机名，RoutingKey)
        channel.queueBind("console", "direct_log", "info");
        channel.queueBind("console", "direct_log", "warning");

        DeliverCallback deliverCallback = (counsumerTag , message) -> {
            System.out.println(new String(message.getBody()));
        };
        CancelCallback cancelCallback = counsumerTag -> {
            System.out.println("消息被中断");
        };
        channel.basicConsume("console", true, deliverCallback,cancelCallback);
    }

• work2

public static void main(String[] args) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");
        factory.setUsername("guest");
        factory.setPassword("guest");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        //生明交换机
        channel.exchangeDeclare("direct_log", BuiltinExchangeType.DIRECT);
        //声明队列
        channel.queueDeclare("disk", false,false,false, null);
        //绑定交换机和队列(队列名，交换机名，RoutingKey)
        channel.queueBind("disk", "direct_log", "error");

        DeliverCallback deliverCallback = (counsumerTag , message) -> {
            System.out.println(new String(message.getBody()));
        };
        CancelCallback cancelCallback = counsumerTag -> {
            System.out.println("消息被中断");
        };
        channel.basicConsume("disk", true, deliverCallback,cancelCallback);
    }

• produce

public static void main(String[] args) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");
        factory.setUsername("guest");
        factory.setPassword("guest");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            String message = sc.next();
            channel.basicPublish("direct_log","error",null,message.getBytes(StandardCharsets.UTF_8));
        }
    }

7.topic类型

Topic的要求
发送到该类型topic交换机的消息的routing_ key 不能随意写，必须满足一定的要求， 它必须是一个单词列表，以点号分隔开。
这些单词可以是任意单词,比如说: "stock.usd.nyse", "nyse .vmw",这种类型的。当然这个单词列表最多不能超过255个字节。
在这个规则列表中，共中有两个普换符
*(星号)可以代替一个单词

(井号)可以替代零个或多个单词

当一个队列绑定键是# ,那么这个队列将接收所有数据，就有点像fanout了
如果队列绑定键当中没有#和*出现，那么该队列绑定类型就是direct了

• work1

 public static void main(String[] args) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");
        factory.setUsername("guest");
        factory.setPassword("guest");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        //生明交换机
        channel.exchangeDeclare("topic_logs", "topic");
        //声明队列
        channel.queueDeclare("q1", false, false, false ,null);
        //绑定交换机和队列
        channel.queueBind("q1", "topic_logs", "*.orange.*");

        DeliverCallback deliverCallback = (counsumerTag , message) -> {
            System.out.println(new String(message.getBody()));
        };
        CancelCallback cancelCallback = counsumerTag -> {
            System.out.println("消息被中断");
        };
        channel.basicConsume("q1", true, deliverCallback,cancelCallback);
    }

• work2

public static void main(String[] args) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");
        factory.setUsername("guest");
        factory.setPassword("guest");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        //生明交换机
        channel.exchangeDeclare("topic_logs", "topic");
        //声明队列
        channel.queueDeclare("q2", false, false, false ,null);
        //绑定交换机和队列
        channel.queueBind("q2", "topic_logs", "lazy.#");
        channel.queueBind("q2", "topic_logs", "*.*.rabbit");

        DeliverCallback deliverCallback = (counsumerTag , message) -> {
            System.out.println(new String(message.getBody()));
        };
        CancelCallback cancelCallback = counsumerTag -> {
            System.out.println("消息被中断");
        };
        channel.basicConsume("q2", true, deliverCallback,cancelCallback);
    }

• produce

 public static void main(String[] args) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");
        factory.setUsername("guest");
        factory.setPassword("guest");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            String message = sc.next();
            channel.basicPublish("topic_logs",message,null,message.getBytes(StandardCharsets.UTF_8));
        }
    }