The Spec for Azure Storage - File & Queue Java Library Track 2 Preview

authoring-guidelines.md

Storage Track 2 Preview Authoring Guidelines

• There should be 4 clients created for each generated client, sync client, raw sync client, async client, and raw async client.
• Normal clients should have private constructors that take the raw client and a builder. Raw clients should have package private constructors and no builders (cannot be instantiated by user).
• Raw client methods should return Response<T> or VoidResponse. Corresponding normal client methods should return T or void.
• Raw client methods should take Context context as the last parameter.
• Raw sync client should take Timeout timeout, Context context as the last 2 parameters.
• Normal client methods should return a hand-written object type containing aggregated non-trivial information from the AutoRest generated response headers and body. Headers like Content-Length, x-ms-request-id, x-ms-version, x-ms-error-code, Date, etc should not be part of the response type T. If there are no such headers, this method should return void.
• In uploadFromXXX() and downloadToXXX() methods, file paths should be of type String.

file_spec.md

Azure Storage - File Java Library Track 2 Preview

Table of Contents

• Clients
  • ShareAsyncClient
  • ShareAsyncRawClient
  • ShareClient
  • ShareRawClient
  • DirectoryAsyncClient
  • DirectoryAsyncRawClient
  • DirectoryClient
  • DirectoryRawClient
  • FileAsyncClient
  • FileAsyncRawClient
  • FileClient
  • FileRawClient
• Samples
  • Create and upload a file in a new share

Clients

ShareAsyncClient

public class ShareAsyncClient {
  // private constructor
  private ShareAsyncClient(ShareAsyncRawClient rawClient);

  // builder
  public static ShareAsyncClientBuilder builder();

  // get raw client
  public ShareAsyncRawClient getRawClient();
  
  // create DirectoryClient
  public DirectoryAsyncClient getDirectoryClient(String directoryName);
  
  // client methods
  public Mono<Share> create();
  
  public Mono<ShareProperties> getProperties();
  
  public Mono<Void> delete();
  
  public Mono<ShareSnapshot> createSnapshot();
  public Mono<ShareSnapshot> createSnapshot(Map<String, String> metadata);
  
  public Mono<Share> setQuota(int quotaInGB);
  
  public Mono<Share> setMetadata(Map<String, String> metadata);
  
  public Flux<SignedIdentifier> getAccessPolicy();
  
  public Mono<Share> setAccessPolicy(List<SignedIdentifier> permissions);
  
  public Mono<ShareStats> getStatistics();
}

public class ShareAsyncClientBuilder {
  // contructor
  public ShareAsyncClientBuilder();
  // setters
  public ShareAsyncClientBuilder endpoint(String endpoint);
  public ShareAsyncClientBuilder credentials(SharedKeyCredentials credentials);
  public ShareAsyncClientBuilder connectionString(String connectionString);
  public ShareAsyncClientBuilder httpClient(HttpClient httpClient);
  public ShareAsyncClientBuilder addPolicy(HttpPipelinePolicy pipelinePolicy);
  public ShareAsyncClientBuilder httpLogDetailLevel(HttpLogDetailLevel logLevel);
  // build
  public ShareAsyncClient build();
}

ShareAsyncRawClient

public class ShareAsyncRawClient extends ServiceClient {
  // private constructor
  ShareAsyncRawClient(URL endpoint, HttpPipeline httpPipeline);
  
  // create DirectoryClient
  public DirectoryAsyncRawClient getDirectoryClient(String directoryName);
  
  // client methods
  public Mono<Response<Share>> create(Context context);
  
  public Mono<Response<ShareProperties>> getProperties(Context context);
  
  public Mono<VoidResponse> delete(Context context);
  
  public Mono<Response<ShareSnapshot>> createSnapshot(Map<String, String> metadata, Context context);
  
  public Mono<Response<Share>> setQuota(int quotaInGB, Context context);
  
  public Mono<Response<Share>> setMetadata(Map<String, String> metadata);
  
  public Flux<SignedIdentifier> getAccessPolicy(Context context);
  
  public Mono<Response<Share>> setAccessPolicy(List<SignedIdentifier> permissions, Context context);
  
  public Mono<Response<ShareStats>> getStatistics(Context context);
}

ShareClient

public class ShareClient {
  // private constructor
  ShareClient(ShareRawClient rawClient);
  
  // builder
  public static ShareClientBuilder builder();

  // get raw client
  public ShareRawClient getRawClient();
  
  // create DirectoryClient
  public DirectoryClient getDirectoryClient(String directoryName);
  
  // client methods
  public Share create();
  
  public ShareProperties getProperties();
  
  public void delete();
  
  public ShareSnapshot createSnapshot();
  public ShareSnapshot createSnapshot(Map<String, String> metadata);
  
  public Share setQuota(int quotaInGB);
  
  public Share setMetadata(Map<String, String> metadata);
  
  public List<SignedIdentifier> getAccessPolicy();
  
  public Share setAccessPolicy(List<SignedIdentifier> permissions);
  
  public ShareStats getStatistics();
}

public class ShareClientBuilder {
  // contructor
  public ShareClientBuilder();
  // setters
  public ShareClientBuilder endpoint(String endpoint);
  public ShareClientBuilder credentials(SharedKeyCredentials credentials);
  public ShareClientBuilder connectionString(String connectionString);
  public ShareClientBuilder httpClient(HttpClient httpClient);
  public ShareClientBuilder addPolicy(HttpPipelinePolicy pipelinePolicy);
  public ShareClientBuilder httpLogDetailLevel(HttpLogDetailLevel logLevel);
  // build
  public ShareClient build();
}

ShareRawClient

public class ShareRawClient {
  // private constructor
  ShareRawClient(ShareAsyncRawClient asyncClient);
  
  // create DirectoryClient
  public DirectoryRawClient getDirectoryClient(String directoryName);
  
  // client methods
  public Response<Share> create(Duration timeout, Context context);
  
  public Response<ShareProperties> getProperties(Duration timeout, Context context);
  
  public VoidResponse delete(Duration timeout, Context context);
  
  public Response<ShareSnapshot> createSnapshot(Map<String, String> metadata, Duration timeout, Context context);
  
  public Response<Share> setQuota(int quotaInGB, Duration timeout, Context context);
  
  public Response<Share> setMetadata(Map<String, String> metadata);
  
  public List<SignedIdentifier> getAccessPolicy(Duration timeout, Context context);
  
  public Response<Share> setAccessPolicy(List<SignedIdentifier> permissions, Duration timeout, Context context);
  
  public Response<ShareStats> getStatistics(Duration timeout, Context context);
}

DirectoryAsyncClient

public class DirectoryAsyncClient {
  // private constructor
  private DirectoryAsyncClient(DirectoryAsyncRawClient rawClient);
  
  // builder
  public static DirectoryAsyncClientBuilder builder();

  // get raw client
  public DirectoryAsyncRawClient getRawClient();
  
  // create DirectoryClient & FileClient
  public DirectoryAsyncClient getDirectoryClient(String directoryName);
  public FileAsyncClient getFileClient(String fileName);
  
  // client methods
  public Mono<Directory> create();
  
  public Mono<DirectoryProperties> getProperties();
  
  public Mono<Void> delete();
  
  public Mono<Directory> setMetadata(Map<String, String> metadata);
  
  public Flux<FileRef> listFiles(String prefix); // Lists all files and dirs but FileRef:isDirectory() will be true for dirs
  
  public Flux<HandleItem> listHandles();
  
  public Flux<Integer> forceCloseHandles(String handleId); // this is a paged operation, each response returning the number of handles closed
}

public class DirectoryAsyncClientBuilder {
  // contructor
  public DirectoryAsyncClientBuilder();
  // setters
  public DirectoryAsyncClientBuilder endpoint(String endpoint);
  public DirectoryAsyncClientBuilder credentials(SharedKeyCredentials credentials);
  public DirectoryAsyncClientBuilder connectionString(String connectionString);
  public DirectoryAsyncClientBuilder httpClient(HttpClient httpClient);
  public DirectoryAsyncClientBuilder addPolicy(HttpPipelinePolicy pipelinePolicy);
  public DirectoryAsyncClientBuilder httpLogDetailLevel(HttpLogDetailLevel logLevel);
  public DirectoryAsyncClientBuilder shareSnapshot(String shareSnapshot);
  // build
  public DirectoryAsyncClient build();
}

DirectoryAsyncRawClient

public class DirectoryAsyncRawClient extends ServiceClient {
  // package private constructor
  DirectoryAsyncRawClient(URL endpoint, HttpPipeline httpPipeline);

  // create DirectoryClient & FileClient
  public DirectoryAsyncRawClient getDirectoryClient(String directoryName);
  public FileAsyncRawClient getFileClient(String fileName);
  
  // client methods
  public Mono<Response<Directory>> create(Context context);
  
  public Mono<Response<DirectoryProperties>> getProperties(Context context);
  
  public Mono<VoidResponse> delete(Context context);
  
  public Mono<Response<Directory>> setMetadata(Map<String, String> metadata, Context context);
  
  public Flux<FileRef> listFiles(String prefix, Context context); // Lists all files and dirs but FileRef:isDirectory() will be true for dirs
  
  public Flux<HandleItem> listHandles(Context context);
  
  public Flux<Integer> forceCloseHandles(String handleId, Context context); // this is a paged operation, each response returning the number of handles closed
  public Flux<Integer> forceCloseHandles(HandleItem handleItem, Context context); // this is a paged operation, each response returning the number of handles closed
}

DirectoryClient

public class DirectoryClient {
  // private constructor
  private DirectoryClient(DirectoryRawClient rawClient);
  
  // builder
  public static DirectoryClientBuilder builder();

  // get raw client
  public DirectoryRawClient getRawClient();
  
  // create DirectoryClient & FileClient
  public DirectoryClient getDirectoryClient(String directoryName);
  public FileClient getFileClient(String fileName);
  
  // client methods
  public Directory create();
  
  public DirectoryProperties getProperties();
  
  public void delete();
  
  public Directory setMetadata(Map<String, String> metadata);
  
  public List<FileRef> listFiles(String prefix); // Lists all files and dirs but FileRef:isDirectory() will be true for dirs
  
  public List<HandleItem> listHandles();
  
  public List<Integer> forceCloseHandles(String handleId); // this is a paged operation, each response returning the number of handles closed
}

public class DirectoryClientBuilder {
  // contructor
  public DirectoryClientBuilder();
  // setters
  public DirectoryClientBuilder endpoint(String endpoint);
  public DirectoryClientBuilder credentials(SharedKeyCredentials credentials);
  public DirectoryClientBuilder connectionString(String connectionString);
  public DirectoryClientBuilder httpClient(HttpClient httpClient);
  public DirectoryClientBuilder addPolicy(HttpPipelinePolicy pipelinePolicy);
  public DirectoryClientBuilder httpLogDetailLevel(HttpLogDetailLevel logLevel);
  public DirectoryClientBuilder shareSnapshot(String shareSnapshot);
  // build
  public DirectoryClient build();
}

DirectoryRawClient

public class DirectoryRawClient {
  // package private constructor
  DirectoryRawClient(DirectoryAsyncRawClient asyncClient);

  // create DirectoryClient & FileClient
  public DirectoryRawClient getDirectoryClient(String directoryName);
  public FileRawClient getFileClient(String fileName);
  
  // client methods
  public Response<Directory> create(Duration timeout, Context context);
  
  public Response<DirectoryProperties> getProperties(Duration timeout, Context context);
  
  public VoidResponse delete(Duration timeout, Context context);
  
  public Response<Directory> setMetadata(Map<String, String> metadata, Duration timeout, Context context);
  
  public List<FileRef> listFiles(String prefix, Duration timeout, Context context); // Lists all files and dirs but FileRef:isDirectory() will be true for dirs
  
  public List<HandleItem> listHandles(Duration timeout, Context context);
  
  public List<Integer> forceCloseHandles(String handleId, Duration timeout, Context context); // this is a paged operation, each response returning the number of handles closed
  public List<Integer> forceCloseHandles(HandleItem handleItem, Duration timeout, Context context); // this is a paged operation, each response returning the number of handles closed
}

FileAsyncClient

public class FileAsyncClient {
  // private constructor
  private FileAsyncClient(FileAsyncRawClient rawClient);
  
  // builder
  public static FileAsyncClientBuilder builder();

  // get raw client
  public FileAsyncRawClient getRawClient();
  
  // client methods
  public Mono<File> create(long fileContentLength);
  
  public Flux<ByteBuffer> download();

  public Mono<FileDownloadInfo> downloadWithProperties(FileRange range, boolean rangeGetContentMD5, Context context);

  public Mono<Void> downloadToFile(String saveLocation);
  public Mono<Void> downloadToFile(String saveLocation, FileRange range, boolean rangeGetContentMD5, Context context);
  
  public Mono<FileProperties> getProperties();
  
  public Mono<Void> delete();
  
  // TODO: Clarify what this method does
  public Mono<File> setHttpHeaders(long fileContentLength, FileHTTPHeaders fileHTTPHeaders);
  
  public Mono<File> setMetadata(Map<String, String> metadata);

  public Mono<File> upload(Flux<ByteBuffer> data, long length);
  public Mono<File> upload(Flux<ByteBuffer> data, long length, FileRange range, FileRangeWriteType fileRangeWrite);

  public Mono<File> uploadFromFile(String pathToFile);
  public Mono<File> uploadFromFile(String pathToFile, FileRange range, FileRangeWriteType fileRangeWrite);

  public Flux<Range> listRanges();
  public Flux<Range> listRanges(FileRange range);
  
  // TODO: Is this Long Running Operation?
  public Mono<FileStartCopyInfo> startCopy(String copySource);
  
  public Mono<File> abortCopy(String copyId);
  
  public Flux<HandleItem> listHandles();
  
  public Flux<Integer> forceCloseHandles(String handleId); // this is a paged operation, each response returning the number of handles closed
}

public class FileAsyncClientBuilder {
  // contructor
  public FileAsyncClientBuilder();
  // setters
  public FileAsyncClientBuilder endpoint(String endpoint);
  public FileAsyncClientBuilder credentials(SharedKeyCredentials credentials);
  public FileAsyncClientBuilder connectionString(String connectionString);
  public FileAsyncClientBuilder httpClient(HttpClient httpClient);
  public FileAsyncClientBuilder addPolicy(HttpPipelinePolicy pipelinePolicy);
  public FileAsyncClientBuilder httpLogDetailLevel(HttpLogDetailLevel logLevel);
  public FileAsyncClientBuilder shareSnapshot(String shareSnapshot);
  // build
  public FileAsyncClient build();
}

FileAsyncRawClient

public class FileAsyncRawClient extends ServiceClient {
  // package private constructor
  FileAsyncRawClient(URL endpoint, HttpPipeline httpPipeline);
  
  // builder
  public static FileAsyncClientBuilder builder();
  
  // client methods
  public Mono<Response<File>> create(long fileContentLength, Context context);
  
  public Flux<ByteBuffer> download(FileRange range, boolean rangeGetContentMD5, Context context);

  public Mono<Response<FileDownloadInfo>> downloadWithProperties(FileRange range, boolean rangeGetContentMD5, Context context);

  public Mono<VoidResponse> downloadToFile(String saveLocation, FileRange range, boolean rangeGetContentMD5, Context context);
  
  public Mono<Response<FileProperties>> getProperties(Context context);
  
  public Mono<VoidResponse> delete(Context context);
  
  // TODO: Clarify what this method does
  public Mono<Response<File>> setHttpHeaders(long fileContentLength, FileHTTPHeaders fileHTTPHeaders, Context context);
  
  public Mono<Response<File>> setMetadata(Map<String, String> metadata, Context context);
  
  public Mono<Response<File>> upload(Flux<ByteBuffer> data, long length, FileRange range, FileRangeWriteType fileRangeWrite, Context context); 

  public Mono<Response<File>> uploadFromFile(String path, FileRange range, FileRangeWriteType fileRangeWrite, Context context); 
  
  public Flux<Range> listRanges(Context context);
  public Flux<Range> listRanges(FileRange range, Context context);
  
  // TODO: Is this Long Running Operation?
  public Mono<Response<FileStartCopyInfo>> startCopy(String copySource, Context context);
  
  public Mono<Response<File>> abortCopy(String copyId, Context context);
  
  public Flux<HandleItem> listHandles(Context context);
  
  public Flux<Integer> forceCloseHandles(String handleId, Context context); // this is a paged operation, each response returning the number of handles closed
  public Flux<Integer> forceCloseHandles(HandleItem handleItem, Context context); // this is a paged operation, each response returning the number of handles closed
}

FileClient

public class FileClient {
  // private constructor
  private FileClient(FileRawClient rawClient);
  
  // builder
  public static FileClientBuilder builder();

  // get raw client
  public FileRawClient getRawClient();
  
  // client methods
  public File create(long fileContentLength);
  
  public void download(OutputStream outStream);
  public void download(OutputStream outStream, FileRange range, boolean rangeGetContentMD5);

  public void downloadToFile(String saveLocation);
  public void downloadToFile(String saveLocation, FileRange range, boolean rangeGetContentMD5);

  public void downloadToByteArray(byte[] buffer, long bufferOffset);
  public void downloadToByteArray(byte[] buffer, long bufferOffset, FileRange range, boolean rangeGetContentMD5);
  
  public FileProperties getProperties();
  
  public void delete();
  
  // TODO: Clarify what this method does
  public File setHttpHeaders(long fileContentLength, FileHTTPHeaders fileHTTPHeaders);
  
  public File setMetadata(Map<String, String> metadata);

  public File upload(InputStream data, long length);
  public File upload(InputStream data, long length, FileRange range, FileRangeWriteType fileRangeWrite);

  public File uploadFromFile(String pathToFile);
  public File uploadFromFile(String pathToFile, FileRange range, FileRangeWriteType fileRangeWrite);

  public File uploadFromByteArray(byte[] data);
  public File uploadFromByteArray(byte[] data, long offset, long length, FileRange range, FileRangeWriteType fileRangeWrite);
  
  public List<Range> listRanges();
  public List<Range> listRanges(FileRange range);
  
  // TODO: Is this Long Running Operation?
  public FileStartCopyInfo startCopy(String copySource);
  
  public File abortCopy(String copyId);
  
  public List<HandleItem> listHandles();
  
  public List<Integer> forceCloseHandles(String handleId); // this is a paged operation, each response returning the number of handles closed
}

public class FileClientBuilder {
  // contructor
  public FileClientBuilder();
  // setters
  public FileClientBuilder endpoint(String endpoint);
  public FileClientBuilder credentials(SharedKeyCredentials credentials);
  public FileClientBuilder connectionString(String connectionString);
  public FileClientBuilder httpClient(HttpClient httpClient);
  public FileClientBuilder addPolicy(HttpPipelinePolicy pipelinePolicy);
  public FileClientBuilder httpLogDetailLevel(HttpLogDetailLevel logLevel);
  public FileClientBuilder shareSnapshot(String shareSnapshot);
  // build
  public FileClient build();
}

FileRawClient

public class FileRawClient {
  // package private constructor
  FileRawClient(FileAsyncRawClient asyncClient);
  
  // builder
  public static FileClientBuilder builder();
  
  // client methods
  public Response<File> create(long fileContentLength, Duration timeout, Context context);
  
  public void download(OutputStream outStream, FileRange range, boolean rangeGetContentMD5, Duration timeout, Context context);

  public Response<FileDownloadInfo> downloadWithProperties(FileRange range, boolean rangeGetContentMD5, Duration timeout, Context context);

  public VoidResponse downloadToFile(String saveLocation, FileRange range, boolean rangeGetContentMD5, Duration timeout, Context context);

  public void downloadToByteArray(byte[] buffer, long bufferOffset, FileRange range, boolean rangeGetContentMD5, Duration timeout, Context context);
  
  public Response<FileProperties> getProperties(Duration timeout, Context context);
  
  public VoidResponse delete(Duration timeout, Context context);
  
  // TODO: Clarify what this method does
  public Response<File> setHttpHeaders(long fileContentLength, FileHTTPHeaders fileHTTPHeaders, Duration timeout, Context context);
  
  public Response<File> setMetadata(Map<String, String> metadata, Duration timeout, Context context);
  
  public Response<File> upload(InputStream data, long length, FileRange range, FileRangeWriteType fileRangeWrite, Duration timeout, Context context); 
  public Response<File> uploadFromFile(String path, FileRange range, FileRangeWriteType fileRangeWrite, Duration timeout, Context context); 
  public Response<File> uploadFromByteArray(byte[] data, long offset, long length, FileRange range, FileRangeWriteType fileRangeWrite, Duration timeout, Context context); 
    
  public List<Range> listRanges(Duration timeout, Context context);
  public List<Range> listRanges(FileRange range, Duration timeout, Context context);
  
  // TODO: Is this Long Running Operation?
  public Response<FileStartCopyInfo> startCopy(String copySource, Duration timeout, Context context);
  
  public Response<File> abortCopy(String copyId, Duration timeout, Context context);
  
  public List<HandleItem> listHandles(Duration timeout, Context context);
  
  public List<Integer> forceCloseHandles(String handleId, Duration timeout, Context context); // this is a paged operation, each response returning the number of handles closed
  public List<Integer> forceCloseHandles(HandleItem handleItem, Duration timeout, Context context); // this is a paged operation, each response returning the number of handles closed
}

Samples

Create and upload a file in a new share

String shareName = getShareName();
String directoryName = getDirectoryName();
String fileName = getFileName();
Path localFileToUpload = getFilePath();

// create a share
ShareClient shareClient = ShareClient.builder()
  .endpoint("myaccount.file.core.windows.net/" + shareName)
  .credentials(createCredentials())
  .build();
// This method actually creates the share that the URL on the ShareClient represents
Share share = shareClient.create();

// create a directory
DirectoryClient dirClient = shareClient.getDirectoryClient(directoryName);
dirClient.create();

// create a file
FileClient fileClient = dirClient.getFileClient(fileName);
fileClient.create();

// upload the local file
File file = fileClient.uploadFromFile(localFileToUpload);

// download the file to a byte array
FileProperties properties = fileClient.getProperties();
byte[] data = new byte[properties.contentLength()];
fileClient.downloadToByteArray(data, 0);

queue_spec.md

Azure Storage - Queue Java Library Track 2 Preview

Table of Contents

• Clients
  • QueueAsyncClient
  • QueueAsyncRawClient
  • QueueClient
  • QueueRawClient
  • MessagesAsyncClient
  • MessagesAsyncRawClient
  • MessagesClient
  • MessagesRawClient
  • MessageIdAsyncClient
  • MessageIdAsyncRawClient
  • MessageIdClient
  • MessageIdRawClient
• Samples
  • Create a queue and enqueue a message

Clients

QueueAsyncClient

public class QueueAsyncClient {
  // private constructor
  private QueueAsyncClient(QueueAsyncRawClient rawClient);

  // builder
  public static QueueAsyncClientBuilder builder();

  // get raw client
  public QueueAsyncRawClient getRawClient();

  // create MessagesClient
  public MessagesAsyncClient getMessagesClient();

  // client methods
  public Mono<Void> create();

  public Mono<Void> delete();

  public Mono<QueueProperties> getProperties();

  public Mono<Void> setMetadata(Map<String, String> metadata);

  public Flux<SignedIdentifier> getAccessPolicy();

  public Mono<Void> setAccessPolicy(List<SignedIdentifier> permissions);
}

public class QueueAsyncClientBuilder {
  // contructor
  public QueueAsyncClientBuilder();
  // setters
  public QueueAsyncClientBuilder endpoint(String endpoint);
  public QueueAsyncClientBuilder credentials(SharedKeyCredentials credentials);
  public QueueAsyncClientBuilder connectionString(String connectionString);
  public QueueAsyncClientBuilder httpClient(HttpClient httpClient);
  public QueueAsyncClientBuilder addPolicy(HttpPipelinePolicy pipelinePolicy);
  public QueueAsyncClientBuilder httpLogDetailLevel(HttpLogDetailLevel logLevel);
  // build
  public QueueAsyncClient build();
}

QueueAsyncRawClient

public class QueueAsyncRawClient extends ServiceClient {
  // package private constructor
  QueueAsyncRawClient(URL endpoint, HttpPipeline httpPipeline);

  // create MessagesClient
  public MessagesAsyncRawClient getMessagesClient();

  // client methods
  public Mono<VoidResponse> create(Context context);

  public Mono<VoidResponse> delete(Context context);

  public Mono<Response<QueueProperties>> getProperties(Context context);

  public Mono<VoidResponse> setMetadata(Map<String, String> metadata, Context context);

  public Flux<SignedIdentifier> getAccessPolicy(Context context);

  public Mono<VoidResponse> setAccessPolicy(List<SignedIdentifier> permissions, Context context);
}

QueueClient

public class QueueClient {
  // private constructor
  private QueueClient(QueueRawClient rawClient);

  // builder
  public static QueueClientBuilder builder();

  // get raw client
  public QueueRawClient getRawClient();

  // create MessagesClient
  public MessagesClient getMessagesClient();

  // client methods
  public Void create();

  public Void delete();

  public QueueProperties getProperties();

  public Void setMetadata(Map<String, String> metadata);

  public List<SignedIdentifier> getAccessPolicy();

  public Void setAccessPolicy(List<SignedIdentifier> permissions);
}

public class QueueClientBuilder {
  // contructor
  public QueueClientBuilder();
  // setters
  public QueueClientBuilder endpoint(String endpoint);
  public QueueClientBuilder credentials(SharedKeyCredentials credentials);
  public QueueClientBuilder connectionString(String connectionString);
  public QueueClientBuilder httpClient(HttpClient httpClient);
  public QueueClientBuilder addPolicy(HttpPipelinePolicy pipelinePolicy);
  public QueueClientBuilder httpLogDetailLevel(HttpLogDetailLevel logLevel);
  // build
  public QueueClient build();
}

QueueRawClient

public class QueueRawClient {
  // package private constructor
  QueueRawClient(QueueAsyncRawClient asyncClient);

  // create MessagesClient
  public MessagesRawClient getMessagesClient();

  // client methods
  public VoidResponse create(Duration timeout, Context context);

  public VoidResponse delete(Duration timeout, Context context);

  public Response<QueueProperties> getProperties(Duration timeout, Context context);

  public VoidResponse setMetadata(Map<String, String> metadata, Duration timeout, Context context);

  public List<SignedIdentifier> getAccessPolicy(Duration timeout, Context context);

  public VoidResponse setAccessPolicy(List<SignedIdentifier> permissions, Duration timeout, Context context);
}

MessagesAsyncClient

public class MessagesAsyncClient {
  // private constructor
  private MessagesAsyncClient(MessagesRawClient rawClient);

  // builder
  public static MessagesAsyncClientBuilder builder();

  // get raw client
  public MessagesRawClient getRawClient();

  // create MessageIdClient
  public MessageIdAsyncClient getMessageIdClient(String messageId);

  // client methods
  public Flux<EnqueuedMessage> enqueue(QueueMessage queueMessage);

  public Flux<DequeuedMessageItem> dequeue(int numberOfMessages);

  public Flux<PeekedMessageItem> peek(int numberOfMessages);

  public Mono<Void> clear();
}

public class MessagesAsyncClientBuilder {
  // contructor
  public MessagesAsyncClientBuilder();
  // setters
  public MessagesAsyncClientBuilder endpoint(String endpoint);
  public MessagesAsyncClientBuilder credentials(SharedKeyCredentials credentials);
  public MessagesAsyncClientBuilder connectionString(String connectionString);
  public MessagesAsyncClientBuilder httpClient(HttpClient httpClient);
  public MessagesAsyncClientBuilder addPolicy(HttpPipelinePolicy pipelinePolicy);
  public MessagesAsyncClientBuilder httpLogDetailLevel(HttpLogDetailLevel logLevel);
  // build
  public MessagesAsyncClient build();
}

MessagesAsyncRawClient

public class MessagesAsyncRawClient extends ServiceClient {
  // package private constructor
  MessagesAsyncRawClient(URL endpoint, HttpPipeline httpPipeline);

  // create MessageIdClient
  public MessageIdAsyncRawClient getMessageIdClient(String messageId);

  // client methods
  public Flux<EnqueuedMessage> enqueue(QueueMessage queueMessage, Context context);

  public Flux<DequeuedMessageItem> dequeue(int numberOfMessages, Context context);

  public Flux<PeekedMessageItem> peek(int numberOfMessages, Context context);

  public Mono<VoidResponse> clear(Context context);
}

MessagesClient

public class MessagesClient {
  // private constructor
  private MessagesClient(MessagesRawClient rawClient);

  // builder
  public static MessagesClientBuilder builder();

  // get raw client
  public MessagesRawClient getRawClient();

  // create MessageIdClient
  public MessageIdClient getMessageIdClient(String messageId);

  // client methods
  public List<EnqueuedMessage> enqueue(QueueMessage queueMessage);

  public List<DequeuedMessageItem> dequeue(int numberOfMessages);

  public List<PeekedMessageItem> peek(int numberOfMessages);

  public void clear();
}

public class MessagesClientBuilder {
  // contructor
  public MessagesClientBuilder();
  // setters
  public MessagesClientBuilder endpoint(String endpoint);
  public MessagesClientBuilder credentials(SharedKeyCredentials credentials);
  public MessagesClientBuilder connectionString(String connectionString);
  public MessagesClientBuilder httpClient(HttpClient httpClient);
  public MessagesClientBuilder addPolicy(HttpPipelinePolicy pipelinePolicy);
  public MessagesClientBuilder httpLogDetailLevel(HttpLogDetailLevel logLevel);
  // build
  public MessagesClient build();
}

MessagesRawClient

public class MessagesRawClient {
  // package private constructor
  MessagesRawClient(MessagesAsyncRawClient asyncClient);

  // create MessageIdClient
  public MessageIdRawClient getMessageIdClient(String messageId);

  // client methods
  public List<EnqueuedMessage> enqueue(QueueMessage queueMessage, Duration timeout, Context context);

  public List<DequeuedMessageItem> dequeue(int numberOfMessages, Duration timeout, Context context);

  public List<PeekedMessageItem> peek(int numberOfMessages, Duration timeout, Context context);

  public VoidResponse clear(Duration timeout, Context context);
}

MessageIdAsyncClient

public class MessageIdAsyncClient {
  // private constructor
  private MessageIdAsyncClient(MessageIdAsyncRawClient rawClient);

  // builder
  public static MessageIdAsyncClientBuilder builder();

  // get raw client
  public MessageIdAsyncRawClient getRawClient();

  // client methods
  public Mono<UpdatedMessage> update(QueueMessage queueMessage, String popReceipt, int visibilityTimeout);

  public Mono<Void> delete(String popReceipt);
}

public class MessageIdAsyncClientBuilder {
  // contructor
  public MessageIdAsyncClientBuilder();
  // setters
  public MessageIdAsyncClientBuilder endpoint(String endpoint);
  public MessageIdAsyncClientBuilder credentials(SharedKeyCredentials credentials);
  public MessageIdAsyncClientBuilder connectionString(String connectionString);
  public MessageIdAsyncClientBuilder httpClient(HttpClient httpClient);
  public MessageIdAsyncClientBuilder addPolicy(HttpPipelinePolicy pipelinePolicy);
  public MessageIdAsyncClientBuilder httpLogDetailLevel(HttpLogDetailLevel logLevel);
  public MessageIdAsyncClientBuilder serverTimeout(Duration timeout);
  // build
  public MessageIdAsyncClient build();
}

MessageIdAsyncRawClient

public class MessageIdAsyncRawClient extends ServiceClient {
  // package private constructor
  MessageIdAsyncRawClient(URL endpoint, HttpPipeline httpPipeline);

  // client methods
  public Mono<Response<UpdatedMessage>> update(QueueMessage queueMessage, String popReceipt, int visibilityTimeout, Context context);

  public Mono<VoidResponse> delete(String popReceipt, Context context);
}

MessageIdClient

public class MessageIdClient {
  // private constructor
  private MessageIdClient(MessageIdRawClient rawClient);

  // builder
  public static MessageIdClientBuilder builder();

  // get raw client
  public MessageIdRawClient getRawClient();

  // client methods
  public UpdatedMessage update(QueueMessage queueMessage, String popReceipt, int visibilityTimeout);

  public void delete(String popReceipt);
}

public class MessageIdClientBuilder {
  // contructor
  public MessageIdClientBuilder();
  // setters
  public MessageIdClientBuilder endpoint(String endpoint);
  public MessageIdClientBuilder credentials(SharedKeyCredentials credentials);
  public MessageIdClientBuilder connectionString(String connectionString);
  public MessageIdClientBuilder httpClient(HttpClient httpClient);
  public MessageIdClientBuilder addPolicy(HttpPipelinePolicy pipelinePolicy);
  public MessageIdClientBuilder httpLogDetailLevel(HttpLogDetailLevel logLevel);
  public MessageIdClientBuilder serverTimeout(Duration timeout);
  // build
  public MessageIdClient build();
}

MessageIdRawClient

public class MessageIdRawClient {
  // package private constructor
  MessageIdRawClient(MessageIdAsyncRawClient asyncClient);

  // client methods
  public Response<UpdatedMessage> update(QueueMessage queueMessage, String popReceipt, int visibilityTimeout, Duration timeout, Context context);

  public VoidResponse delete(String popReceipt, Duration timeout, Context context);
}

Samples

Create a queue and enqueue a message

String queueName = getQueueName();
String messageText = getMessageText();

// create a queue
QueueClient queuClient = QueueClient.builder()
  .endpoint("myaccount.queue.core.windows.net/" + queueName)
  .credentials(createCredentials())
  .build();
// This method actually creates the share that the URL on the ShareClient represents
queueClient.create();

// enqueue a message
MessagesClient messagesClient = queuClient.getMessagesClient(directoryName);
List<EnqueuedMessage> enqueuedMessages = messagesClient.enqueue(new QueueMessage().messageText(messageText));

Storage clients uses a different object model from most services like KeyVault. In most cases, you have a FooClient who can access all foos in an account:

public class FooClient {
  Mono<Foo> createFoo(Foo foo);
  Mono<Foo> getFoo(String name);
  Mono<Foo> deleteFoo(String name);
}

But in Storage, a QueueClient can can only work with one Queue as the base URL contains the ID of the queue. Same applies to Messages, Blob, etc. If I have to interact with 100 messages, I have to create 100 MessageIdsAsyncClient.

It's possible to wrap this model in a client like

public class QueueClient {
  Mono<QueueCreateResponse> createQueue(QueueCreateRequest createRequest);
  Mono<QueueDeleteResponse> deleteQueue(String name);
  MessagesClient createMessagesClient(String name);
}

public class MessagesClient {
  Mono<MessagesEnqueueResponse> enqueue(QueueMessage queueMessage);
}