Schnellstart: Azure Blob Storage-Clientbibliothek für Java SE

Hinweis

Die Option "Build from Scratch " führt dich beim Erstellen eines Projekts, beim Installieren von Paketen, beim Schreiben von Code und beim Ausführen einer einfachen Konsolen-App. Wählen Sie diese Option, um zu verstehen, wie man eine App erstellt, die sich mit Azure Blob Storage verbindet. Um Bereitstellungsaufgaben zu automatisieren und mit einem abgeschlossenen Projekt zu beginnen, wählen Sie " Mit einer Vorlage beginnen".

Hinweis

Die Option "Start with a template" verwendet die Azure Developer CLI, um Bereitstellungsaufgaben zu automatisieren und stellt ein abgeschlossenes Projekt bereit. Wählen Sie diese Option, um den Code zu erkunden, ohne die Einrichtungsaufgaben abgeschlossen zu haben. Für eine Schritt-für-Schritt-Anleitung zum Erstellen der App wählen Sie Von Grund auf neu erstellen.

Beginnen Sie mit der Azure Blob Storage-Clientbibliothek für Java, um Blobs und Container zu verwalten.

In diesem Artikel führen Sie die Schritte zum Installieren des Pakets aus und testen den Beispielcode für grundlegende Aufgaben.

In diesem Artikel verwenden Sie die Azure Developer CLI, um Azure-Ressourcen bereitzustellen und eine fertige Konsolen-App mit nur wenigen Befehlen auszuführen.

Tipp

Für Spring-Anwendungen, die Azure Storage-Ressourcen verwenden, sollten Sie Spring Cloud Azure in Betracht ziehen. Dieses Open-Source-Projekt integriert Spring mit Azure-Diensten. Ein Beispiel für Blob Storage siehe Upload a file to a Azure Storage Blob.

API-Referenzdokumentation | Quellcode der Bibliothek | Paket (Maven) | Beispiele

Voraussetzungen

Einrichten

In diesem Abschnitt wird beschrieben, wie ein Projekt zur Verwendung mit der Azure Blob Storage-Clientbibliothek für Java vorbereitet wird.

Erstellen des Projekts

Erstellen Sie eine Java-Anwendung mit dem Namen blob-quickstart.

  1. Verwenden Sie in einem Konsolenfenster (z. B. PowerShell oder Bash) Maven zum Erstellen einer neuen Konsolen-App mit dem Namen blob-quickstart. Geben Sie den folgenden mvn-Befehl ein, um ein „Hallo Welt!“-Java-Projekt zu erstellen.

    mvn archetype:generate `
    --define interactiveMode=n `
    --define groupId=com.blobs.quickstart `
    --define artifactId=blob-quickstart `
    --define archetypeArtifactId=maven-archetype-quickstart `
    --define archetypeVersion=1.4

  2. Überprüfen Sie die Ergebnisse der Projektentwicklung.

    [INFO] Scanning for projects...
[INFO]
[INFO] ------------------< org.apache.maven:standalone-pom >-------------------
[INFO] Building Maven Stub Project (No POM) 1
[INFO] --------------------------------[ pom ]---------------------------------
[INFO]
[INFO] >>> maven-archetype-plugin:3.1.2:generate (default-cli) > generate-sources @ standalone-pom >>>
[INFO]
[INFO] <<< maven-archetype-plugin:3.1.2:generate (default-cli) < generate-sources @ standalone-pom <<<
[INFO]
[INFO]
[INFO] --- maven-archetype-plugin:3.1.2:generate (default-cli) @ standalone-pom ---
[INFO] Generating project in Batch mode
[INFO] ----------------------------------------------------------------------------
[INFO] Using following parameters for creating project from Archetype: maven-archetype-quickstart:1.4
[INFO] ----------------------------------------------------------------------------
[INFO] Parameter: groupId, Value: com.blobs.quickstart
[INFO] Parameter: artifactId, Value: blob-quickstart
[INFO] Parameter: version, Value: 1.0-SNAPSHOT
[INFO] Parameter: package, Value: com.blobs.quickstart
[INFO] Parameter: packageInPathFormat, Value: com/blobs/quickstart
[INFO] Parameter: version, Value: 1.0-SNAPSHOT
[INFO] Parameter: package, Value: com.blobs.quickstart
[INFO] Parameter: groupId, Value: com.blobs.quickstart
[INFO] Parameter: artifactId, Value: blob-quickstart
[INFO] Project created from Archetype in dir: C:\QuickStarts\blob-quickstart
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  7.056 s
[INFO] Finished at: 2019-10-23T11:09:21-07:00
[INFO] ------------------------------------------------------------------------
    ```

  3. Wechseln Sie zu dem neu erstellten Verzeichnis blob-quickstart.

    cd blob-quickstart

  4. Im Verzeichnis blob-quickstart erstellen Sie ein weiteres Verzeichnis namens data. In diesem Ordner werden die Blob-Datendateien erstellt und gespeichert.

    mkdir data

Installieren der Pakete

Öffnen Sie die Datei pom.xml in Ihrem Text-Editor.

Fügen Sie azure-sdk-bom hinzu, um eine Abhängigkeit von der neuesten Version der Bibliothek herzustellen. Ersetzen Sie im folgenden Codeausschnitt den Platzhalter {bom_version_to_target} durch die Versionsnummer. Mit azure-sdk-bom müssen Sie nicht die Version jeder einzelnen Abhängigkeit angeben. Weitere Informationen zur BOM finden Sie in der Azure SDK-BOM-Infodatei.

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>com.azure</groupId>
            <artifactId>azure-sdk-bom</artifactId>
            <version>{bom_version_to_target}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

Fügen Sie der Gruppe der Abhängigkeiten dann das folgende Abhängigkeitselement hinzu. Du brauchst die azure-identity-Abhängigkeit für passwortlose Verbindungen zu Azure-Diensten.

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

Einrichten des App-Frameworks

Führen Sie im Projektverzeichnis die folgenden Schritte aus, um die grundlegende Struktur der App zu erstellen:

  1. Navigieren Sie zum Verzeichnis /src/main/java/com/blobs/quickstart.
  2. Öffnen Sie die Datei App.java in Ihrem Editor.
  3. Löschen Sie die Zeile System.out.println("Hello world!");.
  4. Fügen Sie die notwendigen import-Direktiven hinzu.

Der Code sollte diesem Framework ähneln:

package com.blobs.quickstart;

/**
 * Azure Blob Storage quickstart
 */
import com.azure.identity.*;
import com.azure.storage.blob.*;
import com.azure.storage.blob.models.*;
import java.io.*;

public class App
{
    public static void main(String[] args) throws IOException
    {
        // Quickstart code goes here
    }
}

Mit der Azure Developer CLI können Sie ein Speicherkonto erstellen und den Beispielcode mit nur wenigen Befehlen ausführen. Du kannst das Projekt in deiner lokalen Entwicklungsumgebung oder in einem DevContainer ausführen.

Initialisieren der Azure Developer CLI-Vorlage und Bereitstellen von Ressourcen

Führen Sie aus einem leeren Verzeichnis die folgenden Schritte aus, um die azd-Vorlage zu initialisieren, Azure-Ressourcen bereitzustellen und mit dem Code zu beginnen:

  • Klonen Sie die Schnellstart-Repositoryressourcen von GitHub und initialisieren Sie die Vorlage lokal:

    azd init --template blob-storage-quickstart-java

    Sie werden zur Eingabe der folgenden Informationen aufgefordert:

    • Environment name: Azure Developer CLI verwendet diesen Wert als Präfix für alle Azure Ressourcen, die sie erstellt. Der Name muss für alle Azure Abonnements eindeutig sein und zwischen 3 und 24 Zeichen lang sein. Der Name darf nur Ziffern und Kleinbuchstaben enthalten.

  • Melden Sie sich bei Azure an:

    azd auth login

  • Bereitstellen der Ressourcen in Azure:

    azd up

    Sie werden zur Eingabe der folgenden Informationen aufgefordert:

    • Abonnement: Das Azure-Abonnement zur Bereitstellung Ihrer Ressourcen.
    • Standort: Die Azure-Region zum Bereitstellen Ihrer Ressourcen.

    Die Bereitstellung kann einige Minuten dauern. Die Ausgabe des azd up Befehls enthält den Namen des neu erstellten Speicherkontos, das Sie später zum Ausführen des Codes benötigen.

Führen Sie den Beispielcode aus

Nun werden die Ressourcen in Azure bereitgestellt, und der Code kann fast ausgeführt werden. Führen Sie die folgenden Schritte aus, um den Namen des Speicherkontos im Code zu aktualisieren und die Beispielkonsolen-App auszuführen:

  • Aktualisieren sie den Namen des Speicherkontos:
    1. Navigieren Sie im lokalen Verzeichnis zum blob-quickstart/src/main/java/com/blobs/quickstart-Verzeichnis.
    2. Öffnen Sie die Datei mit dem Namen App.java in Ihrem Editor. Suchen Sie den <storage-account-name>-Platzhalter und ersetzen Sie ihn durch den tatsächlichen Namen des Speicherkontos, das vom Befehl azd up erstellt wurde.
    3. Speichern Sie die Änderungen.
  • Führen Sie das Projekt aus:
    1. Navigieren Sie zum blob-quickstart-Verzeichnis, das die pom.xml-Datei enthält. Kompilieren Sie das Projekt mithilfe des folgenden mvn-Befehls: 
      mvn compile
    2. Verpacken Sie den kompilierten Code in seinem verteilbaren Format: 
      mvn package
    3. Führen Sie die App mit dem folgenden mvn-Befehl aus. 
      mvn exec:java
  • Beobachten Sie die Ausgabe: Diese App erstellt eine Testdatei in Ihrem lokalen Daten-Ordner und lädt sie in einen Container im Speicherkonto hoch. Anschließend werden im Beispiel die Blobs im Container aufgelistet, und die Datei wird mit einem neuen Namen heruntergeladen, damit Sie die alte und neue Datei vergleichen können.

Weitere Informationen zur Funktionsweise des Beispielcodes finden Sie in Codebeispielen.

Wenn Sie mit dem Testen des Codes fertig sind, lesen Sie den Abschnitt Bereinigen von Ressourcen, um die vom Befehl azd up erstellten Ressourcen zu löschen.

Objektmodell

Azure Blob Storage ist für die Speicherung großer Mengen unstrukturierter Daten optimiert. Unstrukturierte Daten entsprechen keinem bestimmten Datenmodell und keiner bestimmten Definition (also beispielsweise Text- oder Binärdaten). Blob Storage bietet drei Typen von Ressourcen:

  • Das Speicherkonto
  • Einen Container im Speicherkonto
  • Ein Blob im Container

Im folgenden Diagramm ist die Beziehung zwischen diesen Ressourcen dargestellt.

Diagramm, das ein Speicherkonto zeigt, das einen Blob-Container und einen Blob enthält.

Verwenden Sie die folgenden Java-Klassen zur Interaktion mit folgenden Ressourcen:

  • BlobServiceClient: Die BlobServiceClient Klasse verwaltet Azure Storage-Ressourcen und Blob-Container. Das Speicherkonto stellt den Namespace der obersten Ebene für den Blob-Dienst bereit.
  • BlobServiceClientBuilder: Die BlobServiceClientBuilder Klasse stellt eine flüssige API zur Verfügung, um Objekte zu konfigurieren und zu erstellen BlobServiceClient .
  • BlobContainerClient: Die BlobContainerClient Klasse verwaltet Azure Storage-Container und deren Blobs.
  • BlobClient: Die BlobClient Klasse verwaltet Azure Storage Blobs.
  • BlobItem: Die BlobItem-Klasse stellt einzelne Blobs dar, die durch einen Aufruf von listBlobs zurückgegeben werden.

Codebeispiele

Mit den Beispielcodeausschnitten wird veranschaulicht, wie folgende Aktionen mit der Azure Blob Storage-Clientbibliothek für Java durchgeführt werden:

Wichtig

Füge die in Setting beschriebenen Abhängigkeiten und Direktiven hinzu, bevor du die Codebeispiele verwendest.

Hinweis

Die Azure Developer CLI-Vorlage enthält eine Datei mit bereits vorhandenem Beispielcode. Die folgenden Beispiele enthalten Details für jeden Teil des Beispielcodes. Die Vorlage implementiert die empfohlene kennwortlose Authentifizierungsmethode, wie im Abschnitt Authentifizieren bei Azure beschrieben. Die Verbindungszeichenfolgenmethode wird als Alternative angezeigt, wird jedoch nicht in der Vorlage verwendet und wird nicht für Produktionscode empfohlen.

Authentifizieren bei Azure und Autorisieren des Zugriffs auf Blobdaten

Anwendungsanforderungen an Azure Blob Storage müssen autorisiert werden. Die Verwendung der von der Azure Identity-Clientbibliothek bereitgestellten Klasse DefaultAzureCredential ist der empfohlene Ansatz zum Implementieren von kennwortlosen Verbindungen mit Azure-Diensten in Ihrem Code, einschließlich Blob Storage.

Sie können Anforderungen an Azure Blob Storage auch mithilfe des Kontozugriffsschlüssels autorisieren. Dieser Ansatz sollte jedoch mit Vorsicht verwendet werden. Entwickler müssen darauf achten, dass die Zugriffsschlüssel niemals an einem unsicheren Ort offengelegt werden. Jeder, der über den Zugriffsschlüssel verfügt, kann Anforderungen für das Speicherkonto autorisieren und hat somit Zugriff auf alle Daten. DefaultAzureCredential bietet verbesserte Verwaltungs- und Sicherheitsvorteile gegenüber dem Kontoschlüssel, um kennwortlose Authentifizierung zu ermöglichen. Beide Optionen werden im folgenden Beispiel veranschaulicht.

DefaultAzureCredential ist eine Klasse, die von der Azure Identity-Clientbibliothek für Java bereitgestellt wird. „DefaultAzureCredential“ unterstützt mehrere Authentifizierungsmethoden und bestimmt, welche Methode zur Laufzeit verwendet wird. Bei diesem Ansatz kann Ihre App unterschiedliche Authentifizierungsmethoden in verschiedenen Umgebungen (lokal gegenüber Produktion) verwenden, ohne umgebungsspezifischen Code zu implementieren.

Sie finden die Reihenfolge und die Speicherorte, an denen DefaultAzureCredential nach Anmeldeinformationen sucht, in der Übersicht zur Azure Identity-Bibliothek.

Zum Beispiel kann Ihre App sich authentifizieren, indem sie Ihre Visual Studio Code-Anmeldedaten verwendet, wenn Sie lokal entwickeln. Deine App kann dann nach der Bereitstellung auf Azure eine verwaltete Identität verwenden. Für diesen Übergang sind keine Änderungen am Code erforderlich.

Weisen Sie Ihrem Microsoft Entra-Benutzerkonto Rollen zu.

Stellen Sie bei lokaler Entwicklung sicher, dass das Benutzerkonto, das auf Blobdaten zugreift, über die richtigen Berechtigungen verfügt. Sie benötigen die Berechtigung Mitwirkender an Speicherblobdaten zum Lesen und Schreiben von Blobdaten. Um sich selbst diese Rolle zuweisen zu können, benötigen Sie die Rolle Benutzerzugriffsadministrator oder eine andere Rolle, die die Aktion Microsoft.Authorization/roleAssignments/write enthält. Sie können einem Benutzer Azure RBAC-Rollen über das Azure-Portal, die Azure CLI oder mit Azure PowerShell zuweisen. Weitere Informationen zur Rolle " Storage Blob Data Contributor " finden Sie unter "Storage Blob Data Contributor". Weitere Informationen zu den verfügbaren Bereichen für Rollenzuweisungen finden Sie unter Grundlegendes zum Bereich für Azure RBAC.

In diesem Szenario weisen Sie Ihrem Benutzerkonto Berechtigungen zu, die auf das Speicherkonto zugeschnitten sind, um dem Prinzip der geringsten Rechte zu folgen. Auf diese Weise erhalten Benutzer nur die erforderlichen Mindestberechtigungen, und es entstehen sicherere Produktionsumgebungen.

Im folgenden Beispiel wird Ihrem Benutzerkonto die Rolle Mitwirkender an Storage-Blobdaten zugewiesen, die sowohl Lese- als auch Schreibzugriff auf Blobdaten in Ihrem Speicherkonto ermöglicht.

Wichtig

In den meisten Fällen dauert es eine oder zwei Minute(n), bis die Rollenzuweisung in Azure weitergegeben wird. In seltenen Fällen kann es aber bis zu acht Minuten dauern. Wenn bei der ersten Ausführung Ihres Codes Authentifizierungsfehler auftreten, warten Sie einige Momente, und versuchen Sie es dann erneut.

  1. Suchen Sie im Azure-Portal Ihr Speicherkonto mithilfe der Hauptsuchleiste oder der linken Navigationsleiste.

  2. Wählen Sie auf der Übersichtsseite des Speicherkontos im linken Menü die Option Zugriffssteuerung (IAM) aus.

  3. Wählen Sie auf der Seite Zugriffssteuerung (IAM) die Registerkarte Rollenzuweisungen aus.

  4. Wählen Sie im oberen Menü + Hinzufügen und aus dem dann angezeigten Dropdownmenü die Option Rollenzuweisung hinzufügen aus.

    Ein Screenshot zeigt, wie eine Rolle zugewiesen wird.

  5. Über das Suchfeld können Sie die Ergebnisse für die gewünschte Rolle filtern. Suchen Sie in diesem Beispiel nach Mitwirkender an Speicherblobdaten, wählen Sie das entsprechende Ergebnis und dann Weiter aus.

  6. Wählen Sie unter Zugriff zuweisen zu die Option Benutzer, Gruppe oder Dienstprinzipal und dann die Option + Mitglieder auswählen aus.

  7. Suchen Sie im Dialogfeld nach Ihrem Microsoft Entra-Benutzernamen (normalerweise Ihre E-Mail-Adresse benutzer@domäne), und wählen Sie unten im Dialogfeld Auswählen aus.

  8. Wählen Sie Überprüfen und zuweisen aus, um zur letzten Seite zu gelangen, und wählen Sie erneut Überprüfen und zuweisen aus, um den Vorgang abzuschließen.

Melden Sie sich an, und verbinden Sie Ihren App-Code mit Azure mithilfe von DefaultAzureCredential

Autorisieren Sie den Zugriff auf Daten in Ihrem Speicherkonto durch folgende Schritte:

  1. Authentifizieren Sie sich mit demselben Microsoft Entra-Konto, dem Sie die Rolle des Speicherkontos zugewiesen haben. Verwenden Sie Azure CLI, Visual Studio Code oder Azure PowerShell.

    Melden Sie sich mit dem folgenden Befehl bei Azure über die Azure CLI an:

    az login

  2. Um DefaultAzureCredential zu verwenden, fügen Sie die Abhängigkeit azure-identity zu pom.xml hinzu:

    <dependency>
  <groupId>com.azure</groupId>
  <artifactId>azure-identity</artifactId>
</dependency>

  3. Fügen Sie diesen Code der Methode main hinzu. Wenn der Code auf Ihrer lokalen Arbeitsstation läuft, verwendet er die Entwicklerzugangsdaten des priorisierten Tools, bei dem Sie angemeldet sind, um sich bei Azure zu authentifizieren, wie z. B. der Azure CLI oder Visual Studio Code.

    /*
 * The default credential first checks environment variables for configuration
 * If environment configuration is incomplete, it will try managed identity
 */
DefaultAzureCredential defaultCredential = new DefaultAzureCredentialBuilder().build();

// Azure SDK client builders accept the credential as a parameter
// TODO: Replace <storage-account-name> with your actual storage account name
BlobServiceClient blobServiceClient = new BlobServiceClientBuilder()
        .endpoint("https://<storage-account-name>.blob.core.windows.net/")
        .credential(defaultCredential)
        .buildClient();

  4. Aktualisiere den Speicherkontonamen in der URI deines BlobServiceClient. Finden Sie den Namen des Speicherkontos auf der Übersichtsseite im Azure-Portal.

    Ein Screenshot, der zeigt, wie Sie den Namen des Speicherkontos finden.

    Hinweis

    Bei der Bereitstellung in Azure kann derselbe Code verwendet werden, um Anforderungen an Azure Storage aus einer in Azure ausgeführten Anwendung zu autorisieren. Sie müssen jedoch verwaltete Identitäten in Ihrer App in Azure aktivieren. Konfigurieren Sie dann Ihr Speicherkonto, um dieser verwalteten Identität das Herstellen einer Verbindung zu ermöglichen. Ausführliche Anleitungen zum Konfigurieren dieser Verbindung zwischen Azure-Diensten finden Sie im Tutorial Auth from Azure-hosted apps (Autorisieren aus von Azure gehosteten Apps).

Container erstellen

Erstellen Sie einen neuen Container in Ihrem Speicherkonto, indem Sie die Methode createBlobContainer für das blobServiceClient-Objekt aufrufen. In diesem Beispiel fügt der Code einen GUID-Wert an den Containernamen an, damit dieser eindeutig ist.

Fügen Sie diesen Code am Ende der main-Methode hinzu:

// Create a unique name for the container
String containerName = "quickstartblobs" + java.util.UUID.randomUUID();

// Create the container and return a container client object
BlobContainerClient blobContainerClient = blobServiceClient.createBlobContainer(containerName);

Für weitere Informationen und Beispiele siehe Create a Blob Container with Java.

Wichtig

Die Containernamen müssen klein geschrieben werden. Weitere Informationen zum Benennen von Containern und Blobs finden Sie unter Naming and Referencing Containers, Blobs, and Metadata (Benennen von Containern, Blobs und Metadaten und Verweisen auf diese).

Hochladen von Blobs in einen Container

Laden Sie einen Blob in einen Container hoch, indem Sie die UploadFromFile-Methode aufrufen. Der Beispielcode erstellt eine Textdatei im lokalen Datenverzeichnis, die in den Container hochgeladen werden soll.

Fügen Sie diesen Code am Ende der main-Methode hinzu:

// Create the ./data/ directory and a file for uploading and downloading
String localPath = "./data/";
new File(localPath).mkdirs();
String fileName = "quickstart" + java.util.UUID.randomUUID() + ".txt";

// Get a reference to a blob
BlobClient blobClient = blobContainerClient.getBlobClient(fileName);

// Write text to the file
FileWriter writer = null;
try
{
    writer = new FileWriter(localPath + fileName, true);
    writer.write("Hello, World!");
    writer.close();
}
catch (IOException ex)
{
    System.out.println(ex.getMessage());
}

System.out.println("\nUploading to Blob storage as blob:\n\t" + blobClient.getBlobUrl());

// Upload the blob
blobClient.uploadFromFile(localPath + fileName);

Weitere Informationen und Beispiele finden Sie unter Upload eines Blobs mit Java.

Listen Sie die Blobs in einem Container auf.

Listen Sie die Blobs im Container auf, indem Sie die listBlobs-Methode aufrufen. In diesem Fall haben Sie nur einen Blob zum Container hinzugefügt, sodass die Listing-Operation nur diesen einen Blob zurückgibt.

Fügen Sie diesen Code am Ende der main-Methode hinzu:

System.out.println("\nListing blobs...");

// List the blob(s) in the container.
for (BlobItem blobItem : blobContainerClient.listBlobs()) {
    System.out.println("\t" + blobItem.getName());
}

Weitere Informationen und Beispiele finden Sie unter Liste von Blobs mit Java.

Blobs herunterladen

Laden Sie das zuvor erstellte Blob herunter, indem Sie die downloadToFile-Methode aufrufen. Der Beispielcode fügt dem Dateinamen ein Suffix von DOWNLOAD hinzu, sodass man beide Dateien im lokalen Dateisystem sehen kann.

Fügen Sie diesen Code am Ende der main-Methode hinzu:

// Download the blob to a local file

// Append the string "DOWNLOAD" before the .txt extension for comparison purposes
String downloadFileName = fileName.replace(".txt", "DOWNLOAD.txt");

System.out.println("\nDownloading blob to\n\t " + localPath + downloadFileName);

blobClient.downloadToFile(localPath + downloadFileName);

Für weitere Informationen und Beispiele siehe Download a blob with Java.

Löschen eines Containers

Der folgende Code beseitigt die von der App erstellten Ressourcen, indem der gesamte Container mit der Löschmethode entfernt wird. Außerdem werden die von der App erstellten lokalen Dateien gelöscht.

Die App pausiert für eine Benutzereingabe durch Aufrufen von System.console().readLine(), bevor sie das Blob, den Container und die lokalen Dateien löscht. Diese Pause gibt dir die Möglichkeit zu überprüfen, ob die App die Ressourcen korrekt erstellt hat, bevor sie sie löscht.

Fügen Sie diesen Code am Ende der main-Methode hinzu:

File downloadedFile = new File(localPath + downloadFileName);
File localFile = new File(localPath + fileName);

// Clean up resources
System.out.println("\nPress the Enter key to begin clean up");
System.console().readLine();

System.out.println("Deleting blob container...");
blobContainerClient.delete();

System.out.println("Deleting the local source and downloaded files...");
localFile.delete();
downloadedFile.delete();

System.out.println("Done");

Für weitere Informationen und Beispiele siehe Löschen und wiederherstellen eines Blob-Containers mit Java.

Ausführen des Codes

Mit dieser App wird in Ihrem lokalen Ordner eine Testdatei erstellt und in Blob Storage hochgeladen. Anschließend werden im Beispiel die Blobs im Container aufgelistet, und die Datei wird mit einem neuen Namen heruntergeladen, damit Sie die alte und neue Datei vergleichen können.

Befolgen Sie diese Schritte, um den Code zu kompilieren, zu verpacken und auszuführen:

  1. Navigieren Sie zum Verzeichnis, das die Datei pom.xml enthält, und kompilieren Sie das Projekt mit dem folgenden mvn-Befehl: 
    mvn compile
  2. Verpacken Sie den kompilierten Code in seinem verteilbaren Format: 
    mvn package
  3. Führen Sie die App mit dem folgenden mvn-Befehl aus. 
    mvn exec:java -D exec.mainClass=com.blobs.quickstart.App -D exec.cleanupDaemonThreads=false
    Um den Ausführungsschritt zu vereinfachen, fügen Sie exec-maven-plugin zu pom.xml hinzu und konfigurieren Sie es wie im folgenden Code gezeigt: 
    <plugin>
  <groupId>org.codehaus.mojo</groupId>
  <artifactId>exec-maven-plugin</artifactId>
  <version>1.4.0</version>
  <configuration>
    <mainClass>com.blobs.quickstart.App</mainClass>
    <cleanupDaemonThreads>false</cleanupDaemonThreads>
  </configuration>
</plugin>
    Mit dieser Konfiguration führt man die App mit folgendem Befehl aus: 
    mvn exec:java

Die Ausgabe der App ähnelt dem folgenden Beispiel (UUID-Werte zur besseren Lesbarkeit weggelassen):

Azure Blob Storage - Java quickstart sample

Uploading to Blob storage as blob:
        https://mystorageacct.blob.core.windows.net/quickstartblobsUUID/quickstartUUID.txt

Listing blobs...
        quickstartUUID.txt

Downloading blob to
        ./data/quickstartUUIDDOWNLOAD.txt

Press the Enter key to begin clean up

Deleting blob container...
Deleting the local source and downloaded files...
Done

Überprüfen Sie den Ordner data vor dem Start der Bereinigung auf die beiden Dateien. Sie können sie vergleichen und sich vergewissern, dass sie identisch sind.

Bereinigen von Ressourcen

Nachdem Sie die Dateien überprüft und die Tests abgeschlossen haben, drücken Sie die EINGABETASTE , um die Testdateien zusammen mit dem Container zu löschen, den Sie im Speicherkonto erstellt haben. Sie können Ressourcen auch mit der Azure-Befehlszeilenschnittstelle löschen.

Wenn Sie mit der Schnellstartanleitung fertig sind, bereinigen Sie die Ressourcen, die Sie erstellt haben, indem Sie den folgenden Befehl ausführen:

azd down

Du erhältst eine Aufforderung, die Löschung der Ressourcen zu bestätigen. Drücken Sie zur Bestätigung y.

Nächster Schritt

Azure Storage Beispiele und Entwickleranleitungen für JavaQuickstart: Quarkus Extension for Azure Blob StorageVerwenden Sie Spring Boot, um eine Datei in Azure Blob Storage hochzuladen

  • Last updated on