RabbitMQ API使用

已于 2022-11-25 22:38:04 修改
阅读量460 收藏
点赞数
分类专栏： # rabbitmq 文章标签： java-rabbitmq
于 2022-11-25 22:09:59 首次发布
原文链接：https://blog.csdn.net/fox_bert/article/details/100110421
版权

转载：https://blog.csdn.net/fox_bert/article/details/100110421

RMQ模型

在这里插入图片描述

  • Server：又称Broker，接收客户端的连接，实现AMQP实体服务
  • Connection：连接，应用程序与Broker的网络连接
  • Channel：网络信道，几乎所有的操作都在Channel中进行，包括定义Queue、定义Exchange、绑定Queue与Exchange、发布消息等。Channel是进行消息读写的通道。客户端可以建立多个Channel，每个Channel代表一个会话任务。
  • Message：消息，服务器和应用程序之间传送的数据，由Properties和Body组成。Properties可以对消息进行修饰，比如消息的优先级、延迟等高级特性；Body就是消息体内容。
  • Virtual host：虚拟地址，用于进行逻辑隔离，最上层的消息路由。一个Virtual host可以有若干个Exchange和Queue，同一个Virtual host里面不能有相同的Exchange和Queue
  • Exchange：交换机，接收消息，根据路由键转发消息到绑定的队列

RabbitMQ中有三种常用的交换机类型: direct: 如果路由键匹配，消息就投递到对应的队列
fanout：投递消息给所有绑定在当前交换机上面的队列
topic：允许实现有趣的消息通信场景，使得5不同源头的消息能够达到同一个队列。topic队列名称有两个特殊的关键字。

  • 可以替换一个单词
  • Binding：Exchange和Queue之间的虚拟连接，binding中可以包含routing key
  • Routing key：一个路由规则，虚拟机可用它来确定如何路由一个特定消息
  • Queue：也称为Message Queue，消息队列，保存消息并将它们转发给消费者，多个消费者可以订阅同一个Queue，这时Queue中的消息会被平均分摊给多个消费者进行处理，而不是每个消费者都收到所有的消息并处理。
  • Prefetch count：如果有多个消费者同时订阅同一个Queue中的消息，Queue中的消息会被平摊给多个消费者。这时如果每个消息的处理时间不同，就有可能会导致某些消费者一直在忙，而另外一些消费者很快就处理完手头工作并一直空闲的情况。我们可以通过设置prefetchCount来限制Queue每次发送给每个消费者的消息数，比如我们设置prefetchCount=1，则Queue每次给每个消费者发送一条消息；消费者处理完这条消息后Queue会再给该消费者发送一条消息。
Channel channel = connection.createChannel();

Connection 可以用来创建多个Channel实例，但是Channel实例不能在线程之间共享，应用程序应该为每一个线程开辟一个channel 。某些情况下Chanel 的操作可以并发运行，但是在其他的情况下会导致在网络上，出现错误的通信。同时也会影响发送方确认机制的运行。所以，多线程之间共享 Channel 是非线程安全的。

消息模型

五种消息模型

https://blog.csdn.net/tian830937/article/details/127974125

连接过程

代码示例

1.生产者

1、创建消息生产者

package com.mmr.rabbitmq01.simple;
 
import java.io.IOException;
import java.util.concurrent.TimeoutException;
 
import com.mmr.rabbitmq.util.ConnectionUtils;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
 
public class Send {
	//队列名
	private static final String QUEUE_NAME="test_simple_queue";
 
	public static void main(String[] args) throws IOException, TimeoutException {
		//获取连接
		Connection connection=ConnectionUtils.getConnection();
		//从连接中创建通道
		Channel channel=connection.createChannel();
		//声明（创建）队列
		channel.queueDeclare(QUEUE_NAME, false, false, false, null);
		//发送的消息
		String msg="hello simple";
		channel.basicPublish("", QUEUE_NAME, null, msg.getBytes());
		
		System.out.println("--send queue:"+msg);
		//关闭通道和连接
		channel.close();
		connection.close();
		
	}
}

2.消费者

消息消费者

消费者有两种方式消费消息队列

DefaultConsumer（推荐使用）
QueueingConsumer（旧的，不推荐使用）

package com.mmr.rabbitmq01.simple;
 
import java.io.IOException;
import java.util.concurrent.TimeoutException;
 
import com.mmr.rabbitmq.util.ConnectionUtils;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.ConsumerCancelledException;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import com.rabbitmq.client.QueueingConsumer;
import com.rabbitmq.client.QueueingConsumer.Delivery;
import com.rabbitmq.client.ShutdownSignalException;
import com.rabbitmq.client.AMQP.BasicProperties;
 
/**
 * 消费者获取消息
 * @author Marvin
 *
 */
public class Recv {
	private static final String QUEUE_NAME="test_simple_queue";
	
	public static void main(String[] args) throws IOException, TimeoutException, ShutdownSignalException, ConsumerCancelledException, InterruptedException {
//		oldAPI();
		newAPI();
	}
	/**
	 * 新的方式（DefaultConsumer），推荐使用
	 */
	private static void newAPI() throws IOException, TimeoutException {
		//获取连接
		Connection connection=ConnectionUtils.getConnection();
		//创建频道
		Channel channel=connection.createChannel();
		//队列声明
		channel.queueDeclare(QUEUE_NAME, false, false, false, null);
		//定义消费者
		DefaultConsumer consumer=new DefaultConsumer(channel){
			//获取到达消息
			@Override
			public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties, byte[] body)
					throws IOException {
				String msg=new String(body,"utf-8");
				System.out.println("new api recv:"+msg);
			}
		};
		//监听队列
		channel.basicConsume(QUEUE_NAME, true, consumer);
	}
	/**
	 * 旧的方式（QueueingConsumer），不推荐使用
	 */
	private static void oldAPI() throws IOException, TimeoutException, InterruptedException {
		//获取连接
		Connection connection=ConnectionUtils.getConnection();
		//创建频道
		Channel channel=connection.createChannel();
		//定义队列的消费者
		QueueingConsumer consumer=new QueueingConsumer(channel);
		//监听队列
		channel.basicConsume(QUEUE_NAME, true, consumer);
		while(true){
			Delivery delivery=consumer.nextDelivery();
			String msgString=new String(delivery.getBody());
			System.out.println("[recv] msg:"+msgString);
		}
	}
}

API 汇总

1、连接对象
Connection【com.rabbitmq.client.Connection】

方法返回值描述
createChannel()Channel创建一个通道对象
createChannel()Channel创建一个通道对象

2、通道对象

Channel【com.rabbitmq.client.Channel】

方法返回值描述
queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete,Map<String, Object> arguments)Queue.DeclareOk声明一个队列（创建一个队列）
basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body)void向队列中声明一个消息（发送消息）发送给队列或交换机
basicConsume(String queue, boolean autoAck, Consumer callback)String监听队列（消费端监听队列后才能时实获取队列的消息，立刻消费）
basicQos(int prefetchCount)void限制发送消息个数
basicAck(long deliveryTag, boolean multiple)void手动回执一个消息
exchangeDeclare(String exchange, String type)Exchange.DeclareOk声明交换机，常用类型为 fanout(发布订阅模式)、direct(路由模式)、topic(主题模式)
queueBind(String queue, String exchange, String routingKey)Queue.BindOk将队列绑定在交换机上

保证生产者消息可达MQ服务（避免丢失）

方法返回值描述
txSelect()Tx.SelectOk（事务机制）设置为transaction模式
txCommit()Tx.CommitOk（事务机制）提交事务
txRollback()Tx.RollbackOk（事务机制）回滚事务
confirmSelect()Confirm.SelectOk（消息确认机制）生产者调用confirmSelect 将channel设置为confirm模式
waitForConfirms() waitForConfirms(long var1)boolean（消息确认机制）消息确认
waitForConfirmsOrDie() waitForConfirmsOrDie(long var1)void
addConfirmListener(ConfirmListener var1)（消息确认机制）异步监听发送方确认模式

3、消息获取对象

Consumer【com.rabbitmq.client.Consumer】
DefaultConsumer【com.rabbitmq.client.DefaultConsumer】

方法返回值描述
new DefaultConsumer(Channel channel)定义消费者，消费队列消息（接收消息）这是一个对象，并且重写里面的 handleDelivery方法
handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties, byte[] body)void重写方法。body是消息队列里面的消息

API属性详解

exchange 交换机

/*
 * 声明交换机
 * @param1 exchange 交换机名称
 * @param2 type 交换机类型
 * @param3 durable 是否持久化
 * @param4 autoDelete 是否自动删除
 * @param5 internal 当前Exchange是否用于RabbitMQ内部使用，默认false
 * @param6 arguments 扩展参数，用户扩展AMQP定制化协议
 *
 * @return AMQP.Exchange.DeclareOk 用来标识成功声明一个交换机
 *         打印信息: #method<exchange.declare-ok>()
 */
AMQP.Exchange.DeclareOk declareOk = channel.exchangeDeclare("fanout_exchange",
        BuiltinExchangeType.FANOUT, false, true, false, null);

上面声明交换机的方法，是有多个重载方法的，这些重载的方法都是由上面的这个方法种缺省了某些参数构成的。

声明方法参数介绍

  • exchange 交换机名称。
  • type 交换机类型，常用类型有fanout(扇出),direct(直接),topic(主题),headers(标题)。
  • durable 是否持久化，true表示持久化，false表示非持久化，持久化可以将交换机存盘，在服务器重启的时候不会丢失相关数据。
  • autoDelete 是否自动删除，true表示自动删除，false表示不自动删除。自动删除是指和该交换机绑定的队列或其它交换机解除绑定关系，而不是交换机与生产者断开时RabbitMQ将此交换机删除。
  • internal 是否将此交换机设置为内置交换机，true是表示为内置交换机，false表示非内置交换机，默认为false，当交换机被设置为内置时，此交换机只能用于RabbitMQ内部使用，生产者无法将消息发送到此交换机，只能通过交换机路由到此交换机。
  • arguments 扩展参数，用户扩展AMQP定制化协议，比如：alternate-exchange（备份交换机，表示该交换机为备份交换机，备份交换器是为了实现没有路由到队列的消息，声明交换机的时候添加属性alternate-exchange，声明一个备用交换机，一般声明为fanout类型，这样交换机收到路由不到队列的消息就会发送到备用交换机绑定的队列中。），后面会将参配置的参数列出。

其他方法

/*
 * 声明交换机，该方法不会等待RabbitMQ返回声明是否成功的状态，
 * 就自认为声明成功了，在声明的过程种可能因为某种原因交换机声明失败，
 * 而此方法并不知道，可能导致生产者无法将消息发送到此交换机上。
 *
 * @param1 exchange 交换机名称
 * @param2 type 交换机类型
 * @param3 durable 是否持久化
 * @param4 autoDelete 是否自动删除
 * @param5 internal 当前Exchange是否用于RabbitMQ内部使用，默认false
 * @param6 arguments 扩展参数，用户扩展AMQP定制化协议
 *
 * @return void
 */
channel.exchangeDeclareNoWait("fanout_exchange",
        BuiltinExchangeType.FANOUT, false, true, false, null);
/*
 * 根据交换机名称插叙该交换机是否存在
 * @param1 exchange 交换机名称
 * @return AMQP.Exchange.DeclareOk 用来标识一个交换机是否存在。
 *         存在返回 exchange.declare-ok，
 *         不存在返回 404，同时Channel也会被关闭。
 */
AMQP.Exchange.DeclareOk declareOk1 = channel.exchangeDeclarePassive("fanout_exchange");
/*
 * 删除交换机
 * 
 * @param1 exchange 交换机名称
 */
AMQP.Exchange.DeleteOk deleteOk = channel.exchangeDelete("fanout_exchange");
 
/*
 * 删除交换机没有被使用的交换机
 *
 * @param1 exchange 交换机名称
 * @param2 ifUnused 是否删除未被使用的交换机，
 *         true表示只有在交换机没有被使用的时候才会被删除，
 *         false表示无论如何都要删掉。
 */
AMQP.Exchange.DeleteOk deleteOk1 = channel.exchangeDelete("fanout_exchange",true);
 
/*
 * 删除交换机没有被使用的交换机,该方法表示不会等RabbitMQ给是否删除成功的消息，
 * 就认为是已经删除了，这个方法可能会因为某种原因导致交换机没有被删除，而以为被删除了。
 *
 * @param1 exchange 交换机名称
 * @param2 ifUnused 是否删除未被使用的交换机，
 *         true表示只有在交换机没有被使用的时候才会被删除，
 *         false表示无论如何都要删掉。
 */
channel.exchangeDeleteNoWait("fanout_exchange",true);

队列

/*
 * 方法默认创建一个由RabbitMQ命名的
 * (类似这种amq.gen-LhQzlgv3GhDOv8PIDabOXA 名称，这种队列也称之为匿名队列)、
 * 排他的、自动删除的、非持久化的队列
 */
channel.queueDeclare();
 
/*
 * 声明队列，如果队列不存在会创建队列
 * 生产者和消费者都能够使用queueDeclare 来声明一个队列，
 * 但是如果消费者在同一个信道上订阅了另一个队列，就无法再声明队列了。
 * 必须先取消订阅，然后将信道置为"传输"模式，之后才能声明队列。
 *
 * @param1 queueName 队列名称，队列名称不可重复
 * @param2 durable 队列是否持久化，true表示队列为持久化, 持久化的队列会存盘,
 *    在服务器重启的时候会保证不丢失相关信息
 * @param3 exclusive 设置是否排他,
 *         true表示队列为排他的, 如果一个队列被设置为排他队列,
 *         该队列仅对首次声明它的连接可见, 并在连接断开时自动删除,
 *         (这里需要注意三点:1.排他队列是基于连接Connection可见的,
 *         同一个连接的不同信道Channel是可以同时访问同一连接创建的排他队列;
 *         "首次"是指如果一个连接己经声明了一个排他队列，其他连接是不允许建立同名的排他队列的，
 *         这个与普通队列不同;即使该队列是持久化的，一旦连接关闭或者客户端退出，
 *         该排他队列都会被自动删除，这种队列适用于一个客户端同时发送和读取消息的应用场景)
 * @param4 autoDelete 设置是否自动删除。为true 则设置队列为自动删除。
 *         自动删除的前提是, 至少有一个消费者连接到这个队列，
 *         之后所有与这个队列连接的消费者都断开时，才会自动删除。
 *         不能把这个参数错误地理解为: "当连接到此队列的所有客户端断开时，这个队列自动删除"，
 *         因为生产者客户端创建这个队列，或者没有消费者客户端与这个队列连接时，都不会自动删除这个队列
 * @param5 arguments 可以设置队列其它参数，设置队列的有效期，消息的最大长度，队列的消息生命周期等等
 *
 * @throws IOException
 *
 * @return DeclareOk
 */
AMQP.Queue.DeclareOk declareOk = channel.queueDeclare("hello", false, false, true, null);
 
/*
 * 方法的返回值也是void, 表示不需要服务器的任何返回, 同时也需要注意,
 * 在调用完queueDeclareNoWait方法之后, 紧接着使用声明的队列时有可能发生异常情况
 *
 * @params 参数 参数和上面的方法参数一致
 * @throws IOException
 * @return void
 */
channel.queueDeclareNoWait("hello", false, false, true, null);
 
/*
 *这个方法用来检测相应的队列是否存在,
 * 如果存在则正常返回, 如果不存在则抛出异常,
 * 404 channel excaption, 同时Channel也会被关闭
 *
 * @param1 queueName 队列名称
 * @throws IOException
 *
 * @return DeclareOk
 */
AMQP.Queue.DeclareOk declareOk1 = channel.queueDeclarePassive("hello");
/*
 * 扇出队列
 *
 * @param1 queueName 队列名称
 * @throws IOException
 * @return DeleteOk
 */
AMQP.Queue.DeleteOk deleteOk = channel.queueDelete("hello");
/*
 * 扇出队列
 *
 * @param1 queueName 队列名称
 * @param2 ifUnused 是否在交换器没有使用的情况下删除,
 *         如果设置true表示只有在此队列没有被交换机使用的情况下才会被删除,
 *         false表示无论如何这个队列都要被删除
 * @param3 ifEmpty true表示在队列为空(队列里面没有任何消息堆积)的情况下才能够删除,false反之
 * @throws IOException
 * @return DeleteOk
 */
AMQP.Queue.DeleteOk deleteOk1 = channel.queueDelete("hello",false,false);
/*
 * 扇出队列,不等待
 *
 * @param1 queueName 队列名称
 * @param2 ifUnused 是否在交换器没有使用的情况下删除,
 *         如果设置true表示只有在此队列没有被交换机使用的情况下才会被删除,
 *         false表示无论如何这个队列都要被删除
 * @param3 ifEmpty true表示在队列为空(队列里面没有任何消息堆积)的情况下才能够删除,false反之
 * @throws IOException
 * @return void
 */
channel.queueDeleteNoWait("hello",false,false);
 
/*
 * 扇出队列内容，区别于queueDelete ，这个方法用来清空队列中的内容，而不删除队列本身
 * @param1 queueName 队列名称
 * @throws IOException
 * @return PurgeOk
 */
AMQP.Queue.PurgeOk purgeOk = channel.queuePurge("hello");

参数解释

  1. queueName：队列名称，队列名称不可重复
  2. durable：队列是否持久化，true表示队列为持久化, 持久化的队列会存盘,在服务器重启的时候会保证不丢失相关信息
  3. exclusive：设置是否排他, true表示队列为排他的, 如果一个队列被设置为排他队列, 该队列仅对首次声明它的连接可见, 并在连接断开时自动删除, (这里需要注意三点:1.排他队列是基于连接Connection可见的, 同一个连接的不同信道Channel是可以同时访问同一连接创建的排他队列;"首次"是指如果一个连接己经声明了一个排他队列，其他连接是不允许建立同名的排他队列的，这个与普通队列不同;即使该队列是持久化的，一旦连接关闭或者客户端退出，该排他队列都会被自动删除，这种队列适用于一个客户端同时发送和读取消息的应用场景)
  4. autoDelete：设置是否自动删除。为true 则设置队列为自动删除。自动删除的前提是, 至少有一个消费者连接到这个队列，之后所有与这个队列连接的消费者都断开时，才会自动删除。不能把这个参数错误地理解为: “当连接到此队列的所有客户端断开时，这个队列自动删除”，因为生产者客户端创建这个队列，或者没有消费者客户端与这个队列连接时，都不会自动删除这个队列。
  5. arguments：置队列的有效期，消息的最大长度，队列的消息生命周期等等

绑定

交换机与队列的绑定

/*
 * 将队列与交换机进行绑定
 *
 * @param1 queueName 队列名称
 * @param2 exchangeName 交换器的名称
 * @param3 routingKey  用来绑定队列和交换器的路由键;
 * @param4 argument 定义绑定的一些参数
 *
 * @throws IOException
 * @return BindOk
 */
AMQP.Queue.BindOk bindOk = channel.queueBind("queue_name", "exchange_name", "binding_key", null);
 
/*
 * 将队列与交换机进行绑定
 *
 * @param1 queueName 队列名称
 * @param2 exchangeName 交换器的名称
 * @param3 routingKey  用来绑定队列和交换器的路由键;
 *
 * @throws IOException
 * @return BindOk
 */
AMQP.Queue.BindOk bindOk1 = channel.queueBind("queue_name", "exchange_name", "binding_key");
 
 
/*
 * 将队列与交换机进行绑定 不等待返回，该方法使用时可能会出问题，
 * 因为你不知道绑定关系是否创建成功。
 *
 * @param1 queueName 队列名称
 * @param2 exchangeName 交换器的名称
 * @param3 routingKey  用来绑定队列和交换器的路由键;
 * @param4 argument 定义绑定的一些参数
 *
 * @throws IOException
 * @return void
 */
channel.queueBindNoWait("queue_name", "exchange_name", "binding_key", null);
 
/*
 * 解除队列与交换机之间的绑定关系
 *
 * @param1 queueName 队列名称
 * @param2 exchangeName 交换器的名称
 * @param3 routingKey  用来绑定队列和交换器的路由键;
 * @param4 argument 定义绑定的一些参数
 *
 * @throws IOException
 * @return UnbindOk
 */
AMQP.Queue.UnbindOk unbindOk = channel.queueUnbind("queue_name", "exchange_name", "binding_key", null);
 
/*
 * 解除队列与交换机之间的绑定关系
 *
 * @param1 queueName 队列名称
 * @param2 exchangeName 交换器的名称
 * @param3 routingKey  用来绑定队列和交换器的路由键;
 *
 * @throws IOException
 * @return UnbindOk
 */
AMQP.Queue.UnbindOk unbindOk1 = channel.queueUnbind("queue_name", "exchange_name", "binding_key");

交换机与交换机的绑定

生产者发送消息至交换器source 中，交换器source 根据路由键找到与其匹配的另一个交换器destination ， 井把消息转发到destination 中， 进而存储在.destination 绑定的队列queue 中。

/*
 * 声明目的地交换机
 */
channel.exchangeDeclare("destination_exchange",
        BuiltinExchangeType.DIRECT, false, true, false, null);
/*
 * 声明源交换机
 */
channel.exchangeDeclare("source_exchange",
        BuiltinExchangeType.FANOUT, false, true, false, null);
 
/*
 * 将交换器与交换器绑定
 *
 * @param1 destination 目标交换机名称
 * @param2 source 源头交换机名称
 * @param3 routingKey 绑定关系key
 * @param4 arguments 其它自定义配置参数
 *
 * @throws IOException
 * @return BindOk
 */
AMQP.Exchange.BindOk bindOk = channel.exchangeBind("destination_exchange",
        "source_exchange", "routingKey", null);
/*
 * 将交换器与交换器绑定
 *
 * @param1 destination 目标交换机名称
 * @param2 source 源头交换机名称
 * @param3 routingKey 绑定关系key
 *
 * @throws IOException
 * @return BindOk
 */
AMQP.Exchange.BindOk bindOk1 = channel.exchangeBind("destination_exchange",
        "source_exchange", "routingKey");
 
/*
 * 将交换器与交换器绑定,不等待返回
 *
 * @param1 destination 目标交换机名称
 * @param2 source 源头交换机名称
 * @param3 routingKey 绑定关系key
 * @param4 arguments 其它自定义配置参数
 *
 * @throws IOException
 * @return void
 */
channel.exchangeBind("destination_exchange",
                    "source_exchange", "routingKey", null);

发送消息

/*
 * 声明队列，如果队列不存在会创建队列，如果队列存在会报错，提示队列存在
 *
 * @param1 队列名称，队列名称不可重复
 * @param2 队列是否持久化，是指队列中的消息是否持久化，正常是不需要持久化的。
 * @param3 是否排他，也就是是否私有，只能被一个消费者进行消费，true是排他性，
 *         会对当前队列加锁，其他的通道不能访问，false 则是共享
 * @param4 是否自动删除，这里是指该队列是否会被自动删除，
 *         当最后一个消费者断开连接之后是否删除该队列。true是会自动删除
 * @param5 可以设置队列其它参数，设置队列的有效期，消息的最大长度，队列的消息生命周期等等
 *
 * @return DeclareOk
 *
 * @throws IOException
 *
 */
AMQP.Queue.DeclareOk declareOk = channel.queueDeclare("queue_name", true, false, true, null);

接收消息

/*
 * 消费者订阅队列，在某个队列上注册消费者，在这个队列中有消息时，
 * 就会把消息转发给此Channel来处理，如果这个队列有多个消费者，
 * RabbitMQ则会采用轮转的方式将消息分发给各个消费者。
 *
 * @param1 队列名称 将自己注册到那个队列中，以便消费那个队列的消息。
 * @param2 消息成功接收后是否要自动应答，当设置为true时，代表自动应答，false时代表手动应答。
 * @param3 当队列中有消息是，rabbitmq调用的回调接口，用于将消息传递过来。
 * @param4 rabbitmq取消该消费者对信道中队列的订阅时，调用的回调接口，
 *         如被订阅的队列被删除时，rabbitmq就会通过该接口通知消费者，
 *         以便消费者做相应处理。消费者可以根据consumerTag标识，
 *         主动调用channel.basicCancel(consumerTag)方法进行对RabbitMQ队列的注册关系进行解除。
 * @return 该方法的返回值是该消费者注册到RabbitMQ之后，RabbitMQ给生成的一个该消费者的唯一标识。
 */
String consumerTag = channel.basicConsume("hello", autoAck, deliverCallback, cancelCallback);
懒鸟一枚
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RabbitMQ 进阶
crkres9527
10-29 335
消息何去何从 mandatory和immediate是channel.basicPublish方法中的两个参数，它们都有消息传递过程中不可达目的地时将消息返回给生产者的功能。 mandatory参数 当mandatory参数设为true时，交换器无法根据自身的类型和路由键找到一个符合条件的队列，那么多RabbitMQ会调用 Basic.Return命令将消息返回给生产者。 当mandato...
RabbitMQ-HTTP API 接口列表
12-29
这资料适用于学习，希望对大家的学习有点帮助。
H5调用后端API向RabbitMQ发送消息以及H5通过WebSocket向RabbitMQ读取消息
songduo112的博客
09-17 829
H5调用后端API向RabbitMQ发送消息
RabbitMQ--客户端常用API详解
吴声子夜歌的博客
05-15 2809
连接RabbitMQ 创建Connection： //通过设置参数创建 ConnectionFactory factory = new ConnectionFactory(); factory.setHost(IP_ADDRESS); factory.setPort(PORT); factory.setUsername("guest"); factory.setPassword("guest"); Connection connection = factory.newConnection(); //通过u
Rabbitmq HTTP-API
猫影
01-20 7338
记录Rabbitmq的pika库实现了对消息队列的完美管理，但是假设我现在有n个服务（consumer），我如何能够看到哪个服务健康的存在呢？我之前的方法是写个监控服务的,每个服务写好后，会定期给监控服务发送个1，表示“我还活着”。如果监控挂了，那就没辙了。当然你可以通过http://ip:15672来查看所有服务的状态，然而不巧的是，这个管理页面不是很好，至少UI不够美观。通过官网，我们可以看到M
RabbitMQ支持消息的模式（官方API）
liudachu的博客
07-25 217
由于消息接收者处理消息的能力不同，存在处理快慢的问题，我们就需要能者多劳，处理快的多处理，处理慢的少处理；2、公平分发根据消费者的消费能力进行公平分发，处理快的处理的多，处理慢的处理的少；总结work1和work2的消息处理能力不同，但是最后处理的消息条数相同，是“按均分配”。当有多个消费者时，我们的消息会被哪个消费者消费呢，我们又该如何均衡消费者消费信息的多少呢?Direct模式是fanout模式上的一种叠加，增加了路由RoutingKey的模式。1、轮询模式的分发一个消费者一条，按均分配；...
RabbitMQ API文档
02-24
总的来说，RabbitMQ 3.5.6 API文档是开发者理解和使用RabbitMQ进行应用程序开发的关键资源，它涵盖了与RabbitMQ交互的各种概念和操作。通过深入学习并实践这些API，你可以构建出高效、可靠的分布式系统，充分利用...
RabbitMQ API
03-29
RabbitMQ API RabbitMQ API
rabbitMQ的api及规范说明书.doc
07-24
4. **RabbitMQ API使用**： - **连接**：通过`ConnectionFactory`创建连接，设置RabbitMQ服务器的地址、端口、虚拟主机名以及认证信息。 - **通道(Channel)**：通道是建立在连接上的逻辑通道，用于执行消息相关的...
RabbitMQ快速入门及API介绍（401M）
04-11
RabbitMQ快速入门及API介绍(401M) QQ截图 20191220230107.png?x-oss-process=style/pnp8 (42.73KB, 下载次数：227) 下载附件 2019-12-2023 :01 上传【课程介绍】：第一章 : RabbitMQ介绍：消息中间件概念、RabbitMQ...
Rabbitmq消息队列详解（二）——消息模式API
qq_43409401的博客
01-07 736
Rabbitmq消息模式API。
RabbitMQ收发消息——原生API
whb3299065的博客
01-29 1468
dependency> groupId>com.rabbitmqgroupId> artifactId>amqp-clientartifactId> version>2.8.2version> dependency> 首先是我们创建连接对象的函数 //这里请手动填入，我是通过配置文件注入的 protected ConnectionFactory getFactory() {
04RabbitMQ 常用API
m0_37626203的博客
09-09 794
Connection 可以用来创建多个Channel实例，但是Channel实例不能在线程之间共享，应用程序应该为每一个线程开辟一个channel。某些情况下Chanel 的操作可以并发运行，但是在其他的情况下会导致在网络上，出现错误的通信。这个方法在实际开发过程中还是非常有用的，它用来检测相应的交换机是否存在。exchangeDeclare有多个重载方法，这些重载的方法都是由下面这个方法中缺省的某些参数构成的。无参的方法默认创建了一个由RabbitMQ命名的、排他的、自动删除的、非持久化的队列。
RabbitMQ之Java API操作
weixin_42926863的博客
09-07 1307
RabbitMQ
RabbitMq——核心API即概念的详细介绍与使用
b15735105314的博客
03-14 637
Exchange：接收生产者的消息，并根据路由键转发消息到所绑定的队列。 一、Exchange属性 Name：交换机名称 Type：交换机类型 direct、topic、fanout、headers Durability：是否持久化，true为持久化。如果是false，那么在RabbitMq服务重启之后，交换机就会没有了。 Auto Delete：当最后一个绑定到Exchange上的队列删除后，自动删除改Exchange。即当Exchange没有队列的时候自动删除。实际生产环境中是不会设置自动
rabbitmq如何暂停消费_RabbitMQ如何高效的消费消息-工作队列
weixin_30092093的博客
01-24 3346
在上篇介绍了如何简单的发送一个消息队列之后，我们本篇来看下RabbitMQ的另外一种模式，工作队列。什么是工作队列我们上篇文章说的是，一个生产者生产了消息被一个消费者消费了，如下图上面这种简单的消息队列确实可以处理我们的任务，但是当我们队列中的任务过多，处理每条任务有需要很长的耗时，那么使用一个消费者处理消息显然不不够的，所以我们可以增加消费者，来共享消息队列中的消息，进行任务处理。也就是如下图虽...
RabbitMQ教程大全看这一篇就够了-java版本
又逢乱世
11-06 3017
rabbitmq
RabbitMq中交换器（Exchange）类型详解
技术人集结地
04-04 7305
RabbitMQ是工作中经常使用的一个开源消息队列，它是通过Erlang语言来开发的，RabbitMQ中有一个非常常见且重要的概念叫交换器（Exchange），所有生产者提交的消息都是通过Exchange进行接收，然后通过特定的路由策略转发对特定的队列（Queue）中，然后消费者通过绑定特定的队列，将队列中的信息进行消费处理。我们如果是通过RabbitMQ的客户端来进行创建Exchange的话，一定需要你选择一个特定的Exchange类型的，这个时候如果不了解每一种类型的特性，就很容易选择错误，造成整
java操作rabbitmq消费者示例
feinifi的博客
10-12 6137
rabbitmq是作为消息队列，在实际应用中很常见，生产者将消息发送到某个队列，消费者消费这个队列。 消息在队列中，消费者要消费，需要监听队列，简单的来说，就是注册一个方法到消费者通道，这个方法就会在有消息的时候执行。 下面通过java来操作rabbitmq，给出代码示例。 这里介绍三种消费者示例方法 1、最简单的注册。 直接通过channel.basicConsume()设置callback。 2、模拟一个...
python fastapi 使用rabbitmq
最新发布
05-29
Python FastAPI 是一个快速（高性能）且易于学习的 Web 框架，它可以与多种消息队列（MQ）进行集成，其中包括 RabbitMQ。 在使用 FastAPI 和 RabbitMQ 进行集成时，你可以使用 Pika 库来连接 RabbitMQ，然后在 FastAPI 中使用 FastAPI-BackgroundTasks 库来异步处理消息队列中的消息。以下是一个简单的示例： 1. 安装 FastAPI 和 Pika 库： ```python pip install fastapi pip install pika pip install fastapi-background-tasks ``` 2. 在 FastAPI 应用程序中导入相关库： ```python from fastapi import FastAPI, BackgroundTasks import pika ``` 3. 连接 RabbitMQ： ```python connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost')) channel = connection.channel() channel.queue_declare(queue='my_queue') ``` 4. 编写处理函数，并在函数中使用 `channel.basic_publish()` 方法将消息发布到消息队列中： ```python def process_message(message): # 处理消息的代码 print("Received message:", message) def send_message_to_queue(message): channel.basic_publish(exchange='', routing_key='my_queue', body=message) ``` 5. 在 FastAPI 中定义异步任务： ```python app = FastAPI() @app.post("/send_message") async def send_message(message: str, background_tasks: BackgroundTasks): background_tasks.add_task(send_message_to_queue, message) return {"message": "Message sent successfully!"} @app.on_event("startup") async def startup_event(): connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost')) channel = connection.channel() channel.queue_declare(queue='my_queue') channel.basic_consume(queue='my_queue', on_message_callback=process_message, auto_ack=True) channel.start_consuming() ``` 6. 启动应用程序： ```python uvicorn main:app --reload ``` 这是一个简单的示例，你可以根据你的需求进行调整和扩展。下面是一些相关问题：
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值