ServiceBusReceiverAsyncClient (Azure SDK for Java Reference Documentation)

java.lang.Object
- com.azure.messaging.servicebus.ServiceBusReceiverAsyncClient

All Implemented Interfaces:: AutoCloseable

public final class ServiceBusReceiverAsyncClient
extends Object
implements AutoCloseable

An asynchronous receiver responsible for receiving ServiceBusReceivedMessage from a specific queue or topic on Azure Service Bus.

Create an instance of receiver

 // The required parameters is connectionString, a way to authenticate with Service Bus using credentials.
 ServiceBusReceiverAsyncClient consumer = new ServiceBusClientBuilder()
     .connectionString("Endpoint={fully-qualified-namespace};SharedAccessKeyName={policy-name};"
         + "SharedAccessKey={key};EntityPath={eh-name}")
     .receiver()
     .queueName("<< QUEUE NAME >>")
     .buildAsyncClient();

Create an instance of sender using default credential

 // The required parameters is connectionString, a way to authenticate with Service Bus using credentials.
 ServiceBusReceiverAsyncClient receiver = new ServiceBusClientBuilder()
     .credential("<<fully-qualified-namespace>>",
         new DefaultAzureCredentialBuilder().build())
     .receiver()
     .queueName("<< QUEUE NAME >>")
     .buildAsyncClient();

Receive all messages from Service Bus resource

 Disposable subscription = receiver.receive().subscribe(context -> {
     ServiceBusReceivedMessage message = context.getMessage();
     System.out.printf("Received message id: %s%n", message.getMessageId());
     System.out.printf("Contents of message as string: %s%n", new String(message.getBody(), UTF_8));
 });
 
 // When program ends, or you're done receiving all messages.
 receiver.close();
 subscription.dispose();

Receive messages in ReceiveMode.RECEIVE_AND_DELETE mode from Service Bus resource

 
 
 // Keep a reference to `subscription`. When the program is finished receiving messages, call
 // subscription.dispose(). This will stop fetching messages from the Service Bus.
 Disposable subscription = receiver.receive()
     .subscribe(context -> {
         ServiceBusReceivedMessage message = context.getMessage();
         System.out.printf("Received message id: %s%n", message.getMessageId());
         System.out.printf("Contents of message as string: %s%n", new String(message.getBody(), UTF_8));
     }, error -> System.err.print(error));

Rate limiting consumption of messages from Service Bus resource

For message receivers that need to limit the number of messages they receive at a given time, they can use BaseSubscriber.request(long).

 receiver.receive().subscribe(new BaseSubscriber<ServiceBusReceivedMessageContext>() {
     private static final int NUMBER_OF_MESSAGES = 5;
     private final AtomicInteger currentNumberOfMessages = new AtomicInteger();
 
     {@literal @}Override
     protected void hookOnSubscribe(Subscription subscription) {
         // Tell the Publisher we only want 5 message at a time.
         request(NUMBER_OF_MESSAGES);
     }
 
     {@literal @}Override
     protected void hookOnNext(ServiceBusReceivedMessageContext value) {
         // Process the ServiceBusReceivedMessage
         ServiceBusReceivedMessage message = value.getMessage();
 
         // If the number of messages we have currently received is a multiple of 5, that means we have reached
         // the last message the Subscriber will provide to us. Invoking request(long) here, tells the Publisher
         // that the subscriber is ready to get more messages from upstream.
         if (currentNumberOfMessages.incrementAndGet() % 5 == 0) {
             request(NUMBER_OF_MESSAGES);
         }
     }
 });

See Also:: ServiceBusClientBuilder, To communicate with a Service Bus resource using a synchronous client.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Mono<Void>`	`abandon(MessageLockToken lockToken)` Abandon a `message` with its lock token.
`Mono<Void>`	`abandon(MessageLockToken lockToken, Map<String,Object> propertiesToModify)` Abandon a `message` with its lock token and updates the message's properties.
`Mono<Void>`	`abandon(MessageLockToken lockToken, Map<String,Object> propertiesToModify, String sessionId)` Abandon a `message` with its lock token and updates the message's properties.
`Mono<Void>`	`abandon(MessageLockToken lockToken, String sessionId)` Abandon a `message` with its lock token.
`void`	`close()` Disposes of the consumer by closing the underlying connection to the service.
`Mono<Void>`	`complete(MessageLockToken lockToken)` Completes a `message` using its lock token.
`Mono<Void>`	`complete(MessageLockToken lockToken, String sessionId)` Completes a `message` using its lock token.
`Mono<Void>`	`deadLetter(MessageLockToken lockToken)` Moves a `message` to the deadletter sub-queue.
`Mono<Void>`	`deadLetter(MessageLockToken lockToken, DeadLetterOptions deadLetterOptions)` Moves a `message` to the deadletter subqueue with deadletter reason, error description, and/or modified properties.
`Mono<Void>`	`deadLetter(MessageLockToken lockToken, DeadLetterOptions deadLetterOptions, String sessionId)` Moves a `message` to the deadletter subqueue with deadletter reason, error description, and/or modified properties.
`Mono<Void>`	`deadLetter(MessageLockToken lockToken, String sessionId)` Moves a `message` to the deadletter sub-queue.
`Mono<Void>`	`defer(MessageLockToken lockToken)` Defers a `message` using its lock token.
`Mono<Void>`	`defer(MessageLockToken lockToken, Map<String,Object> propertiesToModify)` Defers a `message` using its lock token with modified message property.
`Mono<Void>`	`defer(MessageLockToken lockToken, Map<String,Object> propertiesToModify, String sessionId)` Defers a `message` using its lock token with modified message property.
`Mono<Void>`	`defer(MessageLockToken lockToken, String sessionId)` Defers a `message` using its lock token.
`String`	`getEntityPath()` Gets the Service Bus resource this client interacts with.
`String`	`getFullyQualifiedNamespace()` Gets the fully qualified Service Bus namespace that the connection is associated with.
`Mono<byte[]>`	`getSessionState(String sessionId)` Gets the state of a session given its identifier.
`Mono<ServiceBusReceivedMessage>`	`peek()` Reads the next active message without changing the state of the receiver or the message source.
`Mono<ServiceBusReceivedMessage>`	`peek(String sessionId)` Reads the next active message without changing the state of the receiver or the message source.
`Mono<ServiceBusReceivedMessage>`	`peekAt(long sequenceNumber)` Starting from the given sequence number, reads next the active message without changing the state of the receiver or the message source.
`Mono<ServiceBusReceivedMessage>`	`peekAt(long sequenceNumber, String sessionId)` Starting from the given sequence number, reads next the active message without changing the state of the receiver or the message source.
`Flux<ServiceBusReceivedMessage>`	`peekBatch(int maxMessages)` Reads the next batch of active messages without changing the state of the receiver or the message source.
`Flux<ServiceBusReceivedMessage>`	`peekBatch(int maxMessages, String sessionId)` Reads the next batch of active messages without changing the state of the receiver or the message source.
`Flux<ServiceBusReceivedMessage>`	`peekBatchAt(int maxMessages, long sequenceNumber)` Starting from the given sequence number, reads the next batch of active messages without changing the state of the receiver or the message source.
`Flux<ServiceBusReceivedMessage>`	`peekBatchAt(int maxMessages, long sequenceNumber, String sessionId)` Starting from the given sequence number, reads the next batch of active messages without changing the state of the receiver or the message source.
`Flux<ServiceBusReceivedMessageContext>`	`receive()` Receives a stream of `messages` from the Service Bus entity and completes them when they are finished processing.
`Flux<ServiceBusReceivedMessageContext>`	`receive(ReceiveAsyncOptions options)` Receives a stream of `messages` from the Service Bus entity with a set of options.
`Mono<ServiceBusReceivedMessage>`	`receiveDeferredMessage(long sequenceNumber)` Receives a deferred `message`.
`Mono<ServiceBusReceivedMessage>`	`receiveDeferredMessage(long sequenceNumber, String sessionId)` Receives a deferred `message`.
`Flux<ServiceBusReceivedMessage>`	`receiveDeferredMessageBatch(Iterable<Long> sequenceNumbers)` Receives a batch of deferred `messages`.
`Flux<ServiceBusReceivedMessage>`	`receiveDeferredMessageBatch(Iterable<Long> sequenceNumbers, String sessionId)` Receives a batch of deferred `messages`.
`Mono<Instant>`	`renewMessageLock(MessageLockToken lockToken)` Asynchronously renews the lock on the specified message.
`Mono<Instant>`	`renewSessionLock(String sessionId)` Sets the state of a session given its identifier.
`Mono<Void>`	`setSessionState(String sessionId, byte[] sessionState)` Sets the state of a session given its identifier.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - getFullyQualifiedNamespace
```
public String getFullyQualifiedNamespace()
```
    Gets the fully qualified Service Bus namespace that the connection is associated with. This is likely similar to {yournamespace}.servicebus.windows.net.
    
    Returns:
    
    The fully qualified Service Bus namespace that the connection is associated with.
  - getEntityPath
```
public String getEntityPath()
```
    Gets the Service Bus resource this client interacts with.
    
    Returns:
    
    The Service Bus resource this client interacts with.
  - abandon
```
public Mono<Void> abandon(MessageLockToken lockToken)
```
    Abandon a message with its lock token. This will make the message available again for processing. Abandoning a message will increase the delivery count on the message.
    
    Parameters:
    
    lockToken - Lock token of the message.
    
    Returns:
    
    A Mono that completes when the Service Bus abandon operation completes.
    
    Throws:
    
    NullPointerException - if lockToken is null.
    
    UnsupportedOperationException - if the receiver was opened in ReceiveMode.RECEIVE_AND_DELETE mode.
    
    IllegalArgumentException - if MessageLockToken.getLockToken() returns a null lock token.
  - abandon
```
public Mono<Void> abandon(MessageLockToken lockToken,
                          String sessionId)
```
    Abandon a message with its lock token. This will make the message available again for processing. Abandoning a message will increase the delivery count on the message.
    
    Parameters:
    
    lockToken - Lock token of the message.
    
    sessionId - Session id of the message to abandon. null if there is no session.
    
    Returns:
    
    A Mono that completes when the Service Bus abandon operation completes.
    
    Throws:
    
    NullPointerException - if lockToken is null.
    
    UnsupportedOperationException - if the receiver was opened in ReceiveMode.RECEIVE_AND_DELETE mode.
    
    IllegalArgumentException - if MessageLockToken.getLockToken() returns a null lock token.
  - abandon
```
public Mono<Void> abandon(MessageLockToken lockToken,
                          Map<String,Object> propertiesToModify)
```
    Abandon a message with its lock token and updates the message's properties. This will make the message available again for processing. Abandoning a message will increase the delivery count on the message.
    
    Parameters:
    
    lockToken - Lock token of the message.
    
    propertiesToModify - Properties to modify on the message.
    
    Returns:
    
    A Mono that completes when the Service Bus operation finishes.
    
    Throws:
    
    NullPointerException - if lockToken is null.
    
    UnsupportedOperationException - if the receiver was opened in ReceiveMode.RECEIVE_AND_DELETE mode.
    
    IllegalArgumentException - if MessageLockToken.getLockToken() returns a null lock token.
  - abandon
```
public Mono<Void> abandon(MessageLockToken lockToken,
                          Map<String,Object> propertiesToModify,
                          String sessionId)
```
    Abandon a message with its lock token and updates the message's properties. This will make the message available again for processing. Abandoning a message will increase the delivery count on the message.
    
    Parameters:
    
    lockToken - Lock token of the message.
    
    propertiesToModify - Properties to modify on the message.
    
    sessionId - Session id of the message to abandon. null if there is no session.
    
    Returns:
    
    A Mono that completes when the Service Bus abandon operation completes.
    
    Throws:
    
    NullPointerException - if lockToken is null.
    
    UnsupportedOperationException - if the receiver was opened in ReceiveMode.RECEIVE_AND_DELETE mode.
    
    IllegalArgumentException - if MessageLockToken.getLockToken() returns a null lock token.
  - complete
```
public Mono<Void> complete(MessageLockToken lockToken)
```
    Completes a message using its lock token. This will delete the message from the service.
    
    Parameters:
    
    lockToken - Lock token of the message.
    
    Returns:
    
    A Mono that finishes when the message is completed on Service Bus.
    
    Throws:
    
    NullPointerException - if lockToken is null.
    
    UnsupportedOperationException - if the receiver was opened in ReceiveMode.RECEIVE_AND_DELETE mode.
    
    IllegalArgumentException - if MessageLockToken.getLockToken() returns a null lock token.
  - complete
```
public Mono<Void> complete(MessageLockToken lockToken,
                           String sessionId)
```
    Completes a message using its lock token. This will delete the message from the service.
    
    Parameters:
    
    lockToken - Lock token of the message.
    
    sessionId - Session id of the message to complete. null if there is no session.
    
    Returns:
    
    A Mono that finishes when the message is completed on Service Bus.
    
    Throws:
    
    NullPointerException - if lockToken is null.
    
    UnsupportedOperationException - if the receiver was opened in ReceiveMode.RECEIVE_AND_DELETE mode.
    
    IllegalArgumentException - if MessageLockToken.getLockToken() returns a null lock token.
  - defer
```
public Mono<Void> defer(MessageLockToken lockToken)
```
    Defers a message using its lock token. This will move message into the deferred subqueue.
    
    Parameters:
    
    lockToken - Lock token of the message.
    
    Returns:
    
    A Mono that completes when the Service Bus defer operation finishes.
    
    Throws:
    
    NullPointerException - if lockToken is null.
    
    UnsupportedOperationException - if the receiver was opened in ReceiveMode.RECEIVE_AND_DELETE mode.
    
    IllegalArgumentException - if MessageLockToken.getLockToken() returns a null lock token.
    
    See Also:
    
    Message deferral
  - defer
```
public Mono<Void> defer(MessageLockToken lockToken,
                        String sessionId)
```
    Defers a message using its lock token. This will move message into the deferred subqueue.
    
    Parameters:
    
    lockToken - Lock token of the message.
    
    sessionId - Session id of the message to defer. null if there is no session.
    
    Returns:
    
    A Mono that completes when the defer operation finishes.
    
    Throws:
    
    NullPointerException - if lockToken is null.
    
    UnsupportedOperationException - if the receiver was opened in ReceiveMode.RECEIVE_AND_DELETE mode.
    
    IllegalArgumentException - if MessageLockToken.getLockToken() returns a null lock token.
    
    See Also:
    
    Message deferral
  - defer
```
public Mono<Void> defer(MessageLockToken lockToken,
                        Map<String,Object> propertiesToModify)
```
    Defers a message using its lock token with modified message property. This will move message into the deferred subqueue.
    
    Parameters:
    
    lockToken - Lock token of the message.
    
    propertiesToModify - Message properties to modify.
    
    Returns:
    
    A Mono that completes when the defer operation finishes.
    
    Throws:
    
    NullPointerException - if lockToken is null.
    
    UnsupportedOperationException - if the receiver was opened in ReceiveMode.RECEIVE_AND_DELETE mode.
    
    IllegalArgumentException - if MessageLockToken.getLockToken() returns a null lock token.
    
    See Also:
    
    Message deferral
  - defer
```
public Mono<Void> defer(MessageLockToken lockToken,
                        Map<String,Object> propertiesToModify,
                        String sessionId)
```
    Defers a message using its lock token with modified message property. This will move message into the deferred subqueue.
    
    Parameters:
    
    lockToken - Lock token of the message.
    
    propertiesToModify - Message properties to modify.
    
    sessionId - Session id of the message to defer. null if there is no session.
    
    Returns:
    
    A Mono that completes when the Service Bus defer operation finishes.
    
    Throws:
    
    NullPointerException - if lockToken is null.
    
    UnsupportedOperationException - if the receiver was opened in ReceiveMode.RECEIVE_AND_DELETE mode.
    
    IllegalArgumentException - if MessageLockToken.getLockToken() returns a null lock token.
    
    See Also:
    
    Message deferral
  - deadLetter
```
public Mono<Void> deadLetter(MessageLockToken lockToken)
```
    Moves a message to the deadletter sub-queue.
    
    Parameters:
    
    lockToken - Lock token of the message.
    
    Returns:
    
    A Mono that completes when the dead letter operation finishes.
    
    Throws:
    
    NullPointerException - if lockToken is null.
    
    UnsupportedOperationException - if the receiver was opened in ReceiveMode.RECEIVE_AND_DELETE mode.
    
    IllegalArgumentException - if MessageLockToken.getLockToken() returns a null lock token.
    
    See Also:
    
    Dead letter queues
  - deadLetter
```
public Mono<Void> deadLetter(MessageLockToken lockToken,
                             String sessionId)
```
    Moves a message to the deadletter sub-queue.
    
    Parameters:
    
    lockToken - Lock token of the message.
    
    sessionId - Session id of the message to deadletter. null if there is no session.
    
    Returns:
    
    A Mono that completes when the dead letter operation finishes.
    
    Throws:
    
    NullPointerException - if lockToken is null.
    
    UnsupportedOperationException - if the receiver was opened in ReceiveMode.RECEIVE_AND_DELETE mode.
    
    IllegalArgumentException - if MessageLockToken.getLockToken() returns a null lock token.
    
    See Also:
    
    Dead letter queues
  - deadLetter
```
public Mono<Void> deadLetter(MessageLockToken lockToken,
                             DeadLetterOptions deadLetterOptions)
```
    Moves a message to the deadletter subqueue with deadletter reason, error description, and/or modified properties.
    
    Parameters:
    
    lockToken - Lock token of the message.
    
    deadLetterOptions - The options to specify when moving message to the deadletter sub-queue.
    
    Returns:
    
    A Mono that completes when the dead letter operation finishes.
    
    Throws:
    
    NullPointerException - if lockToken or deadLetterOptions is null.
    
    UnsupportedOperationException - if the receiver was opened in ReceiveMode.RECEIVE_AND_DELETE mode.
    
    IllegalArgumentException - if MessageLockToken.getLockToken() returns a null lock token.
  - deadLetter
```
public Mono<Void> deadLetter(MessageLockToken lockToken,
                             DeadLetterOptions deadLetterOptions,
                             String sessionId)
```
    Moves a message to the deadletter subqueue with deadletter reason, error description, and/or modified properties.
    
    Parameters:
    
    lockToken - Lock token of the message.
    
    deadLetterOptions - The options to specify when moving message to the deadletter sub-queue.
    
    sessionId - Session id of the message to deadletter. null if there is no session.
    
    Returns:
    
    A Mono that completes when the dead letter operation finishes.
    
    Throws:
    
    NullPointerException - if lockToken is null.
    
    UnsupportedOperationException - if the receiver was opened in ReceiveMode.RECEIVE_AND_DELETE mode.
    
    IllegalArgumentException - if MessageLockToken.getLockToken() returns a null lock token.
  - getSessionState
```
public Mono<byte[]> getSessionState(String sessionId)
```
    Gets the state of a session given its identifier.
    
    Parameters:
    
    sessionId - Identifier of session to get.
    
    Returns:
    
    The session state or an empty Mono if there is no state set for the session.
    
    Throws:
    
    IllegalStateException - if the receiver is a non-session receiver.
  - peek
```
public Mono<ServiceBusReceivedMessage> peek()
```
    Reads the next active message without changing the state of the receiver or the message source. The first call to peek() fetches the first active message for this receiver. Each subsequent call fetches the subsequent message in the entity.
    
    Returns:
    
    A peeked ServiceBusReceivedMessage.
    
    See Also:
    
    Message browsing
  - peek
```
public Mono<ServiceBusReceivedMessage> peek(String sessionId)
```
    Reads the next active message without changing the state of the receiver or the message source. The first call to peek() fetches the first active message for this receiver. Each subsequent call fetches the subsequent message in the entity.
    
    Parameters:
    
    sessionId - Session id of the message to peek from. null if there is no session.
    
    Returns:
    
    A peeked ServiceBusReceivedMessage.
    
    See Also:
    
    Message browsing
  - peekAt
```
public Mono<ServiceBusReceivedMessage> peekAt(long sequenceNumber)
```
    Starting from the given sequence number, reads next the active message without changing the state of the receiver or the message source.
    
    Parameters:
    
    sequenceNumber - The sequence number from where to read the message.
    
    Returns:
    
    A peeked ServiceBusReceivedMessage.
    
    See Also:
    
    Message browsing
  - peekAt
```
public Mono<ServiceBusReceivedMessage> peekAt(long sequenceNumber,
                                              String sessionId)
```
    Starting from the given sequence number, reads next the active message without changing the state of the receiver or the message source.
    
    Parameters:
    
    sequenceNumber - The sequence number from where to read the message.
    
    sessionId - Session id of the message to peek from. null if there is no session.
    
    Returns:
    
    A peeked ServiceBusReceivedMessage.
    
    See Also:
    
    Message browsing
  - peekBatch
```
public Flux<ServiceBusReceivedMessage> peekBatch(int maxMessages)
```
    Reads the next batch of active messages without changing the state of the receiver or the message source.
    
    Parameters:
    
    maxMessages - The number of messages.
    
    Returns:
    
    A Flux of messages that are peeked.
    
    Throws:
    
    IllegalArgumentException - if maxMessages is not a positive integer.
    
    See Also:
    
    Message browsing
  - peekBatch
```
public Flux<ServiceBusReceivedMessage> peekBatch(int maxMessages,
                                                 String sessionId)
```
    Reads the next batch of active messages without changing the state of the receiver or the message source.
    
    Parameters:
    
    maxMessages - The number of messages.
    
    sessionId - Session id of the messages to peek from. null if there is no session.
    
    Returns:
    
    An IterableStream of messages that are peeked.
    
    Throws:
    
    IllegalArgumentException - if maxMessages is not a positive integer.
    
    See Also:
    
    Message browsing
  - peekBatchAt
```
public Flux<ServiceBusReceivedMessage> peekBatchAt(int maxMessages,
                                                   long sequenceNumber)
```
    Starting from the given sequence number, reads the next batch of active messages without changing the state of the receiver or the message source.
    
    Parameters:
    
    maxMessages - The number of messages.
    
    sequenceNumber - The sequence number from where to start reading messages.
    
    Returns:
    
    A Flux of ServiceBusReceivedMessage peeked.
    
    Throws:
    
    IllegalArgumentException - if maxMessages is not a positive integer.
    
    See Also:
    
    Message browsing
  - peekBatchAt
```
public Flux<ServiceBusReceivedMessage> peekBatchAt(int maxMessages,
                                                   long sequenceNumber,
                                                   String sessionId)
```
    Starting from the given sequence number, reads the next batch of active messages without changing the state of the receiver or the message source.
    
    Parameters:
    
    maxMessages - The number of messages.
    
    sequenceNumber - The sequence number from where to start reading messages.
    
    sessionId - Session id of the messages to peek from. null if there is no session.
    
    Returns:
    
    An IterableStream of ServiceBusReceivedMessage peeked.
    
    Throws:
    
    IllegalArgumentException - if maxMessages is not a positive integer.
    
    See Also:
    
    Message browsing
  - receive
```
public Flux<ServiceBusReceivedMessageContext> receive()
```
    Receives a stream of messages from the Service Bus entity and completes them when they are finished processing.
    By default, each successfully consumed message is auto-completed and auto-renewed. When downstream consumers throw an exception, the auto-completion feature will abandon the message. Auto-renewal occurs until the operation timeout has elapsed.
    
    Returns:
    
    A stream of messages from the Service Bus entity.
    
    Throws:
    
    com.azure.core.amqp.exception.AmqpException - if operation timeout has elapsed and downstream consumers are still processing the message.
  - receive
```
public Flux<ServiceBusReceivedMessageContext> receive(ReceiveAsyncOptions options)
```
    Receives a stream of messages from the Service Bus entity with a set of options. To disable lock auto-renewal, set setMaxAutoRenewDuration to Duration.ZERO or null.
    
    Parameters:
    
    options - Set of options to set when receiving messages.
    
    Returns:
    
    A stream of messages from the Service Bus entity.
    
    Throws:
    
    NullPointerException - if options is null.
    
    IllegalArgumentException - if max auto-renew duration is negative.
  - receiveDeferredMessage
```
public Mono<ServiceBusReceivedMessage> receiveDeferredMessage(long sequenceNumber)
```
    Receives a deferred message. Deferred messages can only be received by using sequence number.
    
    Parameters:
    
    sequenceNumber - The sequence number of the message.
    
    Returns:
    
    A deferred message with the matching sequenceNumber.
  - receiveDeferredMessage
```
public Mono<ServiceBusReceivedMessage> receiveDeferredMessage(long sequenceNumber,
                                                              String sessionId)
```
    Receives a deferred message. Deferred messages can only be received by using sequence number.
    
    Parameters:
    
    sequenceNumber - The sequence number of the message.
    
    sessionId - Session id of the deferred message. null if there is no session.
    
    Returns:
    
    A deferred message with the matching sequenceNumber.
  - receiveDeferredMessageBatch
```
public Flux<ServiceBusReceivedMessage> receiveDeferredMessageBatch(Iterable<Long> sequenceNumbers)
```
    Receives a batch of deferred messages. Deferred messages can only be received by using sequence number.
    
    Parameters:
    
    sequenceNumbers - The sequence numbers of the deferred messages.
    
    Returns:
    
    A Flux of deferred messages.
  - receiveDeferredMessageBatch
```
public Flux<ServiceBusReceivedMessage> receiveDeferredMessageBatch(Iterable<Long> sequenceNumbers,
                                                                   String sessionId)
```
    Receives a batch of deferred messages. Deferred messages can only be received by using sequence number.
    
    Parameters:
    
    sequenceNumbers - The sequence numbers of the deferred messages.
    
    sessionId - Session id of the deferred messages. null if there is no session.
    
    Returns:
    
    An IterableStream of deferred messages.
  - renewMessageLock
```
public Mono<Instant> renewMessageLock(MessageLockToken lockToken)
```
    Asynchronously renews the lock on the specified message. The lock will be renewed based on the setting specified on the entity. When a message is received in ReceiveMode.PEEK_LOCK mode, the message is locked on the server for this receiver instance for a duration as specified during the Queue creation (LockDuration). If processing of the message requires longer than this duration, the lock needs to be renewed. For each renewal, the lock is reset to the entity's LockDuration value.
    
    Parameters:
    
    lockToken - Lock token of the message to renew.
    
    Returns:
    
    The new expiration time for the message.
    
    Throws:
    
    NullPointerException - if lockToken is null.
    
    UnsupportedOperationException - if the receiver was opened in ReceiveMode.RECEIVE_AND_DELETE mode.
    
    IllegalStateException - if the receiver is a session receiver.
    
    IllegalArgumentException - if MessageLockToken.getLockToken() returns an empty value.
  - renewSessionLock
```
public Mono<Instant> renewSessionLock(String sessionId)
```
    Sets the state of a session given its identifier.
    
    Parameters:
    
    sessionId - Identifier of session to get.
    
    Returns:
    
    The next expiration time for the session lock.
    
    Throws:
    
    IllegalStateException - if the receiver is a non-session receiver.
  - setSessionState
```
public Mono<Void> setSessionState(String sessionId,
                                  byte[] sessionState)
```
    Sets the state of a session given its identifier.
    
    Parameters:
    
    sessionId - Identifier of session to get.
    
    sessionState - State to set on the session.
    
    Returns:
    
    A Mono that completes when the session is set
    
    Throws:
    
    IllegalStateException - if the receiver is a non-session receiver.
  - close
```
public void close()
```
    Disposes of the consumer by closing the underlying connection to the service.
    
    Specified by:
    
    close in interface AutoCloseable

Class ServiceBusReceiverAsyncClient

Method Summary

Methods inherited from class java.lang.Object

Method Detail

getFullyQualifiedNamespace

getEntityPath

abandon

abandon

abandon

abandon

complete

complete

defer

defer

defer

defer

deadLetter

deadLetter

deadLetter

deadLetter

getSessionState

peek

peek

peekAt

peekAt

peekBatch

peekBatch

peekBatchAt

peekBatchAt

receive

receive

receiveDeferredMessage

receiveDeferredMessage

receiveDeferredMessageBatch

receiveDeferredMessageBatch

renewMessageLock

renewSessionLock

setSessionState

close