首页 > 软件编程 > Java > 原生Java操作兔子队列RabbitMQ

原生Java操作兔子队列RabbitMQ

福牛 5月 23, 2023 14 0

一.前言

RabbitMQ 是一种快速、灵活、可靠的消息传递方式，可用于构建分布式应用程序、异步处理任务、实现消息队列等。下面是 Java 原生操作 RabbitMQ 的一些好处和用途：

  1. 简单易用：RabbitMQ 提供了丰富的 Java 客户端库，开发者可以轻松地使用 Java 代码进行消息发送和接收，无需学习复杂的消息传递协议和 API。
  2. 可扩展性强：RabbitMQ 支持集群和分布式部署，可以轻松地实现横向和纵向扩展，以适应不同规模和负载的应用需求。
  3. 可靠性高：RabbitMQ 提供了多种消息传递模式，包括持久化消息、确认机制、事务机制等，确保消息传递的可靠性和一致性。
  4. 异步处理能力：RabbitMQ 可以异步处理任务，提高应用程序的响应速度和吞吐量，实现任务削峰、应对高并发等需求。
  5. 可用于多种场景：RabbitMQ 可以用于构建分布式应用程序、实现消息队列、异步处理任务、实现实时数据同步等场景，具有广泛的应用场景和发展前景。

二.原生Java操作RabbitMQ

Ⅰ. 简单模式

1. 添加依赖

  1.      <!–rabbitmq依赖–>
  2.      <dependency>
  3.          <groupId>com.rabbitmq</groupId>
  4.          <artifactId>amqp-client</artifactId>
  5.          <version>5.14.0</version>
  6.      </dependency>

2. 编写生产者

  1. import com.rabbitmq.client.Channel;
  2. import com.rabbitmq.client.Connection;
  3. import com.rabbitmq.client.ConnectionFactory;
  4. import java.io.IOException;
  5. import java.util.concurrent.TimeoutException;
  6. //生产者
  7. public class Producer {
  8.      public static void main(String[] args) throws IOException, TimeoutException {
  9. // 1.创建连接工厂
  10.          ConnectionFactory connectionFactory = new ConnectionFactory();
  11.          connectionFactory.setHost(“120.79.50.65”);
  12.          connectionFactory.setPort(5672);
  13.          connectionFactory.setUsername(“lion”);
  14.          connectionFactory.setPassword(“lion”);
  15.          connectionFactory.setVirtualHost(“/”);
  16. // 2.创建连接
  17.          Connection connection = connectionFactory.newConnection();
  18. // 3.建立信道
  19.          Channel channel = connection.createChannel();
  20. // 4.创建队列，若队列已存在则使用该队列
  21.          /**
  22.              * 参数1：队列名
  23.              * 参数2：是否持久化，true表示MQ重启后队列还存在
  24.              * 参数3：是否私有化，false表示所有消费者都可以访问，true表示只有第一次访问她的消费者才能访问
  25.              * 参数4：是否自动删除，true表示不再使用队列时，自动删除
  26.              * 参数5：其他额外参数
  27.              */
  28.          channel.queueDeclare(“simple_queue”,false,false,false,null);
  29. // 5.发送消息
  30.          String message = “hello rabbitmq”;
  31.          /**
  32.              * 参数1：交换机名，””表示默认交换机
  33.              * 参数2：路由键，简单模式就是队列名
  34.              * 参数3：其他额外参数
  35.              * 参数4：要传递的消息字节数组
  36.              */
  37.          channel.basicPublish(“”,“simple_queue”,null,message.getBytes());
  38. // 6.关闭信道和连接
  39.          channel.close();
  40.          connection.close();
  41.          System.out.println(“=====发送成功====”);
  42.      }
  43. }

-1

3. 编写消费者

因为消费者不知道生产者什么时候发送消息过来，所以消费者需要一直监听生产者

  1. import com.rabbitmq.client.*;
  2. import java.io.IOException;
  3. import java.util.concurrent.TimeoutException;
  4. /**
  5.      * 消费者
  6.      */
  7. public class Consumer {
  8.      public static void main(String[] args) throws IOException, TimeoutException {
  9. // 1.创建连接工厂
  10.          ConnectionFactory connectionFactory = new ConnectionFactory();
  11.          connectionFactory.setHost(“120.79.50.65”);
  12.          connectionFactory.setPort(5672);
  13.          connectionFactory.setUsername(“lion”);
  14.          connectionFactory.setPassword(“lion”);
  15.          connectionFactory.setVirtualHost(“/”);
  16. // 2.创建连接
  17.          Connection connection = connectionFactory.newConnection();
  18. // 3.创建信道
  19.          Channel channel = connection.createChannel();
  20. // 4.监听队列
  21.          /**
  22.              * 参数1：监听的队列名
  23.              * 参数2：是否自动签收，如果为false，则需要手动确认消息已收到，否则MQ会一直发送消息。
  24.              * 参数3：Consumer的实现类，重写该类方法表示接收到这个消息之后该如何消费消息
  25.              */
  26.          channel.basicConsume(“simple_queue”,true,new DefaultConsumer(channel){
  27.              @Override
  28.              public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
  29.                  String message = new String(body, “UTF-8”);
  30.                  System.out.println(“接收消息，消息为：”+message);
  31.              }
  32.          });
  33.      }
  34. }

-2

Ⅱ. 工作队列模式

-3

与简单模式相比，工作队列模式(Work Queue)多了一些消费者，该模式也使用direct交换机，应用于处理消息较多的情况。特点如下：

  • 一个队列对应多个消费者。
  • 一条消息只会被一个消费者消费。
  • 消息队列默认采用轮询的方式将消息平均发送给消费者。

其实就是 简单模式plus版本。

1. 编写生产者

  1. import com.rabbitmq.client.Channel;
  2. import com.rabbitmq.client.Connection;
  3. import com.rabbitmq.client.ConnectionFactory;
  4. import com.rabbitmq.client.MessageProperties;
  5. import java.io.IOException;
  6. import java.nio.charset.StandardCharsets;
  7. import java.util.concurrent.TimeoutException;
  8. public class Producer {
  9.      public static void main(String[] args) throws IOException, TimeoutException {
  10. // 1.创建连接工厂
  11.          ConnectionFactory connectionFactory = new ConnectionFactory();
  12.          connectionFactory.setHost(“120.79.50.65”);
  13.          connectionFactory.setPort(5672);
  14.          connectionFactory.setUsername(“lion”);
  15.          connectionFactory.setPassword(“lion”);
  16.          connectionFactory.setVirtualHost(“/”);
  17. // 2.创建连接
  18.          Connection connection = connectionFactory.newConnection();
  19. // 3.创建信道
  20.          Channel channel = connection.createChannel();
  21. // 4.创建队列,持久化队列
  22.          channel.queueDeclare(“work_queue”,true,false,false,null);
  23. // 5.发送大量消息,参数3表示该消息为持久化消息，即除了保存到内存还保存到磁盘
  24.          for (int i = 0; i < 100; i++) {
  25.              channel.basicPublish(“”,“work_queue”, MessageProperties.PERSISTENT_TEXT_PLAIN,
  26.                      (“您好，这是今天的第”+i+“条消息”).getBytes(StandardCharsets.UTF_8));
  27.          }
  28. // 6.关闭资源
  29.          channel.close();
  30.          connection.close();
  31.      }
  32. }

-4

2. 编写消费者

这里使用创建了三个消费者，来接收生产者的消息

  1. import com.rabbitmq.client.*;
  2. import java.io.IOException;
  3. import java.util.concurrent.TimeoutException;
  4. public class Consumer {
  5.      public static void main(String[] args) throws IOException, TimeoutException {
  6.          // 1.创建连接工厂
  7.          ConnectionFactory connectionFactory = new ConnectionFactory();
  8.          connectionFactory.setHost(“120.79.50.65”);
  9.          connectionFactory.setPort(5672);
  10.          connectionFactory.setUsername(“lion”);
  11.          connectionFactory.setPassword(“lion”);
  12.          connectionFactory.setVirtualHost(“/”);
  13. // 2.创建连接
  14.          Connection connection = connectionFactory.newConnection();
  15. // 3.创建信道
  16.          Channel channel = connection.createChannel();
  17. // 监听队列，处理消息
  18.          channel.basicConsume(“work_queue”,true,new DefaultConsumer(channel){
  19.              @Override
  20.              public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
  21.                  String message = new String(body, “UTF-8”);
  22.                  System.out.println(“消费者1消费消息，消息为：”+message);
  23.              }
  24.          });
  25.      }
  26. }

3. 实现

先把三个消费者运行起来，再运行生产者，得到的消息就会轮询均分

-5

Ⅲ. 发布订阅模式

在开发过程中，有一些消息需要不同消费者进行不同的处理，如电商网站的同一条促销信息需要短信发送、邮件发送、站内信发送等。此时可以使用发布订阅模式(Publish/Subscribe)

特点：

  • 生产者将消息发送给交换机，交换机将消息转发到绑定此交换机的每个队列中。
  • 工作队列模式的交换机只能将消息发送给一个队列，发布订阅模式的交换机能将消息发送给多个队列。发布订阅模式使用fanout交换机。

1. 编写生产者

这里创建了三条队列，一条是发送短信，一条是站内信，一条是邮件队列、

  1. import com.rabbitmq.client.BuiltinExchangeType;
  2. import com.rabbitmq.client.Channel;
  3. import com.rabbitmq.client.Connection;
  4. import com.rabbitmq.client.ConnectionFactory;
  5. import javax.swing.plaf.TreeUI;
  6. import java.io.IOException;
  7. import java.nio.charset.StandardCharsets;
  8. import java.util.concurrent.TimeoutException;
  9. /**
  10.      * 发布订阅者模式跟简单和工作模式不一样，不是使用默认的交换机，而是自己创建fanout交换机，生产者把消息发到交换机，由交换机转发到与之绑定的队列
  11.      */
  12. public class Producer {
  13.      public static void main(String[] args) throws IOException, TimeoutException {
  14.          // 1.创建连接工厂
  15.          ConnectionFactory connectionFactory = new ConnectionFactory();
  16.          connectionFactory.setHost(“120.79.50.65”);
  17.          connectionFactory.setPort(5672);
  18.          connectionFactory.setUsername(“lion”);
  19.          connectionFactory.setPassword(“lion”);
  20.          connectionFactory.setVirtualHost(“/”);
  21. // 2.创建连接
  22.          Connection connection = connectionFactory.newConnection();
  23. // 3.建立信道
  24.          Channel channel = connection.createChannel();
  25. // 4.创建交换机
  26.          /**
  27.              * 参数1：交换机名
  28.              * 参数2：交换机类型
  29.              * 参数3：交换机是否持久化
  30.              */
  31.          channel.exchangeDeclare(“exchange_fanout”, BuiltinExchangeType.FANOUT,true);
  32. // 5.创建队列
  33.          channel.queueDeclare(“SEND_MAIL”,true,false,false,null);
  34.          channel.queueDeclare(“SEND_MESSAGE”,true,false,false,null);
  35.          channel.queueDeclare(“SEND_STATION”,true,false,false,null);
  36. // 6.交换机绑定队列
  37.          /**
  38.              * 参数1：队列名
  39.              * 参数2：交换机名
  40.              * 参数3：路由关键字，发布订阅模式只需要写””即可
  41.              */
  42.          channel.queueBind(“SEND_MAIL”,“exchange_fanout”,“”);
  43.          channel.queueBind(“SEND_MESSAGE”,“exchange_fanout”,“”);
  44.          channel.queueBind(“SEND_STATION”,“exchange_fanout”,“”);
  45. // 7.发送消息
  46.          for (int i = 0; i < 10; i++) {
  47.              channel.basicPublish(“exchange_fanout”,“”,null,
  48.                      (“您好，尊敬的用户，秒杀商品活动开始啦：”+i).getBytes(StandardCharsets.UTF_8));
  49.          }
  50. // 8.关闭资源
  51.          channel.close();
  52.          connection.close();
  53.      }
  54. }

2. 编写消费者

  1. import com.rabbitmq.client.*;
  2. import java.io.IOException;
  3. import java.util.concurrent.TimeoutException;
  4. //短信消费者
  5. public class ConsumerMessage {
  6.      public static void main(String[] args) throws IOException, TimeoutException {
  7.          // 1.创建连接工厂
  8.          ConnectionFactory connectionFactory = new ConnectionFactory();
  9.          connectionFactory.setHost(“120.79.50.65”);
  10.          connectionFactory.setPort(5672);
  11.          connectionFactory.setUsername(“lion”);
  12.          connectionFactory.setPassword(“lion”);
  13.          connectionFactory.setVirtualHost(“/”);
  14. // 2.创建连接
  15.          Connection connection = connectionFactory.newConnection();
  16. // 3.创建信道
  17.          Channel channel = connection.createChannel();
  18. // 4.监听队列
  19.          /**
  20.              * 参数1：监听的队列名
  21.              * 参数2：是否自动签收，如果为false，则需要手动确认消息已收到，否则MQ会一直发送消息。
  22.              * 参数3：Consumer的实现类，重写该类方法表示接收到这个消息之后该如何消费消息
  23.              */
  24.          channel.basicConsume(“SEND_MESSAGE”,true,new DefaultConsumer(channel){
  25.              @Override
  26.              public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
  27.                  String message = new String(body, “UTF-8”);
  28.                  System.out.println(“发送短信，消息为：”+message);
  29.              }
  30.          });
  31.      }
  32. }
  1. import com.rabbitmq.client.*;
  2. import java.io.IOException;
  3. import java.util.concurrent.TimeoutException;
  4. //邮件消费者
  5. public class ConsumerMail {
  6.      public static void main(String[] args) throws IOException, TimeoutException {
  7.          // 1.创建连接工厂
  8.          ConnectionFactory connectionFactory = new ConnectionFactory();
  9.          connectionFactory.setHost(“120.79.50.65”);
  10.          connectionFactory.setPort(5672);
  11.          connectionFactory.setUsername(“lion”);
  12.          connectionFactory.setPassword(“lion”);
  13.          connectionFactory.setVirtualHost(“/”);
  14. // 2.创建连接
  15.          Connection connection = connectionFactory.newConnection();
  16. // 3.创建信道
  17.          Channel channel = connection.createChannel();
  18. // 4.监听队列
  19.          /**
  20.              * 参数1：监听的队列名
  21.              * 参数2：是否自动签收，如果为false，则需要手动确认消息已收到，否则MQ会一直发送消息。
  22.              * 参数3：Consumer的实现类，重写该类方法表示接收到这个消息之后该如何消费消息
  23.              */
  24.          channel.basicConsume(“SEND_MAIL”,true,new DefaultConsumer(channel){
  25.              @Override
  26.              public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
  27.                  String message = new String(body, “UTF-8”);
  28.                  System.out.println(“发送邮件，消息为：”+message);
  29.              }
  30.          });
  31.      }
  32. }
  1. import com.rabbitmq.client.*;
  2. import java.io.IOException;
  3. import java.util.concurrent.TimeoutException;
  4. //站内信消费者
  5. public class ConsumerStation {
  6.      public static void main(String[] args) throws IOException, TimeoutException {
  7.          // 1.创建连接工厂
  8.          ConnectionFactory connectionFactory = new ConnectionFactory();
  9.          connectionFactory.setHost(“120.79.50.65”);
  10.          connectionFactory.setPort(5672);
  11.          connectionFactory.setUsername(“lion”);
  12.          connectionFactory.setPassword(“lion”);
  13.          connectionFactory.setVirtualHost(“/”);
  14. // 2.创建连接
  15.          Connection connection = connectionFactory.newConnection();
  16. // 3.创建信道
  17.          Channel channel = connection.createChannel();
  18. // 4.监听队列
  19.          /**
  20.              * 参数1：监听的队列名
  21.              * 参数2：是否自动签收，如果为false，则需要手动确认消息已收到，否则MQ会一直发送消息。
  22.              * 参数3：Consumer的实现类，重写该类方法表示接收到这个消息之后该如何消费消息
  23.              */
  24.          channel.basicConsume(“SEND_STATION”,true,new DefaultConsumer(channel){
  25.              @Override
  26.              public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
  27.                  String message = new String(body, “UTF-8”);
  28.                  System.out.println(“发送站内信，消息为：”+message);
  29.              }
  30.          });
  31.      }
  32. }

发布订阅模式也允许多个消费者监听同一个队列（工作模式），例如 两个发送短信消费者监听同一个短信生产者，这样短信生产者的消息将会被轮询平分。

Ⅳ. 路由模式

-6

使用发布订阅模式时，所有消息都会发送到绑定的队列中，但很多时候，不是所有消息都无差别的发布到所有队列中。比如电商网站

的促销活动，双十一大促可能会发布到所有队列；而一些小的促销活动为了节约成本，只发布到站内信队列。此时需要使用路由模式

(Routing)完成这一需求。意思就是只发给与绑定相同路由关键字的队列。

特点：

  1. 每个队列绑定路由关键字RoutingKey。
  2. 生产者将带有RoutingKey的消息发送给交换机，交换机根据RoutingKey转发到指定队列。路由模式使用direct交换机。

1. 编写生产者

  1. import com.rabbitmq.client.BuiltinExchangeType;
  2. import com.rabbitmq.client.Channel;
  3. import com.rabbitmq.client.Connection;
  4. import com.rabbitmq.client.ConnectionFactory;
  5. import java.io.IOException;
  6. import java.nio.charset.StandardCharsets;
  7. import java.util.concurrent.TimeoutException;
  8. /**
  9.      * 发布订阅者模式跟简单和工作模式不一样，不是使用默认的交换机，而是自己创建fanout交换机，生产者把消息发到交换机，由交换机转发到与之绑定的队列
  10.      */
  11. // 生产者
  12. public class Producer {
  13.      public static void main(String[] args) throws IOException, TimeoutException {
  14.          // 1.创建连接工厂
  15.          ConnectionFactory connectionFactory = new ConnectionFactory();
  16.          connectionFactory.setHost(“120.79.50.65”);
  17.          connectionFactory.setPort(5672);
  18.          connectionFactory.setUsername(“lion”);
  19.          connectionFactory.setPassword(“lion”);
  20.          connectionFactory.setVirtualHost(“/”);
  21.          // 2.创建连接
  22.          Connection connection = connectionFactory.newConnection();
  23.          // 3.建立信道
  24.          Channel channel = connection.createChannel();
  25.          // 4.创建交换机
  26.          channel.exchangeDeclare(“exchange_routing”, BuiltinExchangeType.DIRECT,true);
  27.          // 5.创建队列
  28.          channel.queueDeclare(“SEND_MAIL2”,true,false,false,null);
  29.          channel.queueDeclare(“SEND_MESSAGE2”,true,false,false,null);
  30.          channel.queueDeclare(“SEND_STATION2”,true,false,false,null);
  31.          // 6.交换机绑定队列
  32.          channel.queueBind(“SEND_MAIL2”,“exchange_routing”,“import”);
  33.          channel.queueBind(“SEND_MESSAGE2”,“exchange_routing”,“import”);
  34.          channel.queueBind(“SEND_STATION2”,“exchange_routing”,“import”);
  35.          channel.queueBind(“SEND_STATION2”,“exchange_routing”,“normal”);
  36.          // 7.发送消息
  37.          channel.basicPublish(“exchange_routing”,“import”,null,
  38.                  “双十一大促活动”.getBytes());
  39.          channel.basicPublish(“exchange_routing”,“normal”,null,
  40.                  “小心促销活动”.getBytes());
  41.          // 8.关闭资源
  42.          channel.close();
  43.          connection.close();
  44.      }
  45. }

2. 编写消费者

  1. import com.rabbitmq.client.*;
  2. import java.io.IOException;
  3. import java.util.concurrent.TimeoutException;
  4. //发送邮件消费者
  5. public class ConsumerMail {
  6.      public static void main(String[] args) throws IOException, TimeoutException {
  7.          // 1.创建连接工厂
  8.          ConnectionFactory connectionFactory = new ConnectionFactory();
  9.          connectionFactory.setHost(“120.79.50.65”);
  10.          connectionFactory.setPort(5672);
  11.          connectionFactory.setUsername(“lion”);
  12.          connectionFactory.setPassword(“lion”);
  13.          connectionFactory.setVirtualHost(“/”);
  14. // 2.创建连接
  15.          Connection connection = connectionFactory.newConnection();
  16. // 3.创建信道
  17.          Channel channel = connection.createChannel();
  18. // 4.监听队列
  19.          /**
  20.              * 参数1：监听的队列名
  21.              * 参数2：是否自动签收，如果为false，则需要手动确认消息已收到，否则MQ会一直发送消息。
  22.              * 参数3：Consumer的实现类，重写该类方法表示接收到这个消息之后该如何消费消息
  23.              */
  24.          channel.basicConsume(“SEND_MAIL2”,true,new DefaultConsumer(channel){
  25.              @Override
  26.              public void handleDelivery(String consumerTag, Envelope envelope,
  27.                      AMQP.BasicProperties properties, byte[] body) throws IOException {
  28.                  String message = new String(body, “UTF-8”);
  29.                  System.out.println(“发送邮件，消息为：”+message);
  30.              }
  31.          });
  32.      }
  33. }
  1. //发送信息消费者
  2. public class ConsumerMessage {
  3.      public static void main(String[] args) throws IOException, TimeoutException {
  4.          // 1.创建连接工厂
  5.          ConnectionFactory connectionFactory = new ConnectionFactory();
  6.          connectionFactory.setHost(“120.79.50.65”);
  7.          connectionFactory.setPort(5672);
  8.          connectionFactory.setUsername(“lion”);
  9.          connectionFactory.setPassword(“lion”);
  10.          connectionFactory.setVirtualHost(“/”);
  11. // 2.创建连接
  12.          Connection connection = connectionFactory.newConnection();
  13. // 3.创建信道
  14.          Channel channel = connection.createChannel();
  15. // 4.监听队列
  16.          /**
  17.              * 参数1：监听的队列名
  18.              * 参数2：是否自动签收，如果为false，则需要手动确认消息已收到，否则MQ会一直发送消息。
  19.              * 参数3：Consumer的实现类，重写该类方法表示接收到这个消息之后该如何消费消息
  20.              */
  21.          channel.basicConsume(“SEND_MESSAGE2”,true,new DefaultConsumer(channel){
  22.              @Override
  23.              public void handleDelivery(String consumerTag, Envelope envelope,
  24.                      AMQP.BasicProperties properties, byte[] body) throws IOException {
  25.                  String message = new String(body, “UTF-8”);
  26.                  System.out.println(“发送短信，消息为：”+message);
  27.              }
  28.          });
  29.      }
  30. }
  1. import com.rabbitmq.client.*;
  2. import java.io.IOException;
  3. import java.util.concurrent.TimeoutException;
  4. //站内信消费者
  5. public class ConsumerStation {
  6.      public static void main(String[] args) throws IOException, TimeoutException {
  7.          // 1.创建连接工厂
  8.          ConnectionFactory connectionFactory = new ConnectionFactory();
  9.          connectionFactory.setHost(“120.79.50.65”);
  10.          connectionFactory.setPort(5672);
  11.          connectionFactory.setUsername(“lion”);
  12.          connectionFactory.setPassword(“lion”);
  13.          connectionFactory.setVirtualHost(“/”);
  14. // 2.创建连接
  15.          Connection connection = connectionFactory.newConnection();
  16. // 3.创建信道
  17.          Channel channel = connection.createChannel();
  18. // 4.监听队列
  19.          /**
  20.              * 参数1：监听的队列名
  21.              * 参数2：是否自动签收，如果为false，则需要手动确认消息已收到，否则MQ会一直发送消息。
  22.              * 参数3：Consumer的实现类，重写该类方法表示接收到这个消息之后该如何消费消息
  23.              */
  24.          channel.basicConsume(“SEND_STATION2”,true,new DefaultConsumer(channel){
  25.              @Override
  26.              public void handleDelivery(String consumerTag, Envelope envelope,
  27.                      AMQP.BasicProperties properties, byte[] body) throws IOException {
  28.                  String message = new String(body, “UTF-8”);
  29.                  System.out.println(“发送站内信，消息为：”+message);
  30.              }
  31.          });
  32.      }
  33. }

Ⅴ. 通配符模式

-7

通配符模式(Topic)是在路由模式的基础上，给队列绑定带通配符的路由关键字，只要消息的RoutingKey能实现通配符匹配，就会将消

息转发到该队列。通配符模式比路由模式更灵活，使用topic交换机。

通配符规则：

1 消息设置RoutingKey时，RoutingKey由多个单词构成，中间以 . 分割。

2 队列设置RoutingKey时， # 可以匹配任意多个单词， * 可以匹配任意一个单词。

1. 编写生产者

-8

  1. package com.itbz.mq.topic;
  2. import com.rabbitmq.client.BuiltinExchangeType;
  3. import com.rabbitmq.client.Channel;
  4. import com.rabbitmq.client.Connection;
  5. import com.rabbitmq.client.ConnectionFactory;
  6. import java.io.IOException;
  7. import java.util.concurrent.TimeoutException;
  8. /**
  9.      * 发布订阅者模式跟简单和工作模式不一样，不是使用默认的交换机，而是自己创建fanout交换机，生产者把消息发到交换机，由交换机转发到与之绑定的队列
  10.      */
  11. // 生产者
  12. public class Producer {
  13.      public static void main(String[] args) throws IOException, TimeoutException {
  14.          // 1.创建连接工厂
  15.          ConnectionFactory connectionFactory = new ConnectionFactory();
  16.          connectionFactory.setHost(“120.79.50.65”);
  17.          connectionFactory.setPort(5672);
  18.          connectionFactory.setUsername(“lion”);
  19.          connectionFactory.setPassword(“lion”);
  20.          connectionFactory.setVirtualHost(“/”);
  21.          // 2.创建连接
  22.          Connection connection = connectionFactory.newConnection();
  23.          // 3.建立信道
  24.          Channel channel = connection.createChannel();
  25.          // 4.创建交换机
  26.          channel.exchangeDeclare(“exchange_topic”, BuiltinExchangeType.TOPIC,true);
  27.          // 5.创建队列
  28.          channel.queueDeclare(“SEND_MAIL3”,true,false,false,null);
  29.          channel.queueDeclare(“SEND_MESSAGE3”,true,false,false,null);
  30.          channel.queueDeclare(“SEND_STATION3”,true,false,false,null);
  31.          // 6.交换机绑定队列
  32.          channel.queueBind(“SEND_MAIL3”,“exchange_topic”,“#.mail.#”);
  33.          channel.queueBind(“SEND_MESSAGE3”,“exchange_topic”,“#.message.#”);
  34.          channel.queueBind(“SEND_STATION3”,“exchange_topic”,“#.station.#”);
  35.          // 7.发送消息
  36.              // 三个队列都匹配上了
  37.          channel.basicPublish(“exchange_topic”,“mail.message.station”,null,
  38.                  “双十一大促活动”.getBytes());
  39.              // 只发给station
  40.          channel.basicPublish(“exchange_topic”,“station”,null,
  41.                  “小心促销活动”.getBytes());
  42.          // 8.关闭资源
  43.          channel.close();
  44.          connection.close();
  45.      }
  46. }

2. 编写消费者

跟前面差不多

三.总结

这篇万字长文总结了原生Java操作RabbitMQ的各种过程，希望对您有帮助哦！

到此这篇关于原生Java操作兔子队列RabbitMQ的文章就介绍到这了,更多相关原生Java操作RabbitMQ内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！

标签

相关推荐

发表评论