vertx-lang-scala-docs_2.12 3.4.2 API < Back
 

# Packages

-  package root
  Definition Classes
    root
-  package io
  Definition Classes
    root
-  package vertx
  Definition Classes
    io
-  package scala
  Definition Classes
    vertx
-  package rabbitmq
  Definition Classes
    scala
- RabbitMQClient

c

io.vertx.scala.rabbitmq

# RabbitMQClient 

###
Companion object RabbitMQClient

#### class RabbitMQClient extends AnyRef

Linear Supertypes
AnyRef, Any
 
Ordering

1. Alphabetic
2. By Inheritance

Inherited

1. RabbitMQClient
2. AnyRef
3. Any

1. Hide All
2. Show All

Visibility

1. Public
2. All

### Instance Constructors

1.  new RabbitMQClient(_asJava: AnyRef)

### Value Members

1.  final def !=(arg0: Any): Boolean
   Definition Classes
     AnyRef → Any
2.  final def ##(): Int
   Definition Classes
     AnyRef → Any
3.  final def ==(arg0: Any): Boolean
   Definition Classes
     AnyRef → Any
4.  final def asInstanceOf[T0]: T0
   Definition Classes
     Any
5.  def asJava: AnyRef
6.  def basicAck(deliveryTag: Long, multiple: Boolean, resultHandler: Handler[AsyncResult[JsonObject]]): Unit

   Acknowledge one or several received messages.

   Acknowledge one or several received messages. Supply the deliveryTag from the AMQP.Basic.GetOk or AMQP.Basic.Deliver method containing the received message being acknowledged.

7.  def basicAckFuture(deliveryTag: Long, multiple: Boolean): Future[JsonObject]

   Like basicAck but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

8.  def basicConsume(queue: String, address: String, autoAck: Boolean, resultHandler: Handler[AsyncResult[Unit]], errorHandler: Handler[Throwable]): Unit

   Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag and error handler

9.  def basicConsume(queue: String, address: String, autoAck: Boolean, resultHandler: Handler[AsyncResult[Unit]]): Unit

   Start a non-nolocal, non-exclusive consumer, with a server-generated consumerTag.

10.  def basicConsume(queue: String, address: String, resultHandler: Handler[AsyncResult[Unit]]): Unit

    Start a non-nolocal, non-exclusive consumer, with auto acknowledgement and a server-generated consumerTag.

11.  def basicConsumeFuture(queue: String, address: String, autoAck: Boolean): Future[Unit]

    Like basicConsume but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

12.  def basicConsumeFuture(queue: String, address: String): Future[Unit]

    Like basicConsume but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

13.  def basicGet(queue: String, autoAck: Boolean, resultHandler: Handler[AsyncResult[JsonObject]]): Unit

    Retrieve a message from a queue using AMQP.Basic.Get

14.  def basicGetFuture(queue: String, autoAck: Boolean): Future[JsonObject]

    Like basicGet but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

15.  def basicNack(deliveryTag: Long, multiple: Boolean, requeue: Boolean, resultHandler: Handler[AsyncResult[JsonObject]]): Unit

    Reject one or several received messages.

16.  def basicNackFuture(deliveryTag: Long, multiple: Boolean, requeue: Boolean): Future[JsonObject]

    Like basicNack but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

17.  def basicPublish(exchange: String, routingKey: String, message: JsonObject, resultHandler: Handler[AsyncResult[Unit]]): Unit

    Publish a message.

    Publish a message. Publishing to a non-existent exchange will result in a channel-level protocol exception, which closes the channel. Invocations of Channel#basicPublish will eventually block if a resource-driven alarm is in effect.

18.  def basicPublishFuture(exchange: String, routingKey: String, message: JsonObject): Future[Unit]

    Like basicPublish but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

19.  def basicQos(prefetchCount: Int, resultHandler: Handler[AsyncResult[Unit]]): Unit

    Request specific "quality of service" settings, Limiting the number of unacknowledged messages on a channel (or connection).

    Request specific "quality of service" settings, Limiting the number of unacknowledged messages on a channel (or connection). This limit is applied separately to each new consumer on the channel.

20.  def basicQosFuture(prefetchCount: Int): Future[Unit]

    Like basicQos but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

21.  def clone(): AnyRef
    Attributes
      protected[java.lang]
    Definition Classes
      AnyRef
    Annotations
      @throws( ... )
22.  def confirmSelect(resultHandler: Handler[AsyncResult[Unit]]): Unit

    Enables publisher acknowledgements on this channel.

    Enables publisher acknowledgements on this channel. Can be called once during client initialisation. Calls to basicPublish() will have to be confirmed.

23.  def confirmSelectFuture(): Future[Unit]

    Like confirmSelect but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

24.  final def eq(arg0: AnyRef): Boolean
    Definition Classes
      AnyRef
25.  def equals(arg0: Any): Boolean
    Definition Classes
      AnyRef → Any
26.  def exchangeBind(destination: String, source: String, routingKey: String, resultHandler: Handler[AsyncResult[Unit]]): Unit

    Bind an exchange to an exchange.

27.  def exchangeBindFuture(destination: String, source: String, routingKey: String): Future[Unit]

    Like exchangeBind but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

28.  def exchangeDeclare(exchange: String, type: String, durable: Boolean, autoDelete: Boolean, config: Map[String, String], resultHandler: Handler[AsyncResult[Unit]]): Unit

    Declare an exchange with additional parameters such as dead lettering or an alternate exchnage.

29.  def exchangeDeclare(exchange: String, type: String, durable: Boolean, autoDelete: Boolean, resultHandler: Handler[AsyncResult[Unit]]): Unit

    Declare an exchange.

30.  def exchangeDeclareFuture(exchange: String, type: String, durable: Boolean, autoDelete: Boolean, config: Map[String, String]): Future[Unit]

    Like exchangeDeclare but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

31.  def exchangeDeclareFuture(exchange: String, type: String, durable: Boolean, autoDelete: Boolean): Future[Unit]

    Like exchangeDeclare but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

32.  def exchangeDelete(exchange: String, resultHandler: Handler[AsyncResult[Unit]]): Unit

    Delete an exchange, without regard for whether it is in use or not.

33.  def exchangeDeleteFuture(exchange: String): Future[Unit]

    Like exchangeDelete but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

34.  def exchangeUnbind(destination: String, source: String, routingKey: String, resultHandler: Handler[AsyncResult[Unit]]): Unit

    Unbind an exchange from an exchange.

35.  def exchangeUnbindFuture(destination: String, source: String, routingKey: String): Future[Unit]

    Like exchangeUnbind but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

36.  def finalize(): Unit
    Attributes
      protected[java.lang]
    Definition Classes
      AnyRef
    Annotations
      @throws( classOf[java.lang.Throwable] )
37.  final def getClass(): Class[_]
    Definition Classes
      AnyRef → Any
38.  def hashCode(): Int
    Definition Classes
      AnyRef → Any
39.  def isConnected(): Boolean

    Check if a connection is open

    Check if a connection is open

    returns

      true when the connection is open, false otherwise

40.  final def isInstanceOf[T0]: Boolean
    Definition Classes
      Any
41.  def isOpenChannel(): Boolean

    Check if a channel is open

    Check if a channel is open

    returns

      true when the connection is open, false otherwise

42.  def messageCount(queue: String, resultHandler: Handler[AsyncResult[JsonObject]]): Unit

    Returns the number of messages in a queue ready to be delivered.

43.  def messageCountFuture(queue: String): Future[JsonObject]

    Like messageCount but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

44.  final def ne(arg0: AnyRef): Boolean
    Definition Classes
      AnyRef
45.  final def notify(): Unit
    Definition Classes
      AnyRef
46.  final def notifyAll(): Unit
    Definition Classes
      AnyRef
47.  def queueBind(queue: String, exchange: String, routingKey: String, resultHandler: Handler[AsyncResult[Unit]]): Unit

    Bind a queue to an exchange

48.  def queueBindFuture(queue: String, exchange: String, routingKey: String): Future[Unit]

    Like queueBind but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

49.  def queueDeclare(queue: String, durable: Boolean, exclusive: Boolean, autoDelete: Boolean, config: Map[String, String], resultHandler: Handler[AsyncResult[JsonObject]]): Unit

    Declare a queue with config options

50.  def queueDeclare(queue: String, durable: Boolean, exclusive: Boolean, autoDelete: Boolean, resultHandler: Handler[AsyncResult[JsonObject]]): Unit

    Declare a queue

51.  def queueDeclareAuto(resultHandler: Handler[AsyncResult[JsonObject]]): Unit

    Actively declare a server-named exclusive, autodelete, non-durable queue.

52.  def queueDeclareAutoFuture(): Future[JsonObject]

    Like queueDeclareAuto but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

53.  def queueDeclareFuture(queue: String, durable: Boolean, exclusive: Boolean, autoDelete: Boolean, config: Map[String, String]): Future[JsonObject]

    Like queueDeclare but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

54.  def queueDeclareFuture(queue: String, durable: Boolean, exclusive: Boolean, autoDelete: Boolean): Future[JsonObject]

    Like queueDeclare but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

55.  def queueDelete(queue: String, resultHandler: Handler[AsyncResult[JsonObject]]): Unit

    Delete a queue, without regard for whether it is in use or has messages on it

56.  def queueDeleteFuture(queue: String): Future[JsonObject]

    Like queueDelete but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

57.  def queueDeleteIf(queue: String, ifUnused: Boolean, ifEmpty: Boolean, resultHandler: Handler[AsyncResult[JsonObject]]): Unit

    Delete a queue

58.  def queueDeleteIfFuture(queue: String, ifUnused: Boolean, ifEmpty: Boolean): Future[JsonObject]

    Like queueDeleteIf but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

59.  def start(resultHandler: Handler[AsyncResult[Unit]]): Unit

    Start the rabbitMQ client.

    Start the rabbitMQ client. Create the connection and the chanel.

60.  def startFuture(): Future[Unit]

    Like start but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

61.  def stop(resultHandler: Handler[AsyncResult[Unit]]): Unit

    Stop the rabbitMQ client.

    Stop the rabbitMQ client. Close the connection and its chanel.

62.  def stopFuture(): Future[Unit]

    Like stop but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

63.  final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
      AnyRef
64.  def toString(): String
    Definition Classes
      AnyRef → Any
65.  final def wait(): Unit
    Definition Classes
      AnyRef
    Annotations
      @throws( ... )
66.  final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
      AnyRef
    Annotations
      @throws( ... )
67.  final def wait(arg0: Long): Unit
    Definition Classes
      AnyRef
    Annotations
      @throws( ... )
68.  def waitForConfirms(timeout: Long, resultHandler: Handler[AsyncResult[Unit]]): Unit

    Wait until all messages published since the last call have been either ack'd or nack'd by the broker; or until timeout elapses.

    Wait until all messages published since the last call have been either ack'd or nack'd by the broker; or until timeout elapses. If the timeout expires a TimeoutException is thrown.

69.  def waitForConfirms(resultHandler: Handler[AsyncResult[Unit]]): Unit

    Wait until all messages published since the last call have been either ack'd or nack'd by the broker.

    Wait until all messages published since the last call have been either ack'd or nack'd by the broker. This will incur slight performance loss at the expense of higher write consistency. If desired, multiple calls to basicPublish() can be batched before confirming.

70.  def waitForConfirmsFuture(timeout: Long): Future[Unit]

    Like waitForConfirms but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

71.  def waitForConfirmsFuture(): Future[Unit]

    Like waitForConfirms but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

### Inherited from AnyRef

### Inherited from Any

### Ungrouped