RabbitMQ入门

1.消息中间件概述

MQ全称为Message Queue，消息队列是应用程序和应用程序之间的通信方法。

MQ能为我们带来什么？

在项目中，可将一些无需即时返回且耗时的操作提取出来，进行异步处理，而这种异步处理的方式大大的节省了服务器的请求响应时间，从而提高了系统的吞吐量。

MQ的优势

应用解耦：提高系统容错性和可维护性

MQ相当于一个中介，生产方通过MQ与消费方交互，它将应用程序进行解耦合。MQ作为中间件，MQ其中一端的应用系统调整可以不影响到另外一端

异步提速：提升用户体验和系统吞吐量

将不需要同步处理的并且耗时长的操作由消息队列通知消息接收方进行异步处理。提高了应用程序的响应时间。

削峰填谷：提高系统稳定性

例如减缓数据库压力，将MQ以消息队列堆积起来，系统就可以按照自己的消费能力来消费这样一来，高峰期产生的数据势必会被积压在MQ中，高峰就被“削”掉了。但是因为消息积压，在高峰期过后的一段时间内，消费消息的速度还是会维持原先的值，直到消费完积压的消息,这就叫做“填谷”

MQ的劣势

高可用问题

复杂性问题

一致性问题

MQ是消息通信的模型；实现MQ的大致有两种主流方式：AMQP、JMS。

AMQP（Advanced Message Queue 高级消息队列协议）

AMQP是一种协议，更准确的说是一种binary wire-level protocol（链接协议）。这是其和JMS的本质差别，AMQP不从API层进行限定，而是直接定义网络交换的数据格式。AMQP 是协议，类比HTTP。

JMS

JMS即Java消息服务（JavaMessage Service）应用程序接口，是一个Java平台中关于面向消息中间件（MOM）的API，用于在两个应用程序之间，或分布式系统中发送消息，进行异步通信。JMS 是 API 规范接口，类比 JDBC。

AMQP 与 JMS 区别
*   JMS是定义了统一的接口，来对消息操作进行统一；AMQP是通过规定协议来统一数据交互的格式
    
    
*   JMS限定了必须使用Java语言；AMQP只是协议，不规定实现方式，因此是跨语言的。
    
    
*   JMS规定了两种消息模式；而AMQP的消息模式更加丰富

MQ常见产品

RabibitMQ：基于AMQP协议，erlang语言开发，稳定性好
ActiveMQ：基于JMS
RocketMQ：基于JMS，阿里巴巴产品
Kafka：类似MQ的产品；分布式消息系统，高吞吐量

2.快速入门

创建工程，添加依赖


 com.rabbitmq
 amqp-client
 5.6.0

生产者

public class Producer {
 static final String QUEUE_NAME="simple_queue";
 public static void main(String[] args) throws IOException, TimeoutException {
 //一、创建工厂
 ConnectionFactory connectionFactory = new ConnectionFactory();
 /**
 * 二、设置参数
 * 1.主机地址
 * 2.连接端口
 * 3.虚拟主机名称
 * 4.连接用户名
 * 5.连接密码
 */
 connectionFactory.setHost("localhost");
 connectionFactory.setPort(5672);
 connectionFactory.setVirtualHost("/");
 connectionFactory.setUsername("guest");
 connectionFactory.setPassword("guest");
 //创建连接
 Connection connection = connectionFactory.newConnection();
 //创建频道
 Channel channel = connection.createChannel();
 /**
 * 三、声明（创建）队列
 * 参数1：队列名称
 * 参数2：是否定义持久化队列
 * 参数3：是否独占本次连接
 * 参数4：是否在不使用的时候自动删除队列
 * 参数5：队列其它参数
 */
 channel.queueDeclare(QUEUE_NAME, true, false, false, null);
 String message="Hello! RabbitMQ";

 /**
 * 参数1：交换机名称，如果没有指定则使用默认Default Exchage
 * 参数2：路由key,简单模式可以传递队列名称
 * 参数3：消息其它属性
 * 参数4：消息内容
 */
 channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
 System.out.println("已发送消息：" + message);
 // 关闭资源
 channel.close();
 connection.close();
 }
}

消费者

public class consumer {
 static final String QUEUE_NAME="simple_queue";
 public static void main(String[] args) throws IOException, TimeoutException {
 //创建工厂
 ConnectionFactory connectionFactory = new ConnectionFactory();
 /**
 * 设置参数
 * 1.主机地址
 * 2.连接端口
 * 3.虚拟主机名称
 * 4.连接用户名
 * 5.连接密码
 */
 connectionFactory.setHost("localhost");
 connectionFactory.setPort(5672);
 connectionFactory.setVirtualHost("/");
 connectionFactory.setUsername("guest");
 connectionFactory.setPassword("guest");
 //创建连接
 Connection connection = connectionFactory.newConnection();
 //创建频道
 Channel channel = connection.createChannel();
 /**
 * 声明（创建）队列
 * 参数1：队列名称
 * 参数2：是否定义持久化队列
 * 参数3：是否独占本次连接
 * 参数4：是否在不使用的时候自动删除队列
 * 参数5：队列其它参数
 */
 channel.queueDeclare(QUEUE_NAME, true, false, false, null);
 //创建消费者
 DefaultConsumer consumer=new DefaultConsumer(channel){
 @Override
 public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
 /**
 * consumerTag 消息者标签，在channel.basicConsume时候可以指定
 * envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重传标志(收到消息失败后是否需要重新发送)
 * properties 属性信息
 * body 消息
 */
 //路由key
 System.out.println("路由key为：" + envelope.getRoutingKey());
 //交换机
 System.out.println("交换机为：" + envelope.getExchange());
 //消息id
 System.out.println("消息id为：" + envelope.getDeliveryTag());
 //收到的消息
 System.out.println("接收到的消息为：" + new String(body, "utf-8"));
 }
 };
 //监听消息
 /**
 * 参数1：队列名称
 * 参数2：是否自动确认，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复会删除消息，设置为false则需要手动确认
 * 参数3：消息接收到后回调
 */
 channel.basicConsume(QUEUE_NAME, true, consumer);
 //不关闭资源，应该一直监听消息
 //channel.close();
 //connection.close();

 }

}

上述的快速入门，其实使用的就是工作模式中的简单模式。

image-20200503084405902.png

P:生产者，也就是要发送消息的程序
C：消费者：消息的接受者，会一直等待消息到来。
queue：消息队列，图中红色部分。类似一个邮箱，可以缓存消息；生产者向其中投递消息，消费者从其中取出消息。

3.工作模式

3.1 Work queues工作队列模式

image-20200503085811269.png

应用场景：对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。

生产者

public class Producer_workQueues {
 static final String QUEUE_NAME="work_queue";
 public static void main(String[] args) throws IOException, TimeoutException {
 //创建连接
 ConnectionFactory connectionFactory = new ConnectionFactory();
 connectionFactory.setHost("localhost");
 connectionFactory.setPort(5672);
 connectionFactory.setUsername("guest");
 connectionFactory.setPassword("guest");
 connectionFactory.setVirtualHost("/");
 Connection connection = connectionFactory.newConnection();
 //创建通道
 Channel channel = connection.createChannel();
 channel.queueDeclare(QUEUE_NAME,true,false,false,null);
 for (int i = 0; i <30; i++) {
 String message = i+"Hello,RabbitMQ,workqueue!";
 channel.basicPublish("",QUEUE_NAME,null,message.getBytes());
 System.out.println("已发送消息："+message);
 }
 //关闭资源
 channel.close();
 connection.close();
 }
}

消费者1

public class ConsumerWorkQueues01 {
 static final String QUEUE_NAME="work_queue";
 public static void main(String[] args) throws IOException, TimeoutException {
 //创建连接
 ConnectionFactory connectionFactory = new ConnectionFactory();
 connectionFactory.setHost("localhost");
 connectionFactory.setPort(5672);
 connectionFactory.setVirtualHost("/");
 connectionFactory.setUsername("guest");
 connectionFactory.setPassword("guest");
 Connection connection = connectionFactory.newConnection();
 //创建通道
 final Channel channel = connection.createChannel();
 channel.queueDeclare(QUEUE_NAME,true,false,false,null);
 channel.basicQos(1);
 //创建消费者
 DefaultConsumer consumer=new DefaultConsumer(channel){
 @Override
 public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
 try {
 System.out.println("路由key为：" + envelope.getRoutingKey());
 System.out.println("交换机为：" + envelope.getExchange());
 System.out.println("消息id为：" + envelope.getDeliveryTag());
 System.out.println("消费者1-接收到的消息为：" + new String(body, "utf-8"));
 Thread.sleep(1000);
 channel.basicAck(envelope.getDeliveryTag(), false);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
 };
 channel.basicConsume(QUEUE_NAME, false, consumer);
 }
}

消费者2

public class ConsumerWorkQueues01 {
 static final String QUEUE_NAME="work_queue";
 public static void main(String[] args) throws IOException, TimeoutException {
 //创建连接
 ConnectionFactory connectionFactory = new ConnectionFactory();
 connectionFactory.setHost("localhost");
 connectionFactory.setPort(5672);
 connectionFactory.setVirtualHost("/");
 connectionFactory.setUsername("guest");
 connectionFactory.setPassword("guest");
 Connection connection = connectionFactory.newConnection();
 //创建通道
 final Channel channel = connection.createChannel();
 channel.queueDeclare(QUEUE_NAME,true,false,false,null);
 channel.basicQos(1);
 //创建消费者
 DefaultConsumer consumer=new DefaultConsumer(channel){
 @Override
 public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
 try {
 System.out.println("路由key为：" + envelope.getRoutingKey());
 System.out.println("交换机为：" + envelope.getExchange());
 System.out.println("消息id为：" + envelope.getDeliveryTag());
 System.out.println("消费者1-接收到的消息为：" + new String(body, "utf-8"));
 Thread.sleep(1000);
 channel.basicAck(envelope.getDeliveryTag(), false);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
 };
 channel.basicConsume(QUEUE_NAME, false, consumer);
 }
}

在一个队列中如果有多个消费者，那么消费者之间对于同一个消息的关系是竞争的关系。有点类似负载均衡的意思

3.2发布与订阅模式

image-20200503095606131.png

P：生产者，也就是要发送消息的程序，但是不再发送到队列中，而是发给X（交换机）

C：消费者，消息的接受者，会一直等待消息到来。

Queue：消息队列，接收消息、缓存消息。

Exchange：交换机，图中的X。一方面，接收生产者发送的消息。另一方面，知道如何处理消息，例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作，取决于Exchange的类型。Exchange有常见以下3种类型：
*   Fanout：广播，将消息交给所有绑定到交换机的队列
    
    
*   Direct：定向，把消息交给符合指定routing key 的队列
    
    
*   Topic：通配符，把消息交给符合routing pattern（路由模式） 的队列
Exchange（交换机）只负责转发消息，不具备存储消息的能力，因此如果没有任何队列与Exchange绑定，或者没有符合路由规则的队列，那么消息会丢失！

发布订阅模式：

每个消费者监听自己的队列。
生产者将消息发给broker，由交换机将消息转发到绑定此交换机的每个队列，每个绑定交换机的队列都将接收到消息。

生产者

public class ProducerPublishAndSubscribe {
 //交换机名称
 static final String FANOUT_EXCHAGE = "fanout_exchange";
 //队列名称
 static final String FANOUT_QUEUE_1 = "fanout_queue_1";
 //队列名称
 static final String FANOUT_QUEUE_2 = "fanout_queue_2";
 public static void main(String[] args) throws IOException, TimeoutException {
 //创建连接
 ConnectionFactory connectionFactory = new ConnectionFactory();
 connectionFactory.setHost("localhost");
 connectionFactory.setPort(5672);
 connectionFactory.setUsername("guest");
 connectionFactory.setPassword("guest");
 connectionFactory.setVirtualHost("/");
 Connection connection = connectionFactory.newConnection();
 //创建通道
 Channel channel = connection.createChannel();
 channel.exchangeDeclare(FANOUT_EXCHAGE, BuiltinExchangeType.FANOUT);
 channel.queueDeclare(FANOUT_QUEUE_1,true,false,false,null);
 channel.queueDeclare(FANOUT_QUEUE_2,true,false,false,null);
 channel.queueBind(FANOUT_QUEUE_1,FANOUT_EXCHAGE,"");
 channel.queueBind(FANOUT_QUEUE_2,FANOUT_EXCHAGE,"");
 for (int i = 0; i <10; i++) {
 String message = "Hello RabbitMQ PublishAndSubscribe-->" + i;
 channel.basicPublish(FANOUT_EXCHAGE,"",null,message.getBytes());
 System.out.println("已发送"+message);
 }
 //关闭资源
 channel.close();
 connection.close();
 }
}

消费者1

public class ConsumerPublishAndSubscribe01 {
 //交换机名称
 static final String FANOUT_EXCHAGE = "fanout_exchange";
 //队列名称
 static final String FANOUT_QUEUE_1 = "fanout_queue_1";
 //队列名称
 static final String FANOUT_QUEUE_2 = "fanout_queue_2";
 public static void main(String[] args) throws IOException, TimeoutException {
 //创建连接
 ConnectionFactory connectionFactory = new ConnectionFactory();
 connectionFactory.setHost("localhost");
 connectionFactory.setPort(5672);
 connectionFactory.setUsername("guest");
 connectionFactory.setPassword("guest");
 connectionFactory.setVirtualHost("/");
 Connection connection = connectionFactory.newConnection();
 //创建通道
 Channel channel = connection.createChannel();
 channel.exchangeDeclare(FANOUT_EXCHAGE, BuiltinExchangeType.FANOUT);
 channel.queueDeclare(FANOUT_QUEUE_1,true,false,false,null);
 channel.queueBind(FANOUT_QUEUE_1,FANOUT_EXCHAGE,"");
 //创建消费者
 DefaultConsumer consumer =new DefaultConsumer(channel){
 @Override
 public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
 System.out.println("路由key为：" + envelope.getRoutingKey());
 System.out.println("交换机为：" + envelope.getExchange());
 System.out.println("消息id为：" + envelope.getDeliveryTag());
 System.out.println("消费者1-接收到的消息为：" + new String(body, "utf-8"));
 }
 };
 channel.basicConsume(FANOUT_QUEUE_1,true,consumer);
 }
}

消费者2

public class ConsumerPublishAndSubscribe02 {
    //交换机名称
    static final String FANOUT_EXCHAGE = "fanout_exchange";
    //队列名称
    static final String FANOUT_QUEUE_1 = "fanout_queue_1";
    //队列名称
    static final String FANOUT_QUEUE_2 = "fanout_queue_2";

    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("localhost");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        connectionFactory.setVirtualHost("/");
        Connection connection = connectionFactory.newConnection();
        //创建通道
        Channel channel = connection.createChannel();
        channel.exchangeDeclare(FANOUT_EXCHAGE, BuiltinExchangeType.FANOUT);
        channel.queueDeclare(FANOUT_QUEUE_2,true,false,false,null);
        channel.queueBind(FANOUT_QUEUE_2,FANOUT_EXCHAGE,"");
        //创建消费者
        DefaultConsumer consumer =new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("路由key为：" + envelope.getRoutingKey());
                System.out.println("交换机为：" + envelope.getExchange());
                System.out.println("消息id为：" + envelope.getDeliveryTag());
                System.out.println("消费者2-接收到的消息为：" + new String(body, "utf-8"));
            }
        };
        channel.basicConsume(FANOUT_QUEUE_2,true,consumer);
    }
}

启动所有消费者，然后使用生产者发送消息；在每个消费者对应的控制台可以查看到生产者发送的所有消息；实现广播的效果。

发布订阅模式与工作队列模式的区别

工作队列模式不用定义交换机，而发布/订阅模式需要定义交换机。
发布/订阅模式的生产方是面向交换机发送消息，工作队列模式的生产方是面向队列发送消息(底层使用默认交换机)
发布/订阅模式需要设置队列和交换机的绑定，工作队列模式不需要设置，实际上工作队列模式会将队列绑定到默认的交换机。

3.3 Routing路由模式

image-20200503103706011.png

P：生产者，向Exchange发送消息，发送消息时，会指定一个routing key。

X：Exchange（交换机），接收生产者的消息，然后把消息递交给与routing key完全匹配的队列

C1：消费者，其所在队列指定了需要routing key 为 error 的消息

C2：消费者，其所在队列指定了需要routing key 为 info、error、warning 的消息

路由模式交换机的类型为：Direct，还有队列绑定交换机的时候需要指定routing key。

生产者

public class ProducerRouting {
    //交换机名称
    static final String DIRECT_EXCHAGE = "direct_exchange";
    //队列名称
    static final String DIRECT_QUEUE_INSERT = "direct_queue_insert";
    //队列名称
    static final String DIRECT_QUEUE_UPDATE = "direct_queue_update";
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("localhost");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        connectionFactory.setVirtualHost("/");
        Connection connection = connectionFactory.newConnection();
        //创建通道
        Channel channel = connection.createChannel();
        channel.exchangeDeclare(DIRECT_EXCHAGE, BuiltinExchangeType.DIRECT);
        channel.queueDeclare(DIRECT_QUEUE_INSERT, true, false, false, null);
        channel.queueDeclare(DIRECT_QUEUE_UPDATE, true, false, false, null);
        channel.queueBind(DIRECT_QUEUE_UPDATE,DIRECT_EXCHAGE,"update");
        channel.queueBind(DIRECT_QUEUE_INSERT,DIRECT_EXCHAGE,"insert");
        String message = "新增了商品。路由模式；routing key 为 insert!";
        channel.basicPublish(DIRECT_EXCHAGE,"insert",null,message.getBytes());
        System.out.println("已发送消息："+message);
        message="修改了商品。路由模式；routing key 为 update";
        channel.basicPublish(DIRECT_EXCHAGE,"update",null,message.getBytes());
        System.out.println("已发送消息："+message);
        //关闭资源
        channel.close();
        connection.close();
    }
}

消费者1

public class ConsumerRouting01 {
    //交换机名称
    static final String DIRECT_EXCHAGE = "direct_exchange";
    //队列名称
    static final String DIRECT_QUEUE_INSERT = "direct_queue_insert";
    //队列名称
    static final String DIRECT_QUEUE_UPDATE = "direct_queue_update";
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("localhost");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        connectionFactory.setVirtualHost("/");
        Connection connection = connectionFactory.newConnection();
        //创建通道
        Channel channel = connection.createChannel();
        channel.exchangeDeclare(DIRECT_EXCHAGE, BuiltinExchangeType.DIRECT);
        channel.queueDeclare(DIRECT_QUEUE_INSERT,true,false,false,null);
        channel.queueBind(DIRECT_QUEUE_INSERT,DIRECT_EXCHAGE,"insert");
        //创建消费者
        DefaultConsumer consumer =new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("路由key为：" + envelope.getRoutingKey());
                System.out.println("交换机为：" + envelope.getExchange());
                System.out.println("消息id为：" + envelope.getDeliveryTag());
                System.out.println("消费者1-接收到的消息为：" + new String(body, "utf-8"));
            }
        };
        channel.basicConsume(DIRECT_QUEUE_INSERT,true,consumer);
    }
}

消费者2

public class ConsumerRouting02 {
    //交换机名称
    static final String DIRECT_EXCHAGE = "direct_exchange";
    //队列名称
    static final String DIRECT_QUEUE_INSERT = "direct_queue_insert";
    //队列名称
    static final String DIRECT_QUEUE_UPDATE = "direct_queue_update";
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("localhost");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        connectionFactory.setVirtualHost("/");
        Connection connection = connectionFactory.newConnection();
        //创建通道
        Channel channel = connection.createChannel();
        channel.exchangeDeclare(DIRECT_EXCHAGE, BuiltinExchangeType.DIRECT);
        channel.queueDeclare(DIRECT_QUEUE_UPDATE,true,false,false,null);
        channel.queueBind(DIRECT_QUEUE_UPDATE,DIRECT_EXCHAGE,"update");
        //创建消费者
        DefaultConsumer consumer =new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("路由key为：" + envelope.getRoutingKey());
                System.out.println("交换机为：" + envelope.getExchange());
                System.out.println("消息id为：" + envelope.getDeliveryTag());
                System.out.println("消费者1-接收到的消息为：" + new String(body, "utf-8"));
            }
        };
        channel.basicConsume(DIRECT_QUEUE_UPDATE,true,consumer);
    }
}

路由模式特点：

队列与交换机的绑定，不能是任意绑定了，而是要指定一个RoutingKey（路由key）

消息的发送方在向 Exchange发送消息时，也必须指定消息的 RoutingKey。

Exchange不再把消息交给每一个绑定的队列，而是根据消息的Routing Key进行判断，只有队列的Routingkey与消息的 Routing key完全一致，才会接收到消息

3.4Topics通配符模式

Topic类型与Direct相比，都是可以根据Routing key把消息路由到不同的队列。只不过Topic类型Exchange可以让队列在绑定Routing key的时候使用通配符！

Routingkey 一般都是有一个或多个单词组成，多个单词之间以”.”分割，例如： item.insert

通配符规则：

#：匹配一个或多个词

*：匹配不多不少恰好1个词

举例：

item.#：能够匹配item.insert.abc 或者 item.insert

item.*：只能匹配item.insert

image-20200503110814306.png

消费者

public class ProducerTopics {
    //交换机名称
    static final String TOPIC_EXCHAGE = "topic_exchange";
    //队列名称
    static final String TOPIC_QUEUE_1 = "topic_queue_1";
    //队列名称
    static final String TOPIC_QUEUE_2 = "topic_queue_2";
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("localhost");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        connectionFactory.setVirtualHost("/");
        Connection connection = connectionFactory.newConnection();
        //创建通道
        Channel channel = connection.createChannel();
        channel.exchangeDeclare(TOPIC_EXCHAGE, BuiltinExchangeType.TOPIC);
        channel.queueDeclare(TOPIC_QUEUE_1, true, false, false, null);
        channel.queueDeclare(TOPIC_QUEUE_2, true, false, false, null);
        channel.queueBind(TOPIC_QUEUE_1,TOPIC_EXCHAGE,"*.update");
        channel.queueBind(TOPIC_QUEUE_2,TOPIC_EXCHAGE,"*.insert");
        channel.queueBind(TOPIC_QUEUE_1,TOPIC_EXCHAGE,"*.delete");
        channel.queueBind(TOPIC_QUEUE_2,TOPIC_EXCHAGE,"*.update");
        channel.queueBind(TOPIC_QUEUE_2,TOPIC_EXCHAGE,"*.delete");
        //发送消息
        String message="新增了商品。Topic模式；routing key 为 item.insert ";
        channel.basicPublish(TOPIC_EXCHAGE, "item.insert", null, message.getBytes());
        System.out.println("已发送消息：" + message);
        message = "修改了商品。Topic模式；routing key 为 item.update" ;
        channel.basicPublish(TOPIC_EXCHAGE, "item.update", null, message.getBytes());
        System.out.println("已发送消息：" + message);
        message = "删除了商品。Topic模式；routing key 为 item.delete" ;
        channel.basicPublish(TOPIC_EXCHAGE, "item.delete", null, message.getBytes());
        System.out.println("已发送消息：" + message);
        //关闭资源
        channel.close();
        connection.close();
    }
}<

消费者1

public class ConsumerTopics01 {
    //交换机名称
    static final String TOPIC_EXCHAGE = "topic_exchange";
    //队列名称
    static final String TOPIC_QUEUE_1 = "topic_queue_1";
    //队列名称
    static final String TOPIC_QUEUE_2 = "topic_queue_2";

    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("localhost");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        connectionFactory.setVirtualHost("/");
        Connection connection = connectionFactory.newConnection();
        //创建通道
        Channel channel = connection.createChannel();
        channel.exchangeDeclare(TOPIC_EXCHAGE, BuiltinExchangeType.TOPIC);
        channel.queueDeclare(TOPIC_QUEUE_1, true, false, false, null);
        channel.queueBind(TOPIC_QUEUE_1, TOPIC_EXCHAGE, "item.update");
        channel.queueBind(TOPIC_QUEUE_1, TOPIC_EXCHAGE, "item.delete");
        //创建消费者
        DefaultConsumer consumer =new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("路由key为：" + envelope.getRoutingKey());
                System.out.println("交换机为：" + envelope.getExchange());
                System.out.println("消息id为：" + envelope.getDeliveryTag());
                System.out.println("消费者1-接收到的消息为：" + new String(body, "utf-8"));
            }
        };
        channel.basicConsume(TOPIC_QUEUE_1,true,consumer);
    }
}

消费者2

public class ConsumerTopics02 {
    //交换机名称
    static final String TOPIC_EXCHAGE = "topic_exchange";
    //队列名称
    static final String TOPIC_QUEUE_1 = "topic_queue_1";
    //队列名称
    static final String TOPIC_QUEUE_2 = "topic_queue_2";
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("localhost");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        connectionFactory.setVirtualHost("/");
        Connection connection = connectionFactory.newConnection();
        //创建通道
        Channel channel = connection.createChannel();
        channel.exchangeDeclare(TOPIC_EXCHAGE, BuiltinExchangeType.TOPIC);
        channel.queueDeclare(TOPIC_QUEUE_2, true, false, false, null);
        channel.queueBind(TOPIC_QUEUE_2, TOPIC_EXCHAGE, "item.*");
        //创建消费者
        DefaultConsumer consumer =new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("路由key为：" + envelope.getRoutingKey());
                System.out.println("交换机为：" + envelope.getExchange());
                System.out.println("消息id为：" + envelope.getDeliveryTag());
                System.out.println("消费者1-接收到的消息为：" + new String(body, "utf-8"));
            }
        };
        channel.basicConsume(TOPIC_QUEUE_2,true,consumer);
    }
}

总结

RabbitMQ工作模式： 1. 简单模式 一个生产者、一个消费者，不需要设置交换机（使用默认的交换机）

2. 工作队列模式 Work Queue 一个生产者、多个消费者（竞争关系），不需要设置交换机（使用默认的交换机）

3. 发布订阅模式 Publish/subscribe 需要设置类型为fanout的交换机，并且交换机和队列进行绑定，当发送消息到交换机后，交换机会将消息发送到绑定的队列

4. 路由模式 Routing 需要设置类型为direct的交换机，交换机和队列进行绑定，并且指定routing key，当发送消息到交换机后，交换机会根据routing key将消息发送到对应的队列

5. 通配符模式 Topic 需要设置类型为topic的交换机，交换机和队列进行绑定，并且指定通配符方式的routing key，当发送消息到交换机后，交换机会根据routing key将消息发送到对应的队列

4.框架整合RabbitMQ

4.1 Spring整合RabbitMQ

4.1.1 搭建生产者工程

创建工程，添加依赖



    4.0.0
    com.itheima
    spring-rabbitmq-producer
    1.0-SNAPSHOT
    
        
            org.springframework
            spring-context
            5.1.7.RELEASE
        
        
            org.springframework.amqp
            spring-rabbit
            2.1.8.RELEASE
        
        
            junit
            junit
            4.12
        
        
            org.springframework
            spring-test
            5.1.7.RELEASE

编写配置文件

rabbitmq.properties连接参数配置文件

rabbitmq.host=localhost
rabbitmq.port=5672
rabbitmq.username=guest
rabbitmq.password=guest
rabbitmq.virtual=/

spring-rabbitmq.xml配置文件

创建测试文件

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring-rabbitmq.xml")
public class ProducerTest {
    @Autowired
    private RabbitTemplate rabbitTemplate;
    /**
     *交换机类型为 direct
     *交换机的名称为空，路由键为队列的名称
     */
    @Test
    public void test1() {
        rabbitTemplate.convertAndSend("spring_queue","只发队列spring_queue的消息。");
    }
    /**
     *交换机类型为 fanout
     *绑定到该交换机的所有队列都能够收到消息
     */
    @Test
    public void test2() {
        rabbitTemplate.convertAndSend("spring_fanout_exchange","","发送到spring_fanout_exchange交换机的广播消息");
    }
    /**
     *交换机类型为 topic
     */
    @Test
    public void test3() {
        rabbitTemplate.convertAndSend("spring_topic_exchange", "heima.bj", "发送到spring_topic_exchange交换机heima.bj的消息");
        rabbitTemplate.convertAndSend("spring_topic_exchange", "heima.bj.1", "发送到spring_topic_exchange交换机heima.bj.1的消息");
        rabbitTemplate.convertAndSend("spring_topic_exchange", "heima.bj.2", "发送到spring_topic_exchange交换机heima.bj.2的消息");
        rabbitTemplate.convertAndSend("spring_topic_exchange", "itcast.cn", "发送到spring_topic_exchange交换机itcast.cn的消息");
    }
}

4.1.2 搭建消费者工程

创建工程，添加依赖



    4.0.0
    com.itheima
    springrabbitmqcomsumer
    1.0-SNAPSHOT
    
        
            org.springframework
            spring-context
            5.1.7.RELEASE
        
        
            org.springframework.amqp
            spring-rabbit
            2.1.8.RELEASE

编写配置文件

rabbitmq.properties连接参数配置文件

rabbitmq.host=localhost
rabbitmq.port=5672
rabbitmq.username=guest
rabbitmq.password=guest
rabbitmq.virtual=/

spring-rabbitmq.xml配置文件

编写监听器

队列监听器

public class SpringQueueListener implements MessageListener {
    public void onMessage(Message message) {
        try {
            String msg = new String(message.getBody(), "utf-8");
            System.out.println("接收路由名称为："+message.getMessageProperties().getReceivedExchange()+"，" +
                    "路由键为："+ message.getMessageProperties().getReceivedRoutingKey()+"，队列名为：" +
                    message.getMessageProperties().getConsumerQueue()+"的消息："+msg);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }
}

广播监听器1

public class FanoutListener1 implements MessageListener {
    public void onMessage(Message message) {
        try {
            String msg = new String(message.getBody(), "utf-8");
            System.out.println("广播监听器1:接收路由名称为："+message.getMessageProperties().getReceivedExchange()+"，" +
                    "路由键为："+ message.getMessageProperties().getReceivedRoutingKey()+"，队列名为：" +
                    message.getMessageProperties().getConsumerQueue()+"的消息："+msg);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }
}

广播监听器2

public class FanoutListener2 implements MessageListener {
    public void onMessage(Message message) {
        try {
            String msg = new String(message.getBody(), "utf-8");
            System.out.println("广播监听器2:接收路由名称为："+message.getMessageProperties().getReceivedExchange()+"，" +
                    "路由键为："+ message.getMessageProperties().getReceivedRoutingKey()+"，队列名为：" +
                    message.getMessageProperties().getConsumerQueue()+"的消息："+msg);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }
}

星号通配符监听器

public class TopicListenerStar implements MessageListener {
    public void onMessage(Message message) {
        try {
            String msg = new String(message.getBody(), "utf-8");
            System.out.println("通配符*监听器:接收路由名称为："+message.getMessageProperties().getReceivedExchange()+"，" +
                    "路由键为："+ message.getMessageProperties().getReceivedRoutingKey()+"，队列名为：" +
                    message.getMessageProperties().getConsumerQueue()+"的消息："+msg);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }
}

井号号通配符监听器

public class TopicListenerWell implements MessageListener {
    public void onMessage(Message message) {
        try {
            String msg = new String(message.getBody(), "utf-8");
            System.out.println("通配符#监听器:接收路由名称为："+message.getMessageProperties().getReceivedExchange()+"，" +
                    "路由键为："+ message.getMessageProperties().getReceivedRoutingKey()+"，队列名为：" +
                    message.getMessageProperties().getConsumerQueue()+"的消息："+msg);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }
}

井号号通配符监听器2

public class TopicListenerWell2 implements MessageListener {
    public void onMessage(Message message) {
        try {
            String msg = new String(message.getBody(), "utf-8");
            System.out.println("通配符#监听器2:接收路由名称为："+message.getMessageProperties().getReceivedExchange()+"，" +
                    "路由键为："+ message.getMessageProperties().getReceivedRoutingKey()+"，队列名为：" +
                    message.getMessageProperties().getConsumerQueue()+"的消息："+msg);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }
}

编写测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring-rabbitmq.xml")
public class ConsumerTest {
    @Test
    public void test1() {
       while (true){

       }
    }
}

4.2 SpringBoot整合RabbitMQ

4.2.1 搭建生产者工程

创建工程添加依赖



    4.0.0
    
        org.springframework.boot
        spring-boot-starter-parent
        2.2.6.RELEASE
         
    
    com.itheima
    springboot-rabbitmq-producer
    0.0.1-SNAPSHOT
    springboot-rabbitmq-producer
    Demo project for Spring Boot
    
        1.8
    
    
        
            org.springframework.boot
            spring-boot-starter
        
        
            org.springframework.boot
            spring-boot-starter-amqp
        
        
            org.springframework.boot
            spring-boot-starter-test
            test
            
                
                    org.junit.vintage
                    junit-vintage-engine
                
            
        
    
    
        
            
                org.springframework.boot
                spring-boot-maven-plugin

编写配置文件

spring:
  rabbitmq:
    host: localhost
    port: 5672
    virtual-host: /
    username: guest
    password: guest

编写配置类

@Configuration
public class RabbitMQConfig {
    //交换机名称
    public static final String ITEM_TOPIC_EXCHANGE = "item_topic_exchange";
    //队列名称
    public static final String ITEM_QUEUE = "item_queue";
    @Bean("itemTopicExchange")
    public Exchange topicExchange(){
        return ExchangeBuilder.topicExchange(ITEM_TOPIC_EXCHANGE).durable(true).build();
    }
    @Bean("itemQueue")
    public Queue itemQueue(){
        return QueueBuilder.durable(ITEM_QUEUE).build();
    }
    @Bean
    public Binding itemBind(@Qualifier("itemQueue")Queue queue,
                            @Qualifier("itemTopicExchange") Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with("item.#").noargs();
    }
}

编写测试类

@SpringBootTest
@RunWith(SpringRunner.class)
public class SpringbootRabbitmqProducerApplicationTests {
    @Autowired
    private RabbitTemplate rabbitTemplate;
    @Test
    public void test1() {
       rabbitTemplate.convertAndSend(RabbitMQConfig.ITEM_TOPIC_EXCHANGE,"boot.bi.z","boot mq hello..");
    }

}

4.2.1 搭建消费者工程

创建工程添加依赖



    4.0.0
    
        org.springframework.boot
        spring-boot-starter-parent
        2.2.6.RELEASE
         
    
    com.itheima
    springboot-rabbitmq-consumer
    0.0.1-SNAPSHOT
    springboot-rabbitmq-consumer
    Demo project for Spring Boot

    
        1.8
    

    
        
            org.springframework.boot
            spring-boot-starter
        

        
            org.springframework.boot
            spring-boot-starter-amqp
        
        
            org.springframework.boot
            spring-boot-starter-test
            test
            
                
                    org.junit.vintage
                    junit-vintage-engine
                
            
        
    

    
        
            
                org.springframework.boot
                spring-boot-maven-plugin

编写配置文件

spring:
  rabbitmq:
    host: localhost
    port: 5672
    virtual-host: /
    username: guest
    password: guest

配置监听器

@Component
public class ConsumerListener {
    @RabbitListener(queues = "item_queue")
    public void listener1(String message){
        System.out.println("消费者接收到的消息为：" + message);
    }

}