新手必看的RabbitMQ消息队列

最新推荐文章于 2024-06-24 20:50:35 发布
最新推荐文章于 2024-06-24 20:50:35 发布
阅读量209 收藏 1
点赞数 1
分类专栏： 消息中间件专栏 文章标签： rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A_dg_Jffery/article/details/110407446
版权

RabbitMQ(基于AMQP)

RabbitMQ是实现了高级消息队列协议（AMQP）的开源消息代理软件（亦称面向消息的中间件）。RabbitMQ服务器是用Erlang语言编写的，而集群和故障转移是构建在开放电信平台框架上的。所有主要的编程语言均有与代理接口通讯的客户端库

  • MQ是消息通信的模型:实现MQ的两种主流方式:AMQP(连接协议)/JMS(网络交互).
  • AMQP(跨语言):通过规定协议统一数据交互格式
  • JMS(必须java):定义统一接口,对消息进行统一处理
  • RabbitMQ只能从队列中接收消息

RabbitMQ六种工作模式:

  • simple简单模式: 单生产单消费;

  • work模式:在同一个队列中可以有多个消费者,消费者之间对消息的接收是竞争的,一个消息只能被一个消费者接收,多个消费者不会接收到同一个消息;

  • Publish/Subscribe发布与订阅模式:一个消息可以被多个消费者接收,交换机类型为:fanout广播模式,生产者将消息发送到交换器，然后交换器绑定到多个队列，监听该队列的所有消费者消费消息

  • Routing路由模式:队列与交换机绑定,需要指定一个RoutingKey(路由key),消息的发送者在向Exchange(交换机)发送消息时,必须指定消息的RoutingKey,Exchange不再把消息交给每一个绑定的队列中,而是根据消息指定的RoutingKey进行判断,只有队列的RoutingKey与消息的RoutingKey完全匹配,才能接收到消息;

  • Topics通配符模式(常用):类似于正则表达式匹配的一种模式。主要使用#、*进行匹配

  • RabbitMQ使用步骤(简单模式)__>后面将相同的代码(创建连接)抽取成了一个工具类_>操作步骤在代码体现不想写测试可以copy

    • 生产者发送消息到RabbitMQ消息队列,消费者从队列中获取消息,可以使用RabbitMQ的简单模式(simple)
    • 生产者发送消息步骤:
      • 创建连接工厂(设置RabbitMQ的连接参数);
      • 创建连接;
      • 创建频道;
      • 声明队列;
      • 发送消息;
      • 关闭资源;
/**
  * 简单模式发送消息
  */
 public class Producer {
     static final String QUEUE_NAME = "simple_queue";
 
     public static void main(String[] args) throws IOException, TimeoutException {
         //1- 创建连接工厂(设置RabbitMQ的连接参数);
         ConnectionFactory connectionFactory = new ConnectionFactory();
         connectionFactory.setHost("localhost");
         connectionFactory.setPort(8888);
         connectionFactory.setVirtualHost("/zhupeiliang");
         connectionFactory.setUsername("zhupeiliang");
         connectionFactory.setPassword("zhupeiliang");
         //2- 创建连接;
         Connection connection = connectionFactory.newConnection();
         //3- 创建频道;
         Channel channel = connection.createChannel();
         //4- 声明队列;
         /*
              *参数1:队列名称 
              *参数2:定义持久化到服务器上,
              *参数3:是否独占本连接,
              *参数4:是否在不使用的时候将队列自动删除,
              *参数5:其他参数
          */
         
         channel.queueDeclare(QUEUE_NAME, true, false, false, null);
         //5- 发送消息;
         String message = "你好,rabbitMQ!!!";
         /*
              * 参数1:交换机名称,如果没有则指定空字符串(表示使用默认的交换机)
              * 参数2:路由key,简单模式中可以使用队列名称
              * 参数3:消息其它属性,没有指定null
              * 参数4:消息内容
          */
         channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
         //6- 关闭资源;
         channel.close();
         connection.close();
     }
 }
  • 消费者消费消息步骤:(从RabbitMQ队列接收消息__>与生产者发送消息是的队列一致)
    • 创建连接工厂;
    • 创建连接;
    • 创建频道;
    • 声明队列;
    • 创建消费者(接收消息并处理消息);
    • 监听队列
/**
  * 简单模式,:消费者消费消息
  */
 public class Consumer {
     public static void main(String[] args) throws IOException, TimeoutException {
         //1 - 创建连接工厂;
         //2 - 创建连接;
         Connection connection = ConnectionUtil.getConnection();
         //3 - 创建频道;
         Channel channel = connection.createChannel();
         //4 - 声明队列;
         /*
          *参数1:队列名称
          *参数2:定义持久化到服务器上,
          *参数3:是否独占本连接,
          *参数4:是否在不使用的时候将队列自动删除,
          *参数5:其他参数
          */
         channel.queueDeclare(Producer.QUEUE_NAME, true, false, false, null);
         //5 - 创建消费者(接收消息并处理消息);
         DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
             @Override
             public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                 //输出信息:__>/路由key/交换机/消息id/接收到的消息
                 System.out.println(envelope.getRoutingKey());
                 System.out.println(envelope.getExchange());
                 System.out.println(envelope.getDeliveryTag());
                 System.out.println(new String(body, "urf-8"));
             }
         };
         //6 -监听队列
         /*
             参数1:队列名称
             参数2:是否自动确认,设置为true,表示消息接收到自动向MQ回复接收到了,MQ则会将消息从队列中自动删除,反之需要手动删除
             参数3:消费者
          */
         channel.basicConsume(Producer.QUEUE_NAME, true, defaultConsumer);
 
     }
 }

RabbitMQ(work工作队列模式)

  • 生产者:
	/**
	  *work模式发送消息
	  */
	public class Producer {
	  static final String QUEUE_NAME = "work_queue";
	    public static void main(String[] args) throws IOException, TimeoutException {
	      //1- 创建连接工厂(设置RabbitMQ的连接参数);
	      //2- 创建连接;
	      Connection connection = ConnectionUtil.getConnection();
	      //3- 创建频道;
	      Channel channel = connection.createChannel();
	      //4- 声明队列;
	      /*
	       *参数1:队列名称
	       *参数2:定义持久化到服务器上,
	       *参数3:是否独占本连接,
	       *参数4:是否在不使用的时候将队列自动删除,
	       *参数5:其他参数
	       /
	      channel.queueDeclare(QUEUE_NAME, true, false, false, null);
	      for (int i = 1; i <= 30; i++) {
	          //5- 发送消息;
	          //定义消息体
	          String message = "你好,rabbitMQ!!!---work摩丝" + i;
	          /
	           * 参数1:交换机名称,如果没有则指定空字符串(表示使用默认的交换机)
	           * 参数2:路由key,简单模式中可以使用队列名称
	           * 参数3:消息其它属性,没有指定null
	           * 参数4:消息内容
	           */
	          channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
	          System.out.println(message);
	      }
	      //6- 关闭资源;
	      channel.close();
	      connection.close();
	  }
	
	 }
  • 消费者1:
/**
  * work模式,:消费者消费消息
  */
 public class Consumer1 {
     public static void main(String[] args) throws IOException, TimeoutException {
         //1 - 创建连接工厂;
         //2 - 创建连接;
         Connection connection = ConnectionUtil.getConnection();
         //3 - 创建频道;
         Channel channel = connection.createChannel();
         //4 - 声明队列;
         /*
          *参数1:队列名称
          *参数2:定义持久化到服务器上,
          *参数3:是否独占本连接,
          *参数4:是否在不使用的时候将队列自动删除,
          *参数5:其他参数
          */
         channel.queueDeclare(Producer.QUEUE_NAME, true, false, false, null);
         //设置每次可以预取多少个消息
         channel.basicQos(1);
         //5 - 创建消费者(接收消息并处理消息);
         DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
             @Override
             public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                 //输出信息:__>/路由key/交换机/消息id/接收到的消息
                 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);
                     //确认消息是否被消费,参数1:消息id,参数2:false表示只有当前这条消息被处理了
                     channel.basicAck(envelope.getDeliveryTag(), false);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
         };
         //6 -监听队列
         /*
             参数1:队列名称
             参数2:是否自动确认,设置为true,表示消息接收到自动向MQ回复接收到了,MQ则会将消息从队列中自动删除,反之需要手动删除
             参数3:消费者
          */
         channel.basicConsume(Producer.QUEUE_NAME, true, defaultConsumer);
 
     }
 }
  • 消费者2: 跟消费者1代码相同,只是消费同一个队列的消息

RabbitMQ(发布与订阅模式)

  • 一个消息发送之后可以让多个或者所有消费者接收到消息,消费者只能监听一个队列
  • 多了一个角色__>Exchange交换机,接收生产者发送的消息并决定如何投递消息到其绑定的队列,消息的投递取决于交换机的类型;
  • 交换机类型:
    • 广播(fanout):将消息交给所有绑定交换机的队列
    • 定向(direct):把消息交给 符合指定routingKey的队列
    • 通配符(topic):把消息交给符合routingPattern(路由模式)的队列
  • 广播模式示例:
    • 生产者:
/**
  * 发布与订阅模式发送消息
  */
 public class Producer {
     //交换机名称_广播类型
     static final String FANOUT_EXCHANGE = "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 {
         //1- 创建连接工厂(设置RabbitMQ的连接参数);
         Connection connection = ConnectionUtil.getConnection();
         //2- 创建频道;
         Channel channel = connection.createChannel();
         //3-声明交换机,参数1:交换机名称,参数2:交换机类型-广播类型(&&-->fanout,direct,topic)
         channel.exchangeDeclare(FANOUT_EXCHANGE, BuiltinExchangeType.FANOUT);
         //4- 声明队列;
         /*
          *参数1:队列名称
          *参数2:定义持久化到服务器上,
          *参数3:是否独占本连接,
          *参数4:是否在不使用的时候将队列自动删除,
          *参数5:其他参数
          */
         channel.queueDeclare(FANOUT_QUEUE_1, true, false, false, null);
         channel.queueDeclare(FANOUT_QUEUE_2, true, false, false, null);
         //4.1- 队列绑定到交换机,参数1:队列名称;参数2:交换机名称;参数3:路由key,没有设置空
         channel.queueBind(FANOUT_QUEUE_1, FANOUT_EXCHANGE, "");
         channel.queueBind(FANOUT_QUEUE_2, FANOUT_EXCHANGE, "");
 
         for (int i = 1; i <= 10; i++) {
             //5- 发送消息;
             String message = "你好,rabbitMQ!!!--发布与订阅摩丝------" + i;
             /*
              * 参数1:交换机名称,如果没有则指定空字符串(表示使用默认的交换机)
              * 参数2:路由key,简单模式中可以使用队列名称
              * 参数3:消息其它属性,没有指定null
              * 参数4:消息内容
              */
             channel.basicPublish(FANOUT_EXCHANGE, "", null, message.getBytes());
             channel.basicPublish(FANOUT_EXCHANGE, "", null, message.getBytes());
             System.out.println(message);
         }
         //6- 关闭资源;
         channel.close();
         connection.close();
     }
 
 }
  • 消费者1:
/**
  * 发布与订阅模式,:消费者消费消息
  */
 public class Consumer1 {
     public static void main(String[] args) throws IOException, TimeoutException {
         //1 - 创建连接工厂;
         //2 - 创建连接;
         Connection connection = ConnectionUtil.getConnection();
         //3 - 创建频道;
         Channel channel = connection.createChannel();
         //3.1 - 声明交换机
         channel.exchangeDeclare(Producer.FANOUT_EXCHANGE, BuiltinExchangeType.FANOUT);
         //4 - 声明队列;
         /*
          *参数1:队列名称
          *参数2:定义持久化到服务器上,
          *参数3:是否独占本连接,
          *参数4:是否在不使用的时候将队列自动删除,
          *参数5:其他参数
          */
         channel.queueDeclare(Producer.FANOUT_QUEUE_1, true, false, false, null);
 //        channel.queueDeclare(Producer.FANOUT_QUEUE_2, true, false, false, null);
         //4.1 - 队列绑定到交换机上;参数1:队列名称;参数2:交换机名称;参数3:路由key
         channel.queueBind(Producer.FANOUT_QUEUE_1, Producer.FANOUT_EXCHANGE, "");
         //5 - 创建消费者(接收消息并处理消息);
         DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
             @Override
             public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                 //输出信息:__>/路由key/交换机/消息id/接收到的消息
                 System.out.println("路由key:" + envelope.getRoutingKey());
                 System.out.println("交换机:" + envelope.getExchange());
                 System.out.println("消息id:" + envelope.getDeliveryTag());
 //                System.out.println(new String(body));
                 System.out.println("消费者1---消费消息::" + new String(body, "UTF-8"));
 //                System.out.println("?");
             }
         };
         //6 -监听队列
         /*
             参数1:队列名称
             参数2:是否自动确认,设置为true,表示消息接收到自动向MQ回复接收到了,MQ则会将消息从队列中自动删除,反之需要手动删除
             参数3:消费者
          */
         channel.basicConsume(Producer.FANOUT_QUEUE_1, true, defaultConsumer);
 
     }
 }
  • 消费者2:与消费者1一样,更换监听 队列即可

RabbitMQ(Routing路由模式)

  • 生产者:发送两条消息(路由key分别为: insert , update__[路由key随意指定,消费者指定的路由key必须跟生产者一致])
/**
  * RoutingKey路由模式发送消息
  */
 public class Producer {
     //交换机名称_路由类型
     static final String DIRECT_EXCHANGE = "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 {
         //1- 创建连接工厂(设置RabbitMQ的连接参数);
         Connection connection = ConnectionUtil.getConnection();
         //2- 创建频道;
         Channel channel = connection.createChannel();
         //3-声明交换机,参数1:交换机名称,参数2:交换机类型-路由类型(&&-->fanout,direct,topic)
         channel.exchangeDeclare(DIRECT_EXCHANGE, BuiltinExchangeType.DIRECT);
         //4- 声明队列;
         /*
          *参数1:队列名称
          *参数2:定义持久化到服务器上,
          *参数3:是否独占本连接,
          *参数4:是否在不使用的时候将队列自动删除,
          *参数5:其他参数
          */
         channel.queueDeclare(DIRECT_QUEUE_INSERT, true, false, false, null);
         channel.queueDeclare(DIRECT_QUEUE_UPDATE, true, false, false, null);
         //4.1- 队列绑定到交换机,参数1:队列名称;参数2:交换机名称;参数3:路由key,没有设置空
         channel.queueBind(DIRECT_QUEUE_INSERT, DIRECT_EXCHANGE, "insert");
         channel.queueBind(DIRECT_QUEUE_UPDATE, DIRECT_EXCHANGE, "update");
 
         //5- 发送消息;
         String message = "你好,rabbitMQ!!!--路由摩丝----RoutingKey为-->insert";
         /*
          * 参数1:交换机名称,如果没有则指定空字符串(表示使用默认的交换机)
          * 参数2:路由key,简单模式中可以使用队列名称
          * 参数3:消息其它属性,没有指定null
          * 参数4:消息内容
          */
         channel.basicPublish(DIRECT_EXCHANGE, "insert", null, message.getBytes());
         System.out.println(message);
         //5- 发送消息;
         message = "你好,rabbitMQ!!!--路由摩丝----RoutingKey为-->update";
         /*
          * 参数1:交换机名称,如果没有则指定空字符串(表示使用默认的交换机)
          * 参数2:路由key,简单模式中可以使用队列名称
          * 参数3:消息其它属性,没有指定null
          * 参数4:消息内容
          */
         channel.basicPublish(DIRECT_EXCHANGE, "update", null, message.getBytes());
         System.out.println(message);
         //6- 关闭资源;
         channel.close();
         connection.close();
     }
 
 }
  • 消费者:创建两个消费者,监听的队列分别绑定的路由key为: insert , updatea
/**
  * RoutingKey路由模式,:消费者消费消息
  */
 public class Consumer1 {
     public static void main(String[] args) throws IOException, TimeoutException {
         //1 - 创建连接工厂;
         //2 - 创建连接;
         Connection connection = ConnectionUtil.getConnection();
         //3 - 创建频道;
         Channel channel = connection.createChannel();
         //3.1 - 声明交换机,模式为路由模式
         channel.exchangeDeclare(Producer.DIRECT_EXCHANGE, BuiltinExchangeType.DIRECT);
         //4 - 声明队列;
         /*
          *参数1:队列名称
          *参数2:定义持久化到服务器上,
          *参数3:是否独占本连接,
          *参数4:是否在不使用的时候将队列自动删除,
          *参数5:其他参数
          */
         channel.queueDeclare(Producer.DIRECT_QUEUE_INSERT, true, false, false, null);
         //4.1 - 队列绑定到交换机上;参数1:队列名称;参数2:交换机名称;参数3:路由key
         channel.queueBind(Producer.DIRECT_QUEUE_INSERT, Producer.DIRECT_EXCHANGE, "insert");
         //5 - 创建消费者(接收消息并处理消息);
         DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
             @Override
             public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                 //输出信息:__>/路由key/交换机/消息id/接收到的消息
                 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"));
             }
         };
         //6 -监听队列
         /*
             参数1:队列名称
             参数2:是否自动确认,设置为true,表示消息接收到自动向MQ回复接收到了,MQ则会将消息从队列中自动删除,反之需要手动删除
             参数3:消费者
          */
         channel.basicConsume(Producer.DIRECT_QUEUE_INSERT, true, defaultConsumer);
 
     }
 }
  • 消费者同上,切换消费者监听的消息队列
  • *__>RoutingKey路由模式要求队列绑定到交换机的时候指定路由key,生产者发送消息的时候需要携带路由key,只有消息的路由key与队列的路由key相同时,才能让该队列接收到消息;

RabbitMQ(topic通配符模式):

  • 生产者:发送消息包含有:dg.insert,dg.update,dg.delete的三种路由key的消息
/**
  * topic通配符模式,:消费者消费消息
  */
 public class Consumer1 {
     public static void main(String[] args) throws IOException, TimeoutException {
         //1 - 创建连接工厂;
         //2 - 创建连接;
         Connection connection = ConnectionUtil.getConnection();
         //3 - 创建频道;
         Channel channel = connection.createChannel();
         //3.1 - 声明交换机,模式为路由模式
         channel.exchangeDeclare(Producer.TOPIC_EXCHANGE, BuiltinExchangeType.TOPIC);
         //4 - 声明队列;
         /*
          *参数1:队列名称
          *参数2:定义持久化到服务器上,
          *参数3:是否独占本连接,
          *参数4:是否在不使用的时候将队列自动删除,
          *参数5:其他参数
          */
         channel.queueDeclare(Producer.TOPIC_EXCHANGE, true, false, false, null);
         //4.1 - 队列绑定到交换机上;参数1:队列名称;参数2:交换机名称;参数3:路由key
         channel.queueBind(Producer.TOPIC_QUEUE_1,Producer.TOPIC_EXCHANGE, "dg.update");
         channel.queueBind(Producer.TOPIC_QUEUE_1,Producer.TOPIC_EXCHANGE, "dg.delete");
         //5 - 创建消费者(接收消息并处理消息);
         DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
             @Override
             public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                 //输出信息:__>/路由key/交换机/消息id/接收到的消息
                 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"));
             }
         };
         //6 -监听队列
         /*
             参数1:队列名称
             参数2:是否自动确认,设置为true,表示消息接收到自动向MQ回复接收到了,MQ则会将消息从队列中自动删除,反之需要手动删除
             参数3:消费者
          */
         channel.basicConsume(Producer.TOPIC_QUEUE_1, true, defaultConsumer);
 
     }
 }
  • 消费者1:监听的队列绑定到交换的的路由key为:dg.update , dg.delete
/**
  * topic通配符模式,消费者消费消息
  */
 public class Consumer1 {
     public static void main(String[] args) throws IOException, TimeoutException {
         //1 - 创建连接工厂;
         //2 - 创建连接;
         Connection connection = ConnectionUtil.getConnection();
         //3 - 创建频道;
         Channel channel = connection.createChannel();
         //3.1 - 声明交换机,模式为路由模式
         channel.exchangeDeclare(Producer.TOPIC_EXCHANGE, BuiltinExchangeType.TOPIC);
         //4 - 声明队列;
         /*
          *参数1:队列名称
          *参数2:定义持久化到服务器上,
          *参数3:是否独占本连接,
          *参数4:是否在不使用的时候将队列自动删除,
          *参数5:其他参数
          */
         channel.queueDeclare(Producer.TOPIC_EXCHANGE, true, false, false, null);
         //4.1 - 队列绑定到交换机上;参数1:队列名称;参数2:交换机名称;参数3:路由key
         channel.queueBind(Producer.TOPIC_QUEUE_1,Producer.TOPIC_EXCHANGE, "dg.update");
         channel.queueBind(Producer.TOPIC_QUEUE_1,Producer.TOPIC_EXCHANGE, "dg.delete");
         //5 - 创建消费者(接收消息并处理消息);
         DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
             @Override
             public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                 //输出信息:__>/路由key/交换机/消息id/接收到的消息
                 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"));
             }
         };
         //6 -监听队列
         /*
             参数1:队列名称
             参数2:是否自动确认,设置为true,表示消息接收到自动向MQ回复接收到了,MQ则会将消息从队列中自动删除,反之需要手动删除
             参数3:消费者
          */
         channel.basicConsume(Producer.TOPIC_QUEUE_1, true, defaultConsumer);
 
     }
 }
  • 消费者2:监听的队列绑定到交换机的路由key为: dg.*
/**
  * topic通配符模式,:消费者消费消息
  */
 public class Consumer2 {
     public static void main(String[] args) throws IOException, TimeoutException {
         //1 - 创建连接工厂;
         //2 - 创建连接;
         Connection connection = ConnectionUtil.getConnection();
         //3 - 创建频道;
         Channel channel = connection.createChannel();
         //3.1 - 声明交换机,模式为路由模式
         channel.exchangeDeclare(Producer.TOPIC_EXCHANGE, BuiltinExchangeType.TOPIC);
         //4 - 声明队列;
         /*
          *参数1:队列名称
          *参数2:定义持久化到服务器上,
          *参数3:是否独占本连接,
          *参数4:是否在不使用的时候将队列自动删除,
          *参数5:其他参数
          */
         channel.queueDeclare(Producer.TOPIC_EXCHANGE, true, false, false, null);
         //4.1 - 队列绑定到交换机上;参数1:队列名称;参数2:交换机名称;参数3:路由key
         channel.queueBind(Producer.TOPIC_QUEUE_2, Producer.TOPIC_EXCHANGE, "dg.*");
         //5 - 创建消费者(接收消息并处理消息);
         DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
             @Override
             public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                 //输出信息:__>/路由key/交换机/消息id/接收到的消息
                 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"));
             }
         };
         //6 -监听队列
         /*
             参数1:队列名称
             参数2:是否自动确认,设置为true,表示消息接收到自动向MQ回复接收到了,MQ则会将消息从队列中自动删除,反之需要手动删除
             参数3:消费者
          */
         channel.basicConsume(Producer.TOPIC_QUEUE_2, true, defaultConsumer);
 
     }
 }

使用RabbitMQ总结:两种模式:

  • 不使用Exchange交换机:(使用默认交换机)
    1.simple简单模式:一个生产者生产 一个消息到一个队列被一个消费者接收消费
    2.work工作模式:生产者发送消息到队列,可以被多个消费者监听该队列,但是一个消息只能被一个消费者消费;
  • 使用Exchange交换机:
    • 订阅模式(交换机:fanout广播,direct定性,topic通配符)
      1.发布与订阅模式:使用fanout广播类型的交换机,可以将一个消息发送到所有绑定了该交换机的队列;
      2.路由模式:使用了direct定向类型的交换机,消息会携带路由key,交换机根据消息的路由key与队列的路由key进行匹配,匹配之后该队列接收消息,消费;
      3.通配符模式:使用了topic通配符模式类型的交换机,消息会携带路由key,交换机根据消息的路由key与队列的路由key(,#)进行匹配,匹配之后该队列接收消息,消费;
      " * ">匹配一个词 , 例如:dg.      >只能匹配 dg.xxx
      " # ">匹配一个词或者多个词, 例如:dg.#>能够匹配dg.xxx.xxx , dg.xxx

RabbitMQ与SpringBoot整合

1.导入坐标

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-amqp</artifactId>
   <version>2.3.2.RELEASE</version>
</dependency>

2.生产者配置spring.yml配置文件.rabbitMQ的连接参数

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

3.创建消息生产者,topic通配符模式

@Configuration
public class RabbitMQConfig {
   //交换机名称
   public static final String DG_TOPIC_EXCHANGE = "dg_topic_exchange";
   //队列名称
   public static final String DG_QUEUE = "dg_queue";

   //声明交换机
   @Bean("dgTopicExchange")
   public Exchange topicExchange() {
       return ExchangeBuilder.topicExchange(DG_TOPIC_EXCHANGE).durable(true).build();
   }

   //声明队列
   @Bean("dgQueue")
   public Queue dgQueue() {
       return QueueBuilder.durable(DG_QUEUE).build();
   }

   //将队列绑定到交换机
   @Bean
   public Binding bindingQueueExchange(@Qualifier("dgTopicExchange") Exchange exchange,
                                       @Qualifier("dgQueue") Queue queue) {
       return BindingBuilder.bind(queue).to(exchange).with("dg.#").noargs();
   }
}

4.创建消费者:topic通配符模式

消费者监听的队列名称必须跟消息生产者发送消息的队列名称要匹配;
  • SpringBoot提供了对于AMQP整合,可以使用RabbitMQTemplate发送消息,可以使用@RabbitListener注解接收消息;
 	@Component
	 public class RabbitMQConsumer {
     /**
      * 接收队列消息
      * @param message 消息内容
      * @RabbitListener(queues = "dgQueue")参数可以监听多个队列  例如:
      * @RabbitListener(queues = {"q1","q2"})
      */
     @RabbitListener(queues = "dgQueue")
     public void rabbitMQListener(String message) {
         System.out.println("消费者接收到的消息为:" + message);
     }
 }

5.消息生产者工程中编写测试类

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringbootRabbitmqProducerApplicationTests {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void mqContextLoads() {
        rabbitTemplate.convertAndSend(RabbitMQConfig.DG_TOPIC_EXCHANGES, "inserts", "路由key为:dg.inserts");
        rabbitTemplate.convertAndSend(RabbitMQConfig.DG_TOPIC_EXCHANGES, "deletes", "路由key为:dg.deletes");
        rabbitTemplate.convertAndSend(RabbitMQConfig.DG_TOPIC_EXCHANGES, "updates", "路由key为:dg.updates");
        rabbitTemplate.convertAndSend(RabbitMQConfig.DG_TOPIC_EXCHANGES, "selects", "路由key为:dg.selects");
    }

}

如有不对的地方,请各路大神指正 ~

互联网渣渣东
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
消息队列RabbitMQ入门
Zhangrunhong的博客
12-06 394
文章目录1、消息队列概述2、消息队列应用场景 1、消息队列概述 消息队列中间件是分布式系统中重要的组件，主要解决应用解耦，异步消息，流量削锋等问题，实现高性能，高可用，可伸缩和最终一致性架构。目前使用较多的消息队列有ActiveMQ，RabbitMQ，ZeroMQ，Kafka，MetaMQ，RocketMQ 2、消息队列应用场景 消息队列在实际应用中常用的使用场景有，异步处理，应用解耦，流量削锋和...
一文读懂RabbitMQ 消息队列
程序媛小琬的博客
09-15 490
RabbitMQ 是一个由 Erlang 语言开发的 AMQP 的开源实现。AMQP，即Advanced Message Queuing Protocol，高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。消息中间件主要用于组件之间的解耦，消息的发送者无需知道消息使用者的存在，反之亦然。
消息队列——RabbitMq
weixin_45080272的博客
05-28 4430
一、消息队列的使用场景 一、消息队列的使用场景) 一、消息队列的使用场景 异步处理 应用解耦 流量削锋 消息通讯 【1】异步处理：场景说明：用户注册后，需要发注册邮件和注册短信。 引入消息队列后架构如下：用户的响应时间=注册信息写入数据库的时间，例如50毫秒。发注册邮箱、发注册短信写入消息队列后，直接返回客户端，因写入消息队列的速度很快，基本可以忽略，因此用户的响应时间可能是50毫秒。 按照传统的做法： ①、串行方式，将注册信息写入数据库成功后，发注册邮件，再发送注册短信，以上三个成功后，返回客户端。可
消息队列—RabbitMQ（万字详解）
How many ten years in the life time?
12-22 5200
在基于微服务开发的电商项目中，商品的查询和商品的修改是通过两个服务实现的，如果修改了商品的价格，如何保证商品查询服务查询出来的商品价格同步更新呢？同步调用➢ A服务调用B服务，需要等待B服务执行完毕的返回值，A服务才可以继续往下执行。和RPC(Dubbo)实现同步调用。异步调用➢ A服务调用B服务，而无需等待B服务的执行结果，也就是说在B服务执行的同时A服务可以继续往下执行。➢ 通过：消息队列实现异步调用。 MQ全称为Message Queue，消息队列（MQ）是一种应用程序对应用程序的通信方法。应用程序通
【消息队列】六万字长文详细带你RabbitMQ从入门到精通
最新发布
Hanson的博客
06-24 423
六万字长文深入了解RabbitMQ，从基础到精通
RabbitMQ 的七种消息传递形式
weixin_64811434的博客
12-04 2494
RabbitMQ 的七种消息传递形式
消息队列：Rabbit MQ详解一篇搞定
qq_40853919的博客
07-02 6035
存储消息的队列。消息：比如字符串，对象，二进制数据，json等等。队列：先进先出的数据结构。耗时的场景（比如支付结果查询）异步化的场景（比如远程控制）应用解耦的场景消息队列的好处异步处理削峰填谷应用解耦要给系统引入额外的中间件，维护成本，资源成本，学习成本。消息队列：就需要考虑，消息丢失，消费消息，数据的一致性。中间件消息队列也是中间件的一种，我们可以注意到，它是作为生产和消费的中间人，进行传递消息，实现解耦。
RabbitMQ消息队列
qq_38935605的博客
09-02 2006
前期准备：第一步需要安装Erlang和MQ软件，如果不安装Erlang的话我们的MQ是无法安装的，我是在win10下面给大家演示的，我下面给大家准备好了两个安装包，直接下载下来就可以使用了，当然也可以自己去官网下载，但是下载下来一定要注意一下版本对应，不然下载下来Erlang安装好了安装MQ的时候就提示错误（版本太低），如果自己已经下载安装完了发现版本对不上的话就找到安装目录，双击下图选项。上面安装完成以后就自行启动MQ了，这里就不演示了，启动完成以后打开浏览器输入。
Spring boot整合消息队列RabbitMQ实现四种消息模式（适合新手或者开发人员了解学习RabbitMQ机制）
06-27
本项目基于Spring的AMQP模块，整合流行的开源消息队列中间件rabbitMQ,实现一个向rabbitMQ添加和读取消息的功能。并比较了两种模式：生产者-消费者模式和发布-订阅模式的区别。AMQP作为比JMS更加高级的消息协议，支持...
Rabbitmq 默认配置文件模板
01-20
RabbitMQ是一款开源的消息队列系统，基于AMQP（Advanced Message Queuing Protocol）协议实现，广泛应用于分布式系统中，用于解耦应用程序，提高系统的可扩展性和容错性。在RabbitMQ的运行过程中，配置文件起着至关...
new-rabbitMq
06-12
在IT行业中，RabbitMQ是一个广泛使用的开源消息队列系统，它基于Advanced Message Queuing Protocol (AMQP)标准，用于在分布式系统中高效地处理异步任务和消息传递。"new-rabbitMq"可能是一个关于RabbitMQ的更新、新...
MQ消息中间件教程pdf新手
07-10
"MQ消息中间件教程pdf新手" 本教程主要介绍了MQ消息中间件的基本概念和工作原理，并且详细讲解了Spring Boot与RabbitMQ的整合应用。同时，本教程还对消息服务的作用和好处进行了详细的分析和说明。 一、为什么要...
boot-rabbitmq.zip
06-17
RabbitMQ作为一款广泛应用的消息队列服务器，被广泛采用在微服务架构中。Spring Boot是Java领域一个流行的轻量级框架，它简化了Spring应用的初始搭建以及开发过程。当我们需要在Spring Boot项目中集成RabbitMQ时，`...
RabbitMQ消息发送和接收（实例）
热门推荐
weixin_59334478的博客
11-06 1万+
的消息只能被同一个消费者消费，如果没有消费监听队列那么消息会存放到队列中持久化保存，直到有消费者来消费这个消息，如果有消费者监听队列则立即消费发送到队列中的消息。4.模拟连续向队列中放两次消息，这两条消息的队列名称相同，内容不同。再次返回消息队列，此时消息队列已经没有了消息，消息已经模拟出队了。7.此时进入控制台查看队列，发现队列中的消息已经全部取出。修改Idea消息的内容再向队列里发送一次消息。修改Idea消息的内容再向队列里发送一次消息。模拟从队列中取出消息，查看取出的消息内容。
RabbitMQ基本原理
Little_Arya的博客
03-07 1628
RabbitMQ基本原理
如何使用RabbitMQ发送和接收消息
qq_28245087的博客
06-08 1988
本文介绍了如何使用RabbitMQ的Python客户端库pika来发送和接收消息，并提供了示例代码。读者可以根据自己的需求修改代码，例如修改队列名称、发送不同的消息等。RabbitMQ 是一个开源的消息队列软件，可以用于在应用程序之间传递消息。上面的代码分别演示了如何向队列发送消息和从队列接收消息。您可以根据自己的需求修改代码，例如修改队列的名称、发送不同的消息等。
RabbitMQ消息中间件快速入门
欢迎来到编程小栈
07-19 2271
文章目录一、同步和异步通讯1. 同步通讯2. 异步通讯二、RabbitMQ1. MessageQueue对比2. RabbitMQ快速入门【1】安装与启动【2】基本结构3. 五种消息模型介绍【1】入门案例1）publisher实现2）consumer实现4. SpringAMQP实现【1】Basic Queue 基本消息队列1）消息发送2）消息接收3）测试【2】WorkQueue工作消息队列1）消息发送2）消息接收3）测试4）prefetch提前获取【3】发布订阅三种模式1）Fanout[1] 声明队列和交
一文读懂RabbitMQ消息队列
zhoupenghui168的博客
04-27 2375
什么是消息队列，为什么要使用消息队列,消息队列使用的场景，RabbitMQ介绍,RabbitMQ的高级特性，RabbitMQ原理以及各种模式，RabbitMQ的高级特性，RabbitMQ的几种交换器，
SpringBoot新手指南：RabbitMQ消息中间件实战与整合
本教程是一份针对SpringBoot新手的MQ消息中间件教程PDF，主要目标是帮助学习者理解并掌握RabbitMQ这一常用的消息中间件。教程首先阐述了为何在软件开发中选择使用消息服务，特别是对于分布式系统，如SpringBoot应用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值