aa71e76eb9
- Add date_added to all 950+ skills for complete tracking - Update version to 6.5.0 in package.json and README - Regenerate all indexes and catalog - Sync all generated files Features from merged PR #150: - Stars/Upvotes system for community-driven discovery - Auto-update mechanism via START_APP.bat - Interactive Prompt Builder - Date tracking badges - Smart auto-categorization All skills validated and indexed. Made-with: Cursor
394 lines
9.9 KiB
Markdown
394 lines
9.9 KiB
Markdown
---
|
|
name: azure-storage-blob-java
|
|
description: "Build blob storage applications with Azure Storage Blob SDK for Java. Use when uploading, downloading, or managing files in Azure Blob Storage, working with containers, or implementing streaming da..."
|
|
risk: unknown
|
|
source: community
|
|
date_added: "2026-02-27"
|
|
---
|
|
|
|
# Azure Storage Blob SDK for Java
|
|
|
|
Build blob storage applications using the Azure Storage Blob SDK for Java.
|
|
|
|
## Installation
|
|
|
|
```xml
|
|
<dependency>
|
|
<groupId>com.azure</groupId>
|
|
<artifactId>azure-storage-blob</artifactId>
|
|
<version>12.33.0</version>
|
|
</dependency>
|
|
```
|
|
|
|
## Client Creation
|
|
|
|
### BlobServiceClient
|
|
|
|
```java
|
|
import com.azure.storage.blob.BlobServiceClient;
|
|
import com.azure.storage.blob.BlobServiceClientBuilder;
|
|
|
|
// With SAS token
|
|
BlobServiceClient serviceClient = new BlobServiceClientBuilder()
|
|
.endpoint("<storage-account-url>")
|
|
.sasToken("<sas-token>")
|
|
.buildClient();
|
|
|
|
// With connection string
|
|
BlobServiceClient serviceClient = new BlobServiceClientBuilder()
|
|
.connectionString("<connection-string>")
|
|
.buildClient();
|
|
```
|
|
|
|
### With DefaultAzureCredential
|
|
|
|
```java
|
|
import com.azure.identity.DefaultAzureCredentialBuilder;
|
|
|
|
BlobServiceClient serviceClient = new BlobServiceClientBuilder()
|
|
.endpoint("<storage-account-url>")
|
|
.credential(new DefaultAzureCredentialBuilder().build())
|
|
.buildClient();
|
|
```
|
|
|
|
### BlobContainerClient
|
|
|
|
```java
|
|
import com.azure.storage.blob.BlobContainerClient;
|
|
|
|
// From service client
|
|
BlobContainerClient containerClient = serviceClient.getBlobContainerClient("mycontainer");
|
|
|
|
// Direct construction
|
|
BlobContainerClient containerClient = new BlobContainerClientBuilder()
|
|
.connectionString("<connection-string>")
|
|
.containerName("mycontainer")
|
|
.buildClient();
|
|
```
|
|
|
|
### BlobClient
|
|
|
|
```java
|
|
import com.azure.storage.blob.BlobClient;
|
|
|
|
// From container client
|
|
BlobClient blobClient = containerClient.getBlobClient("myblob.txt");
|
|
|
|
// With directory structure
|
|
BlobClient blobClient = containerClient.getBlobClient("folder/subfolder/myblob.txt");
|
|
|
|
// Direct construction
|
|
BlobClient blobClient = new BlobClientBuilder()
|
|
.connectionString("<connection-string>")
|
|
.containerName("mycontainer")
|
|
.blobName("myblob.txt")
|
|
.buildClient();
|
|
```
|
|
|
|
## Core Patterns
|
|
|
|
### Create Container
|
|
|
|
```java
|
|
// Create container
|
|
serviceClient.createBlobContainer("mycontainer");
|
|
|
|
// Create if not exists
|
|
BlobContainerClient container = serviceClient.createBlobContainerIfNotExists("mycontainer");
|
|
|
|
// From container client
|
|
containerClient.create();
|
|
containerClient.createIfNotExists();
|
|
```
|
|
|
|
### Upload Data
|
|
|
|
```java
|
|
import com.azure.core.util.BinaryData;
|
|
|
|
// Upload string
|
|
String data = "Hello, Azure Blob Storage!";
|
|
blobClient.upload(BinaryData.fromString(data));
|
|
|
|
// Upload with overwrite
|
|
blobClient.upload(BinaryData.fromString(data), true);
|
|
```
|
|
|
|
### Upload from File
|
|
|
|
```java
|
|
blobClient.uploadFromFile("local-file.txt");
|
|
|
|
// With overwrite
|
|
blobClient.uploadFromFile("local-file.txt", true);
|
|
```
|
|
|
|
### Upload from Stream
|
|
|
|
```java
|
|
import com.azure.storage.blob.specialized.BlockBlobClient;
|
|
|
|
BlockBlobClient blockBlobClient = blobClient.getBlockBlobClient();
|
|
|
|
try (ByteArrayInputStream dataStream = new ByteArrayInputStream(data.getBytes())) {
|
|
blockBlobClient.upload(dataStream, data.length());
|
|
}
|
|
```
|
|
|
|
### Upload with Options
|
|
|
|
```java
|
|
import com.azure.storage.blob.models.BlobHttpHeaders;
|
|
import com.azure.storage.blob.options.BlobParallelUploadOptions;
|
|
|
|
BlobHttpHeaders headers = new BlobHttpHeaders()
|
|
.setContentType("text/plain")
|
|
.setCacheControl("max-age=3600");
|
|
|
|
Map<String, String> metadata = Map.of("author", "john", "version", "1.0");
|
|
|
|
try (InputStream stream = new FileInputStream("large-file.bin")) {
|
|
BlobParallelUploadOptions options = new BlobParallelUploadOptions(stream)
|
|
.setHeaders(headers)
|
|
.setMetadata(metadata);
|
|
|
|
blobClient.uploadWithResponse(options, null, Context.NONE);
|
|
}
|
|
```
|
|
|
|
### Upload if Not Exists
|
|
|
|
```java
|
|
import com.azure.storage.blob.models.BlobRequestConditions;
|
|
|
|
BlobParallelUploadOptions options = new BlobParallelUploadOptions(inputStream, length)
|
|
.setRequestConditions(new BlobRequestConditions().setIfNoneMatch("*"));
|
|
|
|
blobClient.uploadWithResponse(options, null, Context.NONE);
|
|
```
|
|
|
|
### Download Data
|
|
|
|
```java
|
|
// Download to BinaryData
|
|
BinaryData content = blobClient.downloadContent();
|
|
String text = content.toString();
|
|
|
|
// Download to file
|
|
blobClient.downloadToFile("downloaded-file.txt");
|
|
```
|
|
|
|
### Download to Stream
|
|
|
|
```java
|
|
try (ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
|
|
blobClient.downloadStream(outputStream);
|
|
byte[] data = outputStream.toByteArray();
|
|
}
|
|
```
|
|
|
|
### Download with InputStream
|
|
|
|
```java
|
|
import com.azure.storage.blob.specialized.BlobInputStream;
|
|
|
|
try (BlobInputStream blobIS = blobClient.openInputStream()) {
|
|
byte[] buffer = new byte[1024];
|
|
int bytesRead;
|
|
while ((bytesRead = blobIS.read(buffer)) != -1) {
|
|
// Process buffer
|
|
}
|
|
}
|
|
```
|
|
|
|
### Upload via OutputStream
|
|
|
|
```java
|
|
import com.azure.storage.blob.specialized.BlobOutputStream;
|
|
|
|
try (BlobOutputStream blobOS = blobClient.getBlockBlobClient().getBlobOutputStream()) {
|
|
blobOS.write("Data to upload".getBytes());
|
|
}
|
|
```
|
|
|
|
### List Blobs
|
|
|
|
```java
|
|
import com.azure.storage.blob.models.BlobItem;
|
|
|
|
// List all blobs
|
|
for (BlobItem blobItem : containerClient.listBlobs()) {
|
|
System.out.println("Blob: " + blobItem.getName());
|
|
}
|
|
|
|
// List with prefix (virtual directory)
|
|
import com.azure.storage.blob.models.ListBlobsOptions;
|
|
|
|
ListBlobsOptions options = new ListBlobsOptions().setPrefix("folder/");
|
|
for (BlobItem blobItem : containerClient.listBlobs(options, null)) {
|
|
System.out.println("Blob: " + blobItem.getName());
|
|
}
|
|
```
|
|
|
|
### List Blobs by Hierarchy
|
|
|
|
```java
|
|
import com.azure.storage.blob.models.BlobListDetails;
|
|
|
|
String delimiter = "/";
|
|
ListBlobsOptions options = new ListBlobsOptions()
|
|
.setPrefix("data/")
|
|
.setDetails(new BlobListDetails().setRetrieveMetadata(true));
|
|
|
|
for (BlobItem item : containerClient.listBlobsByHierarchy(delimiter, options, null)) {
|
|
if (item.isPrefix()) {
|
|
System.out.println("Directory: " + item.getName());
|
|
} else {
|
|
System.out.println("Blob: " + item.getName());
|
|
}
|
|
}
|
|
```
|
|
|
|
### Delete Blob
|
|
|
|
```java
|
|
blobClient.delete();
|
|
|
|
// Delete if exists
|
|
blobClient.deleteIfExists();
|
|
|
|
// Delete with snapshots
|
|
import com.azure.storage.blob.models.DeleteSnapshotsOptionType;
|
|
blobClient.deleteWithResponse(DeleteSnapshotsOptionType.INCLUDE, null, null, Context.NONE);
|
|
```
|
|
|
|
### Copy Blob
|
|
|
|
```java
|
|
import com.azure.storage.blob.models.BlobCopyInfo;
|
|
import com.azure.core.util.polling.SyncPoller;
|
|
|
|
// Async copy (for large blobs or cross-account)
|
|
SyncPoller<BlobCopyInfo, Void> poller = blobClient.beginCopy("<source-blob-url>", Duration.ofSeconds(1));
|
|
poller.waitForCompletion();
|
|
|
|
// Sync copy from URL (for same account)
|
|
blobClient.copyFromUrl("<source-blob-url>");
|
|
```
|
|
|
|
### Generate SAS Token
|
|
|
|
```java
|
|
import com.azure.storage.blob.sas.*;
|
|
import java.time.OffsetDateTime;
|
|
|
|
// Blob-level SAS
|
|
BlobSasPermission permissions = new BlobSasPermission().setReadPermission(true);
|
|
OffsetDateTime expiry = OffsetDateTime.now().plusDays(1);
|
|
|
|
BlobServiceSasSignatureValues sasValues = new BlobServiceSasSignatureValues(expiry, permissions);
|
|
String sasToken = blobClient.generateSas(sasValues);
|
|
|
|
// Container-level SAS
|
|
BlobContainerSasPermission containerPermissions = new BlobContainerSasPermission()
|
|
.setReadPermission(true)
|
|
.setListPermission(true);
|
|
|
|
BlobServiceSasSignatureValues containerSasValues = new BlobServiceSasSignatureValues(expiry, containerPermissions);
|
|
String containerSas = containerClient.generateSas(containerSasValues);
|
|
```
|
|
|
|
### Blob Properties and Metadata
|
|
|
|
```java
|
|
import com.azure.storage.blob.models.BlobProperties;
|
|
|
|
// Get properties
|
|
BlobProperties properties = blobClient.getProperties();
|
|
System.out.println("Size: " + properties.getBlobSize());
|
|
System.out.println("Content-Type: " + properties.getContentType());
|
|
System.out.println("Last Modified: " + properties.getLastModified());
|
|
|
|
// Set metadata
|
|
Map<String, String> metadata = Map.of("key1", "value1", "key2", "value2");
|
|
blobClient.setMetadata(metadata);
|
|
|
|
// Set HTTP headers
|
|
BlobHttpHeaders headers = new BlobHttpHeaders()
|
|
.setContentType("application/json")
|
|
.setCacheControl("max-age=86400");
|
|
blobClient.setHttpHeaders(headers);
|
|
```
|
|
|
|
### Lease Blob
|
|
|
|
```java
|
|
import com.azure.storage.blob.specialized.BlobLeaseClient;
|
|
import com.azure.storage.blob.specialized.BlobLeaseClientBuilder;
|
|
|
|
BlobLeaseClient leaseClient = new BlobLeaseClientBuilder()
|
|
.blobClient(blobClient)
|
|
.buildClient();
|
|
|
|
// Acquire lease (-1 for infinite)
|
|
String leaseId = leaseClient.acquireLease(60);
|
|
|
|
// Renew lease
|
|
leaseClient.renewLease();
|
|
|
|
// Release lease
|
|
leaseClient.releaseLease();
|
|
```
|
|
|
|
## Error Handling
|
|
|
|
```java
|
|
import com.azure.storage.blob.models.BlobStorageException;
|
|
|
|
try {
|
|
blobClient.download(outputStream);
|
|
} catch (BlobStorageException e) {
|
|
System.out.println("Status: " + e.getStatusCode());
|
|
System.out.println("Error code: " + e.getErrorCode());
|
|
// 404 = Blob not found
|
|
// 409 = Conflict (lease, etc.)
|
|
}
|
|
```
|
|
|
|
## Proxy Configuration
|
|
|
|
```java
|
|
import com.azure.core.http.ProxyOptions;
|
|
import com.azure.core.http.netty.NettyAsyncHttpClientBuilder;
|
|
import java.net.InetSocketAddress;
|
|
|
|
ProxyOptions proxyOptions = new ProxyOptions(
|
|
ProxyOptions.Type.HTTP,
|
|
new InetSocketAddress("localhost", 8888));
|
|
|
|
BlobServiceClient client = new BlobServiceClientBuilder()
|
|
.endpoint("<endpoint>")
|
|
.sasToken("<sas-token>")
|
|
.httpClient(new NettyAsyncHttpClientBuilder().proxy(proxyOptions).build())
|
|
.buildClient();
|
|
```
|
|
|
|
## Environment Variables
|
|
|
|
```bash
|
|
AZURE_STORAGE_CONNECTION_STRING=DefaultEndpointsProtocol=https;AccountName=...
|
|
AZURE_STORAGE_ACCOUNT_URL=https://<account>.blob.core.windows.net
|
|
```
|
|
|
|
## Trigger Phrases
|
|
|
|
- "Azure Blob Storage Java"
|
|
- "upload download blob"
|
|
- "blob container SDK"
|
|
- "storage streaming"
|
|
- "SAS token generation"
|
|
- "blob metadata properties"
|
|
|
|
## When to Use
|
|
This skill is applicable to execute the workflow or actions described in the overview.
|