azure-storage-blob-java

--- Créez des applications de stockage d'objets blob avec le SDK Azure Storage Blob pour Java. À utiliser lors du téléchargement, du téléchargement ou de la gestion de fichiers dans Azure Blob Storage, l'utilisation de conteneurs ou la mise en œuvre d'opérations de données en continu.

npx skills add https://github.com/microsoft/skills --skill azure-storage-blob-java

SDK Azure Storage Blob pour Java

Créez des applications de stockage d'objets blob à l'aide du SDK Azure Storage Blob pour Java.

Installation

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

Création de client

BlobServiceClient

import com.azure.storage.blob.BlobServiceClient;
import com.azure.storage.blob.BlobServiceClientBuilder;

// Avec jeton SAS
BlobServiceClient serviceClient = new BlobServiceClientBuilder()
    .endpoint("<storage-account-url>")
    .sasToken("<sas-token>")
    .buildClient();

// Avec chaîne de connexion
BlobServiceClient serviceClient = new BlobServiceClientBuilder()
    .connectionString("<connection-string>")
    .buildClient();

Avec DefaultAzureCredential

import com.azure.identity.DefaultAzureCredentialBuilder;

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

BlobContainerClient

import com.azure.storage.blob.BlobContainerClient;

// À partir du client de service
BlobContainerClient containerClient = serviceClient.getBlobContainerClient("mycontainer");

// Construction directe
BlobContainerClient containerClient = new BlobContainerClientBuilder()
    .connectionString("<connection-string>")
    .containerName("mycontainer")
    .buildClient();

BlobClient

import com.azure.storage.blob.BlobClient;

// À partir du client de conteneur
BlobClient blobClient = containerClient.getBlobClient("myblob.txt");

// Avec structure de répertoires
BlobClient blobClient = containerClient.getBlobClient("folder/subfolder/myblob.txt");

// Construction directe
BlobClient blobClient = new BlobClientBuilder()
    .connectionString("<connection-string>")
    .containerName("mycontainer")
    .blobName("myblob.txt")
    .buildClient();

Modèles essentiels

Créer un conteneur

// Créer un conteneur
serviceClient.createBlobContainer("mycontainer");

// Créer s'il n'existe pas
BlobContainerClient container = serviceClient.createBlobContainerIfNotExists("mycontainer");

// À partir du client de conteneur
containerClient.create();
containerClient.createIfNotExists();

Charger des données

import com.azure.core.util.BinaryData;

// Charger une chaîne
String data = "Hello, Azure Blob Storage!";
blobClient.upload(BinaryData.fromString(data));

// Charger avec remplacement
blobClient.upload(BinaryData.fromString(data), true);

Charger à partir d'un fichier

blobClient.uploadFromFile("local-file.txt");

// Avec remplacement
blobClient.uploadFromFile("local-file.txt", true);

Charger à partir d'un flux

import com.azure.storage.blob.specialized.BlockBlobClient;

BlockBlobClient blockBlobClient = blobClient.getBlockBlobClient();

try (ByteArrayInputStream dataStream = new ByteArrayInputStream(data.getBytes())) {
    blockBlobClient.upload(dataStream, data.length());
}

Charger avec options

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

Charger s'il n'existe pas

import com.azure.storage.blob.models.BlobRequestConditions;

BlobParallelUploadOptions options = new BlobParallelUploadOptions(inputStream, length)
    .setRequestConditions(new BlobRequestConditions().setIfNoneMatch("*"));

blobClient.uploadWithResponse(options, null, Context.NONE);

Télécharger des données

// Télécharger vers BinaryData
BinaryData content = blobClient.downloadContent();
String text = content.toString();

// Télécharger vers un fichier
blobClient.downloadToFile("downloaded-file.txt");

Télécharger vers un flux

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

Télécharger avec InputStream

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) {
        // Traiter le buffer
    }
}

Charger via OutputStream

import com.azure.storage.blob.specialized.BlobOutputStream;

try (BlobOutputStream blobOS = blobClient.getBlockBlobClient().getBlobOutputStream()) {
    blobOS.write("Data to upload".getBytes());
}

Lister les objets blob

import com.azure.storage.blob.models.BlobItem;

// Lister tous les objets blob
for (BlobItem blobItem : containerClient.listBlobs()) {
    System.out.println("Blob: " + blobItem.getName());
}

// Lister avec préfixe (répertoire virtuel)
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());
}

Lister les objets blob par hiérarchie

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

Supprimer un objet blob

blobClient.delete();

// Supprimer s'il existe
blobClient.deleteIfExists();

// Supprimer avec snapshots
import com.azure.storage.blob.models.DeleteSnapshotsOptionType;
blobClient.deleteWithResponse(DeleteSnapshotsOptionType.INCLUDE, null, null, Context.NONE);

Copier un objet blob

import com.azure.storage.blob.models.BlobCopyInfo;
import com.azure.core.util.polling.SyncPoller;

// Copie asynchrone (pour les grands objets blob ou entre comptes)
SyncPoller<BlobCopyInfo, Void> poller = blobClient.beginCopy("<source-blob-url>", Duration.ofSeconds(1));
poller.waitForCompletion();

// Copie synchrone depuis URL (pour le même compte)
blobClient.copyFromUrl("<source-blob-url>");

Générer un jeton SAS

import com.azure.storage.blob.sas.*;
import java.time.OffsetDateTime;

// SAS au niveau de l'objet blob
BlobSasPermission permissions = new BlobSasPermission().setReadPermission(true);
OffsetDateTime expiry = OffsetDateTime.now().plusDays(1);

BlobServiceSasSignatureValues sasValues = new BlobServiceSasSignatureValues(expiry, permissions);
String sasToken = blobClient.generateSas(sasValues);

// SAS au niveau du conteneur
BlobContainerSasPermission containerPermissions = new BlobContainerSasPermission()
    .setReadPermission(true)
    .setListPermission(true);

BlobServiceSasSignatureValues containerSasValues = new BlobServiceSasSignatureValues(expiry, containerPermissions);
String containerSas = containerClient.generateSas(containerSasValues);

Propriétés et métadonnées des objets blob

import com.azure.storage.blob.models.BlobProperties;

// Obtenir les propriétés
BlobProperties properties = blobClient.getProperties();
System.out.println("Size: " + properties.getBlobSize());
System.out.println("Content-Type: " + properties.getContentType());
System.out.println("Last Modified: " + properties.getLastModified());

// Définir les métadonnées
Map<String, String> metadata = Map.of("key1", "value1", "key2", "value2");
blobClient.setMetadata(metadata);

// Définir les en-têtes HTTP
BlobHttpHeaders headers = new BlobHttpHeaders()
    .setContentType("application/json")
    .setCacheControl("max-age=86400");
blobClient.setHttpHeaders(headers);

Bail sur un objet blob

import com.azure.storage.blob.specialized.BlobLeaseClient;
import com.azure.storage.blob.specialized.BlobLeaseClientBuilder;

BlobLeaseClient leaseClient = new BlobLeaseClientBuilder()
    .blobClient(blobClient)
    .buildClient();

// Acquérir un bail (-1 pour infini)
String leaseId = leaseClient.acquireLease(60);

// Renouveler le bail
leaseClient.renewLease();

// Libérer le bail
leaseClient.releaseLease();

Gestion des erreurs

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 non trouvé
    // 409 = Conflit (bail, etc.)
}

Configuration du proxy

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

Variables d'environnement

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

Expressions déclencheurs

  • "Azure Blob Storage Java"
  • "upload download blob"
  • "blob container SDK"
  • "storage streaming"
  • "SAS token generation"
  • "blob metadata properties"