【RabbitMQ】三、RabbitMQ工作模式

最新推荐文章于 2022-06-19 21:22:43 发布

随记-1

最新推荐文章于 2022-06-19 21:22:43 发布

阅读量162

点赞数

分类专栏： RabbitMQ 文章标签： rabbitmq

本文链接：https://blog.csdn.net/l_s_r/article/details/116664388

版权

RabbitMQ 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

一、前言：

上篇文章讲述了MQ跟RabbitMQ的基本概念及相关内容，那么这篇内容就是真正的硬核知识：rabbit的工作模式及代码实现，废话不多说，开始干。。。。。。。。。。

二、准备内容：

1.作者使用的springboot项目，所以在开始前需要在pom.xml文件引入RabbitMQ的依赖，如下：

<!--rabbitMq依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

2.因为每次请求都需要获取连接，所以就可以把这部分代码单独拿出来写一个工具类，使用的时候直接调用就行：

import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
/**
 * RabbitMQ连接工具类
 */
public class ConnectionUtil {

    public static Connection getConnection() throws IOException, TimeoutException {
        //创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.102.130");
        factory.setPort(5672);
        factory.setUsername("user");
        factory.setPassword("user");
        //设置虚拟机,一个mq服务可以设置多个虚拟机，每个虚拟机就相当于一个独立的mq
        factory.setVirtualHost("/");
        //通过工厂获取连接
        Connection connection = factory.newConnection();
        return connection;
    }
}

三、工作模式：

1.Work queues（工作队列）模式：

特点：

1.一个生产者，一个队列，多个消费者同时竞争消息；

2.一条消息只会被一个消费者接收；

3.rabbit采用轮询的方式将消息平均发送给消费者的；

4.消费者在处理完某条消息后，才会收到下一条消息；而且队列中的消息一旦被消费，就会消失，因为任务是不会被重复执行的。

应用场景：

对于任务过重或任务较多时使用工作队列可以提高任务处理的速度。

生产者代码：

public class ProducerWork{
    //队列名称
    private static final String QUEUE_WORK = "queue_work";
    
    public static void main(String[] args){
        Connection conn = null;
        Channel channel = null;
        try{
            //获取连接
            conn = ConnectionUtil.getConnection();
            //获取通道
            channel  = conn.createChannel();
            //声明队列
            channel.queueDeclare(QUEUE_WORK ,true,false,false,null);
            //发送消息
            //参数：String exchange, String routingKey, BasicProperties props, byte[] body
            /**
             * 参数明细：
             * 1、exchange，交换机，如果不指定将使用mq的默认交换机（设置为""）
             * 2、routingKey，路由key，交换机根据路由key来将消息转发到指定的队列，如果使用默认交换机，routingKey设置为队列的名称
             * 3、props，消息的属性
             * 4、body，消息内容
             */
            for(int i=0;i<100;i++){
                String message="queue work模式:"+i;
                channel.basicPublish("",QUEUE_WORK,null,messgae.getByte());
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            //先关闭通道
            //关闭连接
            try {
                channel.close();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (TimeoutException e) {
                e.printStackTrace();
            }
            try {
                connection.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        
    }

}

消息接收者1：

public class ConsumerWorkOne{
    //
    private static final String QUEUE_WORK="queue_work";

    public static void main(String[] args){
        //获取连接
        Connection conn = ConnectionUtil.getConnection();
        //获取通道
        Channel channel = conn.createChannel();
        //声明队列
        channel.queueDeclare(QUEUE_WORK,true,false,false,null);
        //监听队列、获取消息
        channel.baiscConsume("",true,new DefaultConsumer(channel){
             @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    System.out.println("消费者1接收的值："+new String(body,"utf-8"));
                }
        });
        
    }

}

消息接收者2(每输出一句就sleep1s)：

public class ConsumerWorkTwo{
    //
    private static final String QUEUE_WORK="queue_work";

    public static void main(String[] args){
        //获取连接
        Connection conn = ConnectionUtil.getConnection();
        //获取通道
        Channel channel = conn.createChannel();
        //声明队列
        channel.queueDeclare(QUEUE_WORK,true,false,false,null);
        //监听队列、获取消息
        channel.baiscConsume("",true,new DefaultConsumer(channel){
             @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    System.out.println("消费者2接收的值："+new String(body,"utf-8"));
                    try{
                        Thread.sleep(1000);
                    }catch(InterruptedException e){
                        e.printStackTrace();
                    }
                }
        });
        
    }

}

输出结果：

图解：

队列均匀把消息分配给2个消费者，消费者1接收非常快；消费者2因为加了睡眠导致接收很慢，分配给消费者2的其他消息一直在等消费者2来接收，这样的话就出现了这种情况：消费者1已经接收完了，但是消费者2还在接收，也就是能者不多劳的情况，解决这种情况需要一种机制：消息自动确认机制。

消息自动确认机制：

work queue 模式是均匀分配消息的，但是每个消费者的处理能力速度不一样；所以要想实现能者多劳，就需要手动回复确认消息。

实现代码：

public class ConsumerAuto{
    //
    private static final String QUEUE_WORK="queue_work";
    public static void main(String[] args){
        //获取连接
        Connection conn = ConnectionUtil.getConnection();
        //获取通道
        Channel channel = conn.createChannel();
        //
        channel.basicQos(1);
        //声明队列
        channel.queueDeclare(QUEUE_WORK,true,false,false,null);
        //监听队列、获取消息
        channel.baiscConsume("",false,new DefaultConsumer(channel){
             @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    System.out.println(new String(body));
                    //手动确认
                    /**
                    * 参数明细：
                    * deliveryTag ： 消息id
                    * boolean : false:每次确认一个
                    */
                    channel.basicAck(envelope.getDeliveyTag(),false);
                }
        });
    }
}

给队列的所有消息设置过期时间TTL：

声明队列时设置1个x-message-ttl的属性，并设置过期时间，凡是推送到该队列中的所有消息，都会有一个设定时间之后过期的属性。

代码实现：

HashMap<String,Object> map = new HashMap<String,Object>();
map.put("x-messgae-ttl",30000); //队列中的消息未被消费则30s后过期
channel.queueDeclare("work queue",true,false,false,map);

2.Publish/subscribe (发布/订阅)模式：

特点：

1.每个消费者监听自己的队列；

2.生产者将消息发送给broker，由交换机将消息转发到绑定了此交换机的每个队列，每个绑定交换机的队列都将接收到消息。

3.队列的消费者都能拿到消息，实现一条消息被多个消费者消费。

生产者代码：

** ：Publish/subscribe 模式对应交换机类型为：fanout 。

public class Producer_publish{
    //队列名称
    private static final String QUEUE_ONE = "queue_one";
    private static final String QUEUE_TWO = "queue_two";
    //交换机名称
    private static final String EXCHANGE_ONE = "exchange_one";
    
    public static void main(String[] args){
        Connection connection =null;
        Channel channel = null;
        try{
            //获取连接
        connection = ConnectionUtil.getConnection();
            //获取管道，生产者和mq服务所有通信都在channel通道中完成
        channel = connection.createChannel();
            //声明队列，如果队列在mq中没有则要创建
            /**
            * 参数明细：
            * 1、String queue : 队列名称
            * 2、boolean durable ：是否持久化，如果持久化，mq重启后队列还在
            * 3、boolean exclusive：是否独占连接，队列只允许在该连接中访问，如果connection连接关闭队列则自动删除，如果将此参数设置为true可用于临时队列的创建。
            * 4、boolean autoDelete：自动删除，队列不再使用时是否自动删除此队列，如果将此参数和exclusive参数设置为true就可以实现临时队列（队列不用了就自动删除）
            * 5、Map<String,Object> arguments : 可以设置一个队列的扩展参数，比如：可设置存活时间
            */
        channel.queueDeclare(QUEUE_ONE ,true,false,false,null);
        channel.queueDeclare(QUEUE_TWO,true,false,false,null);
            //声明一个交换机
            /**
            * 参数明细：
            * 1、String exchange : 交换机的名称
            * 2、String type ： 交换机的类型
            * fanout: 对应的rabbitmq的工作模式是：publish/subscribe
            * direct: 对应的Routing模式
            * topic: 对应的Topics工作模式
            * headers: 对应的headers工作模式
            */
        channel.exchangeDeclare(EXCHANGE_ONE,BuiltinExchangeType.FANOUT);
            //进行交换机和队列绑定
            /**
            * 参数明细：
            * 1、String queue ：队列名称
            * 2、String exchange ：交换机名称
            * 3、routingkey ：路由key，作用是交换机根据路由key的值将信息转发到指定的队列，在发布订阅模式中调协为空字符串。
            */
        channel.queueBind(QUEUE_ONE ,EXCHANGE_ONE ,"");
        channel.queueBind(QUEUE_TWO ,EXCHANGE_ONE ,"");
            //发送消息
            /**
            * 参数明细：
            * String exchange : 交换机名称，如果不指定将使用mq的默认交换机（设置为“”）
            * String routingKey : 路由key，交换机根据路由key来将信息转发到指定的队列，如果使用默认交换机，routingKey设置为队列的名称
            * BasicProperties props : 消息的属性
            * byte[] body ： 消息的内容
            */
        for(int i=0;i<5;i++){
            //消息内容
            String message = "Hello World! RabbitMq......"+i;
            channel.basicPublish(EXCHANGE_ONE,"",null,message.getBytes());
            System.out.println("producer send to MQ ："+message);
        }
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            //先关闭通道
            //关闭连接
            try{
                channel.close();
            }catch(){
                 e.printStackTrace();
            }
            try{
                connection.close();
            }catch(){
                 e.printStackTrace();
            }
        }
    }
}

消息接收者1：

public class ConsumerOne{
    //队列名称
    private static final String QUEUE_ONE = "queue_one";
    //交换机名称
    private static final String EXCHANGE_ONE = "exchange_one";

    public static void main(String[] args) throws Exception{
        //创建连接
        Connection connection = ConnectionUtil.getConnection();
        //创建通道
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUE_ONE ,true,false,false,null);
        //声明一个交换机
        channel.exchangeDeclare(EXCHANGE_ONE ,BuiltinExchangeType.FANOUT);
        //进行交换机和队列的绑定
        channel.queueBind(QUEUE_ONE ,EXCHANGE_ONE ,"");
        //实现消费方法
        DefaultConsumer consumer = new DefaultConsumer(channel){
            /**
            * 当接收到消息后此方法将被调用
            * @param consumerTag : 消费者标签，用来标识消费者的，在监听队列时设置channel.basicConsume
            * @param envelope : 信封，通过envelope
            * @param properties : 消息属性
            * @param body : 消息内容
            * @throws IOException
            */
            @Override
            public void handleDelivery(String consumerTag,Envelope envelope,AMQP.BasicProperties properties,byte[] body) throws IOException {
                //交换机
                String exchange = envelope.getExchange();
                //消息id，mq在channel中用来标识消息的id，可用于确认消息已接收
                long deliveryTag = envelope.getDeliveryTag();
                //消息内容
                String message = new String(body,"utf-8");
                System.out.println("消费者1接收到消息："+message);
            }
        };
        //监听队列
        //参数：String queue, boolean autoAck, Consumer callback
        /**
        * 参数明细
        * 1、queue : 队列名称
        * 2、autoAck : 自动回复，当消费者接收到消息后要告诉mq消息已接收，如果将此参数设置为true表示会自动回复mq，设置为false时要通过编程实现回复
        * 3、callback : 消费方法，当消费者接收到消息要执行的方法
        */
        channel.basicConsume(QUEUE_ONE,true,consumer);
    }

}

消息接收者2：

public class ConsumerTwo{
    //队列
    private static final String QUEUE_TWO = "queue_one";
    //交换机
    private static final String EXCHANGE_ONE = "exchange_one";
    
    public static void main(String[] args) throws Exception{
        //获取连接
        Connection connection = ConnectionUtil.getConnection();
        //获取通道
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUE_TWO ,true,false,false,null);
        //声明一个交换机
        channel.exchangeDeclare(EXCHANGE_ONE ,BuiltinExchangeType.FANOUT);
        //进行交换机跟队列的绑定
        channel.queueBind(QUEUE_TWO ,EXCHANGE_ONE ,"");
        //实现消费方法
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //交换机
                String exchange = envelope.getExchange();
                //消息id，mq在channel中用来标识消息的id，可用于确认消息已接收
                long deliveryTag = envelope.getDeliveryTag();
                //消息内容
                String message= new String(body,"utf-8");
                System.out.println("消费者2接收到消息："+message);
            }
        };
        //监听队列
        channel.basicConsume(QUEUE_TWO ,true,defaultConsumer );
    }
    
}

3. Routing （路由）模式：

图解：

P：生产者，向Exchange发送消息，发送消息时，会指定一个routing key。
X：Exchange（交换机），接收生产者的消息，然后把消息递交给与routing key完全匹配的队列
C1：消费者，其所在队列指定了需要routing key 为 error 的消息
C2：消费者，其所在队列指定了需要routing key 为 info、error、warning 的消息

特点：

1.每个消费者监听自己的队列，并且设置routingKey；

2.生产者将消息发送给交换机，由交换机根据routingkey来转发消息到指定的队列。

生产者代码：

** ：Routing 模式对应交换机类型为：Direct

public class ProducerRouting{
     //队列名称
    private static final String QUEUE_ONE = "queue_one";
    private static final String QUEUE_TWO = "queue_two";
    // 交换机名称
    private static final String EXCHANGE_ONE="exchange_one";
    // 路由键名称
    private static final String ROUTINGKEY_ONE="routingkey_one";
    private static final String ROUTINGKEY_TWO="routingkey_two";
    public static void main(String[] args) {
        Connection connection = null;
        Channel channel = null;
        try{
            //通过连接工厂创建新的连接和mq建立连接
            connection = ConnoectionUtil.getConnection();
            //创建会话通道,
            channel = connection.createChannel();
            //声明队列，如果队列在mq 中没有则要创建
            channel.queueDeclare(QUEUE_ONE ,true,false,false,null);
            channel.queueDeclare(QUEUE_TWO ,true,false,false,null);
            //声明一个交换机
            //参数：String exchange, String type
            /**
             * 参数明细：
             * 1、交换机的名称
             * 2、交换机的类型
             * fanout：对应的rabbitmq的工作模式是 publish/subscribe
             * direct：对应的Routing 工作模式
             * topic：对应的Topics工作模式
             * headers： 对应的headers工作模式
             */
            channel.exchangeDeclare(EXCHANGE_ONE, BuiltinExchangeType.DIRECT);
             //进行交换机和队列绑定
            //参数：String queue, String exchange, String routingKey
            /**
             * 参数明细：
             * 1、queue 队列名称
             * 2、exchange 交换机名称
             * 3、routingKey 路由key，作用是交换机根据路由key的值将消息转发到指定的队列中，在发布订阅模式中调协为空字符串
             */
             channel.queueBind(QUEUE_ONE ,EXCHANGE_ONE,ROUTINGKEY_ONE);
             channel.queueBind(QUEUE_TWO ,EXCHANGE_ONE,ROUTINGKEY_TWO);
             //发送消息
             //参数：String exchange, String routingKey, BasicProperties props, byte[] body
            /**
             * 参数明细：
             * 1、exchange，交换机，如果不指定将使用mq的默认交换机（设置为""）
             * 2、routingKey，路由key，交换机根据路由key来将消息转发到指定的队列，如果使用默认交换机，routingKey设置为队列的名称
             * 3、props，消息的属性
             * 4、body，消息内容
             */
              for(int i=0;i<5;i++){
                //发送消息的时候指定routingKey
                String message = "生产者发送消息ONE"+i;
                channel.basicPublish(EXCHANGE_ONE,ROUTINGKEY_ONE,null,message.getBytes());
                System.out.println("send to mq "+message);
            }
            for(int i=0;i<5;i++){
                //发送消息的时候指定routingKey
                String message = "生产者发送消息TWO"+i;
                channel.basicPublish(EXCHANGE_ONE,ROUTINGKEY_TWO,null,message.getBytes());
                System.out.println("send to mq "+message);
            }
            
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            //先关闭通道
            //关闭连接
            try {
                channel.close();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (TimeoutException e) {
                e.printStackTrace();
            }
            try {
                connection.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
    }

}

消息接收者1：

public class ConsumerKeyOne{
     //队列名称
    private static final String QUEUE_ONE = "queue_one";
    // 交换机名称
    private static final String EXCHANGE_ONE="exchange_one";
    // 路由键名称
    private static final String ROUTINGKEY_ONE="routingkey_one";

    public static void main(String[] args) throws IOException, TimeoutException {
        //建立新连接
        Connection connection = ConnectionUtil.getConnection();
        //创建会话通道,生产者和mq服务所有通信都在channel通道中完成
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUE_ONE ,true,false,false,null);
        //声明一个交换机
        channel.exchangeDeclare(EXCHANGE_ONE,BuiltinExchangeType.DIRECT);
        //进行交换机跟队列的绑定
        channel.queueBind(QUEUE_ONE ,EXCHANGE_ONE,ROUTINGKEY_ONE);
        //实现消费方法
        DefaultConsumer defaultConsumer = new DefaultConsumer(){
            /**
             * 当接收到消息后此方法将被调用
             * @param consumerTag  消费者标签，用来标识消费者的，在监听队列时设置channel.basicConsume
             * @param envelope 信封，通过envelope
             * @param properties 消息属性
             * @param body 消息内容
             * @throws IOException
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //交换机
                String exchange = envelope.getExchange();
                //消息id，mq在channel中用来标识消息的id，可用于确认消息已接收
                long deliveryTag = envelope.getDeliveryTag();
                //消息内容
                String message= new String(body,"utf-8");
                System.out.println("消费者1接收到的消息："+message);
            }
        };
        //监听队列
        channel.basicConsume(QUEUE_ONE ,true,defaultConsumer);
    }
}

消息接收者2：

public class ConsumerKeyTwo{
     //队列名称
    private static final String QUEUE_TWO = "queue_two";
    // 交换机名称
    private static final String EXCHANGE_ONE="exchange_one";
    // 路由键名称
    private static final String ROUTINGKEY_TWO="routingkey_two";

    public static void main(String[] args) throws IOException, TimeoutException {
        //建立新连接
        Connection connection = ConnectionUtil.getConnection();
        //创建会话通道,生产者和mq服务所有通信都在channel通道中完成
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUE_TWO ,true,false,false,null);
        //声明一个交换机
        channel.exchangeDeclare(EXCHANGE_TWO,BuiltinExchangeType.DIRECT);
        //进行交换机跟队列的绑定
        channel.queueBind(QUEUE_TWO ,EXCHANGE_ONE,ROUTINGKEY_TWO);
        //实现消费方法
        DefaultConsumer defaultConsumer = new DefaultConsumer(){
            /**
             * 当接收到消息后此方法将被调用
             * @param consumerTag  消费者标签，用来标识消费者的，在监听队列时设置channel.basicConsume
             * @param envelope 信封，通过envelope
             * @param properties 消息属性
             * @param body 消息内容
             * @throws IOException
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //交换机
                String exchange = envelope.getExchange();
                //消息id，mq在channel中用来标识消息的id，可用于确认消息已接收
                long deliveryTag = envelope.getDeliveryTag();
                //消息内容
                String message= new String(body,"utf-8");
                System.out.println("消费者2接收到的消息："+message);
            }
        };
        //监听队列
        channel.basicConsume(QUEUE_TWO ,true,defaultConsumer);
    }
}

4.Topics （通配）模式：

特点：

1.每个消费者监听自己的队列，并且设置带通配符的routingkey（ routingkey一般都是由一个或多个单词组成，多个单词之间以”.”分割，例如： item.insert）；

2.生产者将消息发送给broker，由交换机根据routingkey来转发消息到指定的队列。

生产者代码：

public class Producer04_topics {
    // 队列名称
    private static final String QUEUE_ONE = "queue_one";
    private static final String QUEUE_TWO = "queue_two";
    // 声明交换机
    private static final String EXCHANGE_TOPICS="exchange_topics";
    // 使用通配符的方式来,设置路由键
    private static final String ROUTINGKEY_ONE="inform.#.one.#";
    private static final String ROUTINGKEY_TWO="inform.#.two.#";
    public static void main(String[] args) {
        Connection connection = null;
        Channel channel = null;
        try {
            //建立新连接
            connection = ConnectionUtil.getConnection();
            //创建会话通道,生产者和mq服务所有通信都在channel通道中完成
            channel = connection.createChannel();
            //声明队列，如果队列在mq 中没有则要创建
            channel.queueDeclare(QUEUE_ONE ,true,false,false,null);
            channel.queueDeclare(QUEUE_TWO ,true,false,false,null);
            //声明一个交换机
            channel.exchangeDeclare(EXCHANGE_TOPICS, BuiltinExchangeType.TOPIC);
            //进行交换机和队列绑定
            channel.queueBind(QUEUE_ONE ,EXCHANGE_TOPICS,ROUTINGKEY_ONE);
            channel.queueBind(QUEUE_TWO ,EXCHANGE_TOPICS,ROUTINGKEY_TWO);
            for(int i=0;i<5;i++){
                //发送消息的时候指定routingKey
                String message = "send one inform message to user";
                channel.basicPublish(EXCHANGE_TOPICS,"inform.one",null,message.getBytes());
                System.out.println("send to mq "+message);
            }
            for(int i=0;i<5;i++){
                //发送消息的时候指定routingKey
                String message = "send two inform message to user";
                channel.basicPublish(EXCHANGE_TOPICS,"inform.two",null,message.getBytes());
                System.out.println("send to mq "+message);
            }
            for(int i=0;i<5;i++){
                //发送消息的时候指定routingKey
                String message = "send sms and email inform message to user";
                channel.basicPublish(EXCHANGE_TOPICS,"inform.two.email",null,message.getBytes());
                System.out.println("send to mq "+message);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //关闭连接
            //先关闭通道
            try {
                channel.close();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (TimeoutException e) {
                e.printStackTrace();
            }
            try {
                connection.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

消息接收者1：

public class ConsumerTopiceOne{
    //队列名称
    private static final String QUEUE_ONE = "queue_one";
    //交换机名称
    private static final String EXCHANGE_TOPICS="exchange_topics";
    //路由key
    private static final String ROUTINGKEY_ONE="inform.#.one.#";

    public static void main(String[] args) throws Exception{
        //获取连接
        Connection connection = ConnectionUtil.getConnection();
        //获取通道
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUE_ONE ,true,false,false,null);
        //声明一个交换机
        channel.exchangeDeclare(EXCHANGE_TOPICS,BuiltinExchanggeType.TOPIC);
        //进行交换机跟队列的绑定
        channel.queueBind(QUEUE_ONE ,EXCHANGE_TOPICS,ROUTINGKEY_ONE);
        //获取消息
        DefaultConsumer dafaultConsumer = new DefaultConsumer(channel){
             @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //交换机
                String exchange = envelope.getExchange();
                //消息id，mq在channel中用来标识消息的id，可用于确认消息已接收
                long deliveryTag = envelope.getDeliveryTag();
                //消息内容
                String message= new String(body,"utf-8");
                System.out.println("消费者1接收到的信息:"+message);
            }
        
        };
        //监听队列
        channel.basicConsume(QUEUE_ONE ,true,dafaultConsumer );
    }

}

消息接收者2：

public class ConsumerTopiceTwo{
    //队列名称
    private static final String QUEUE_TWO = "queue_two";
    //交换机名称
    private static final String EXCHANGE_TOPICS="exchange_topics";
    //路由key
    private static final String ROUTINGKEY_TWO="inform.#.two.#";

    public static void main(String[] args) throws Exception{
        //获取连接
        Connection connection = ConnectionUtil.getConnection();
        //获取通道
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUE_TWO ,true,false,false,null);
        //声明一个交换机
        channel.exchangeDeclare(EXCHANGE_TOPICS,BuiltinExchanggeType.TOPIC);
        //进行交换机跟队列的绑定
        channel.queueBind(QUEUE_TWO  ,EXCHANGE_TOPICS,ROUTINGKEY_TWO);
        //获取消息
        DefaultConsumer dafaultConsumer = new DefaultConsumer(channel){
             @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //交换机
                String exchange = envelope.getExchange();
                //消息id，mq在channel中用来标识消息的id，可用于确认消息已接收
                long deliveryTag = envelope.getDeliveryTag();
                //消息内容
                String message= new String(body,"utf-8");
                System.out.println("消费者2接收到的信息:"+message);
            }
        
        };
        //监听队列
        channel.basicConsume(QUEUE_TWO ,true,dafaultConsumer );
    }

}