sickn33/antigravity-awesome-skills/azure-storage-blob-java

<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-storage-blob</artifactId>
    <version>12.33.0</version>
</dependency>

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();

import com.azure.identity.DefaultAzureCredentialBuilder;
 
BlobServiceClient serviceClient = new BlobServiceClientBuilder()
    .endpoint("<storage-account-url>")
    .credential(new DefaultAzureCredentialBuilder().build())
    .buildClient();

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();

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();

// Create container
serviceClient.createBlobContainer("mycontainer");
 
// Create if not exists
BlobContainerClient container = serviceClient.createBlobContainerIfNotExists("mycontainer");
 
// From container client
containerClient.create();
containerClient.createIfNotExists();

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);

blobClient.uploadFromFile("local-file.txt");
 
// With overwrite
blobClient.uploadFromFile("local-file.txt", true);

import com.azure.storage.blob.specialized.BlockBlobClient;
 
BlockBlobClient blockBlobClient = blobClient.getBlockBlobClient();
 
byte[] utf8 = data.getBytes(java.nio.charset.StandardCharsets.UTF_8);
try (ByteArrayInputStream dataStream = new ByteArrayInputStream(utf8)) {
    blockBlobClient.upload(dataStream, utf8.length);
}

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);
}

import com.azure.storage.blob.models.BlobRequestConditions;
 
BlobParallelUploadOptions options = new BlobParallelUploadOptions(inputStream, length)
    .setRequestConditions(new BlobRequestConditions().setIfNoneMatch("*"));
 
blobClient.uploadWithResponse(options, null, Context.NONE);

// Download to BinaryData
BinaryData content = blobClient.downloadContent();
String text = content.toString();
 
// Download to file
blobClient.downloadToFile("downloaded-file.txt");

try (ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
    blobClient.downloadStream(outputStream);
    byte[] data = outputStream.toByteArray();
}

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
    }
}

import com.azure.storage.blob.specialized.BlobOutputStream;
 
try (BlobOutputStream blobOS = blobClient.getBlockBlobClient().getBlobOutputStream()) {
    blobOS.write("Data to upload".getBytes());
}

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());
}

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());
    }
}

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);

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>");

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);

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);

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();

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.)
}

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();

AZURE_STORAGE_CONNECTION_STRING=DefaultEndpointsProtocol=https;AccountName=...
AZURE_STORAGE_ACCOUNT_URL=https://<account>.blob.core.windows.net