RabbitMQ系列之三：publish subscribe

server端代码：

package com.example.publishsubscribe;

import java.io.IOException;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

public class Send {
    
    // 定义一个logs的邮局，对消息进行分发处理
    private static final String EXCHANGE_NAME = "logs";

    public static void main(String[] args) throws IOException {
        
        ConnectionFactory factory = new ConnectionFactory();
        
        //远程服务器ip，如果在本地测试可以改成localhost
        factory.setHost("121.40.151.120");
        
        //不是在本地测试，用户名和密码必填
        factory.setUsername("rabbitmqtest");
        factory.setPassword("rabbitmqtest");
        
        Connection conn = factory.newConnection();
        Channel channel = conn.createChannel();
        
        /** 
         * 参数说明：
         * exchange:邮局名称
         * type： 
         *         direct： 通过routingKey和exchange决定的那个唯一的queue可以接收消息。
         *                        它会处理routingKey，需要将一个队列绑定到交换机上，要求该消息与一个特定的路由键完全匹配。
         *                 这是一个完整的匹配。如果一个队列绑定到该交换机上要求路由键 “dog”，则只有被标记为“dog”的消息才被转发，
         *                 不会转发dog.puppy，也不会转发dog.guard，只会转发dog。 
         *         topic：    所有符合routingKey(此时可以是一个表达式)的routingKey所bind的queue可以接收消息。
         *                 将路由键和某模式进行匹配。此时队列需要绑定要一个模式上。符号“#”匹配一个或多个词，符号“*”匹配不多不少一个词。
         *                 因此“audit.#”能够匹配到“audit.irs.corporate”，但是“audit.*” 只会匹配到“audit.irs”。
         *         fanout：  所有bind到此exchange的queue都可以接收消息。
         *                 不会处理routingKey。你只需要简单的将队列绑定到交换机上。
         *                一个发送到交换机的消息都会被转发到与该交换机绑定的所有队列上。
         *                 很像子网广播，每台子网内的主机都获得了一份复制的消息。Fanout交换机转发消息是最快的。 
         * 
        */
        channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
        
        String message = getMessage(new String[] { "test" });  
        
        /** 
         * 参数说明：
         * exchange:默认的exchange就是"",是direct类型的，
         *             任何发往到默认exchange的消息都会被路由到routingKey的名字对应的队列上，如果没有对应的队列，则消息会被丢弃。
         * routingKey：因为这里的exchange类型是fanout的，所以会匹配所有的routingKey。
         * props：其它属性，比如消息路由头信息,持久化信息
         * body：消息内容
        */  
        channel.basicPublish(EXCHANGE_NAME, "anyRoutingKey", null, message.getBytes());  
        
        System.out.println("send[" + message + "]");  
          
        // 最后，我们关闭channel和连接，释放资源。  
        channel.close();  
        conn.close(); 
    }
    
    private static String getMessage(String[] strings) {  
        if (strings.length < 1) {  
            return "Hello World!";  
        }  
        return joinStrings(strings, " ");  
    }  
  
    private static String joinStrings(String[] strings, String delimiter) {  
        int length = strings.length;  
        if (length == 0) {  
            return "";  
        }  
        StringBuilder words = new StringBuilder(strings[0]);  
        for (int i = 1; i < length; i++) {  
            words.append(delimiter).append(strings[i]);  
        }  
        return words.toString();  
    } 
    
}

 

client端代码：

package com.example.workqueue;

import java.io.IOException;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.ConsumerCancelledException;
import com.rabbitmq.client.QueueingConsumer;
import com.rabbitmq.client.ShutdownSignalException;

public class Recv {
    
    private static final String EXCHANGE_NAME = "logs";  

    public static void main(String[] args) throws IOException, ShutdownSignalException, 
        ConsumerCancelledException, InterruptedException {
        
        ConnectionFactory factory = new ConnectionFactory(); 
        
        factory.setHost("121.40.151.120");
        factory.setUsername("rabbitmqtest");
        factory.setPassword("rabbitmqtest");
        
        Connection connection = factory.newConnection();  
        Channel channel = connection.createChannel();  
        channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
        
        // 临时队列（temporary queue）  
        // 首先，无论什么时候连接Rabbit时，我们需要一个新的、空的队列  
        // First, whenever we connect to Rabbit we need a fresh, empty queue.  
        // 为了做到这一点，我们可以创建一个随机命名的队列，或者更好的，就让服务端给我们选择一个随机的队列名字。  
        // 其次，一旦我们关闭消费者的连接，这个临时队列应该自动销毁。
        String queueName = channel.queueDeclare().getQueue(); 
        // routingKey这里是没有任何作用的，也就是名字可以随便取
        channel.queueBind(queueName, EXCHANGE_NAME, "anyRoutingKey2");
        
        System.out.println("CRTL+C");  
          
        // QueueingConsumer：用来缓存服务端推送给我们的消息。  
        QueueingConsumer consumer = new QueueingConsumer(channel);  
        channel.basicConsume(queueName, true, consumer);
        
        while (true) {  
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();  
            String message = new String(delivery.getBody());  
            System.out.println("[" + message + "]");  
        } 
    }

}

 

三种Exchange的图解：

direct exchange：

fanout exchange：

topic exchange：