Snabbstart: Hantera blobar med Java v12 SDK

I den här snabbstarten lär du dig att hantera blobar med hjälp av Java. Blobar är objekt som kan innehålla stora mängder text eller binära data, inklusive bilder, dokument, strömmande media och arkivdata. Du laddar upp, laddar ned och listar blobar och skapar och tar bort containrar.

Ytterligare resurser:

• Referensdokumentation för API
• Bibliotekskällkod
• Paket (Maven)
• Exempel

Förutsättningar

• Ett Azure-konto med en aktiv prenumeration. Skapa ett konto utan kostnad.
• Ett Azure Storage-konto. Skapa ett lagringskonto.
• Java Development Kit (JDK) version 8 eller senare.
• Apache Maven.

Inrätta

Det här avsnittet går igenom hur du förbereder ett projekt för att arbeta med Azure Blob Storage-klientbiblioteket v12 för Java.

Skapa projektet

Skapa ett Java-program med namnet blob-quickstart-v12.

1. I ett konsolfönster (till exempel cmd, PowerShell eller Bash) använder du Maven för att skapa en ny konsolapp med namnet blob-quickstart-v12. Skriv följande mvn-kommando för att skapa ett "Hello world!" Java-projekt.

   • PowerShell
   • Bash

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

2. Utdata från att generera projektet bör se ut ungefär så här:

   [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-v12
   [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-v12
   [INFO] Project created from Archetype in dir: C:\QuickStarts\blob-quickstart-v12
   [INFO] ------------------------------------------------------------------------
   [INFO] BUILD SUCCESS
   [INFO] ------------------------------------------------------------------------
   [INFO] Total time:  7.056 s
   [INFO] Finished at: 2019-10-23T11:09:21-07:00
   [INFO] ------------------------------------------------------------------------
       ```
   
   

3. Switch to the newly created blob-quickstart-v12 folder.

   cd blob-quickstart-v12
   

4. På sidan blob-quickstart-v12-katalogen skapar du en annan katalog med namnet data. Det är här blobdatafilerna skapas och lagras.

   mkdir data
   

Installera paketet

Öppna pom.xml i textredigeraren. Lägg till följande beroendeelement i gruppen med beroenden.

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

Konfigurera appramverket

Från projektkatalogen:

1. Gå till katalogen /src/main/java/com/blobs/quickstart
2. Öppna filen App.java i redigeringsredigeraren
3. Ta bort System.out.println("Hello world!"); instruktionen
4. Lägga till import direktiv

Här är koden:

package com.blobs.quickstart;

/**
 * Azure blob storage v12 SDK quickstart
 */
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
    {
    }
}

Kopiera dina autentiseringsuppgifter från Azure-portalen

När exempelprogrammet gör en begäran till Azure Storage måste det auktoriserats. Om du vill auktorisera en begäran lägger du till autentiseringsuppgifterna för ditt lagringskonto i programmet som en anslutningssträng. Följ dessa steg om du vill visa autentiseringsuppgifterna för ditt lagringskonto:

1. Logga in på Azure-portalen.

2. Leta rätt på ditt lagringskonto.

3. I menyfönstret för lagringskontot går du till Säkerhet + nätverk och väljer Åtkomstnycklar. Här kan du visa kontoåtkomstnycklarna och den fullständiga anslutningssträngen för varje nyckel.

   

4. I fönstret Åtkomstnycklar väljer du Visa nycklar.

5. Leta upp värdet för Anslutningssträng i avsnittet key1. Välj ikonen Kopiera till Urklipp för att kopiera anslutningssträngen. Du lägger till anslutningssträngens värde i en miljövariabel i nästa avsnitt.

   

Konfigurera anslutningssträngen för lagring

När du har kopierat anslutningssträngen skriver du den till en ny miljövariabel på den lokala dator som kör programmet. Konfigurera miljövariabeln genom att öppna ett konsolfönster och följa anvisningarna för ditt operativsystem. Ersätt <yourconnectionstring> med den faktiska anslutningssträngen.

Windows

setx AZURE_STORAGE_CONNECTION_STRING "<yourconnectionstring>"

När du har lagt till miljövariabeln i Windows måste du starta en ny instans av kommandofönstret.

Linux

export AZURE_STORAGE_CONNECTION_STRING="<yourconnectionstring>"

macOS

export AZURE_STORAGE_CONNECTION_STRING="<yourconnectionstring>"

Starta om program

När du har lagt till miljövariabeln startar du om alla program som körs och behöver läsa miljövariabeln. Du kan till exempel starta om utvecklingsmiljön eller redigeringsredigeraren innan du fortsätter.

Objektmodell

Azure Blob Storage är optimerad för att lagra stora mängder ostrukturerade data. Ostrukturerade data är data som inte följer en viss datamodell eller definition, till exempel text eller binära data. I blobblagringen finns tre typer av resurser:

• Lagringskontot
• En container på lagringskontot
• En blob i containern

Följande diagram visar relationen mellan de här resurserna.

Använd följande Java-klasser för att interagera med dessa resurser:

• BlobServiceClient:Med BlobServiceClient klassen kan du ändra Azure Storage och blobcontainrar. Lagringskontot tillhandahåller namnområdet på den översta nivån för Blob Service.
• BlobServiceClientBuilder:Klassen tillhandahåller ett fluent builder-API som hjälper BlobServiceClientBuilder dig att konfigurera och instansiera BlobServiceClient objekt.
• BlobContainerClient:Med BlobContainerClient klassen kan du ändra Azure Storage och deras blobar.
• BlobClient:Med BlobClient klassen kan du ändra Azure Storage blobar.
• BlobItem:Klassen BlobItem representerar enskilda blobar som returneras från ett anrop till listBlobs.

Kodexempel

De här exempelkodfragmenten visar hur du utför följande med Azure Blob Storage-klientbiblioteket för Java:

• Hämta anslutningssträngen
• Skapa en container
• Upload blobar till en container
• Visa blobar i en container
• Ladda ned blobbar
• Ta bort en container

Hämta anslutningssträngen

Koden nedan hämtar anslutningssträngen för lagringskontot från miljövariabeln som skapades i avsnittet Konfigurera lagringsanslutningssträngen.

Lägg till den här koden i Main metoden :

System.out.println("Azure Blob Storage v12 - Java quickstart sample\n");

// Retrieve the connection string for use with the application. The storage
// connection string is stored in an environment variable on the machine
// running the application called AZURE_STORAGE_CONNECTION_STRING. If the environment variable
// is created after the application is launched in a console or with
// Visual Studio, the shell or application needs to be closed and reloaded
// to take the environment variable into account.
String connectStr = System.getenv("AZURE_STORAGE_CONNECTION_STRING");

Skapa en container

Bestäm ett namn för den nya containern. Koden nedan lägger till ett UUID-värde i containernamnet för att säkerställa att det är unikt.

Skapa sedan en instans av klassen BlobContainerClient och anropa sedan metoden create för att skapa containern i ditt lagringskonto.

Lägg till den här koden i slutet av Main metoden:

// Create a BlobServiceClient object which will be used to create a container client
BlobServiceClient blobServiceClient = new BlobServiceClientBuilder().connectionString(connectStr).buildClient();

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

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

Upload blobar till en container

Följande kodfragment:

1. Skapar en textfil i den lokala datakatalogen.
2. Hämtar en referens till ett BlobClient-objekt genom att anropa metoden getBlobClient i containern från avsnittet Skapa en container.
3. Laddar upp den lokala textfilen till bloben genom att anropa metoden uploadFromFile. Den här metoden skapar bloben om den inte redan finns, men skriver inte över den om den finns.

Lägg till den här koden i slutet av Main metoden:

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

// Write text to the file
FileWriter writer = new FileWriter(localPath + fileName, true);
writer.write("Hello, World!");
writer.close();

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

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

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

Visa blobar i en container

Visa en lista över blobarna i containern genom att anropa metoden listBlobs. I det här fallet har endast en blob lagts till i containern, så liståtgärden returnerar bara den bloben.

Lägg till den här koden i slutet av Main metoden:

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

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

Ladda ned blobbar

Ladda ned bloben som du skapade tidigare genom att anropa downloadToFile-metoden. Exempelkoden lägger till suffixet "DOWNLOAD" i filnamnet så att du kan se båda filerna i det lokala filsystemet.

Lägg till den här koden i slutet av Main metoden:

// Download the blob to a local file
// Append the string "DOWNLOAD" before the .txt extension so that you can see both files.
String downloadFileName = fileName.replace(".txt", "DOWNLOAD.txt");
File downloadedFile = new File(localPath + downloadFileName);

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

blobClient.downloadToFile(localPath + downloadFileName);

Ta bort en container

Följande kod rensar resurserna som appen skapade genom att ta bort hela containern med hjälp av delete-metoden. Den tar även bort de lokala filer som skapats av appen.

Appen pausar för användarindata genom att System.console().readLine() anropa innan den tar bort bloben, containern och lokala filer. Det här är en bra chans att kontrollera att resurserna har skapats korrekt innan de tas bort.

Lägg till den här koden i slutet av Main metoden:

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

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

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

System.out.println("Done");

Kör koden

Den här appen skapar en testfil i din lokala mapp och laddar upp den till Blob Storage. Exemplet visar sedan blobarna i containern och laddar ned filen med ett nytt namn så att du kan jämföra de gamla och nya filerna.

Navigera till katalogen som innehåller pom.xml och kompilera projektet med hjälp av följande mvn kommando.

mvn compile

Skapa sedan paketet.

mvn package

Kör följande mvn kommando för att köra appen.

mvn exec:java -Dexec.mainClass="com.blobs.quickstart.App" -Dexec.cleanupDaemonThreads=false

Appens utdata liknar följande exempel:

Azure Blob Storage v12 - Java quickstart sample

Uploading to Blob storage as blob:
        https://mystorageacct.blob.core.windows.net/quickstartblobsf9aa68a5-260e-47e6-bea2-2dcfcfa1fd9a/quickstarta9c3a53e-ae9d-4863-8b34-f3d807992d65.txt

Listing blobs...
        quickstarta9c3a53e-ae9d-4863-8b34-f3d807992d65.txt

Downloading blob to
        ./data/quickstarta9c3a53e-ae9d-4863-8b34-f3d807992d65DOWNLOAD.txt

Press the Enter key to begin clean up

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

Innan du påbörjar rensningsprocessen kontrollerar du datamappen för de två filerna. Du kan öppna dem och se att de är identiska.

När du har verifierat filerna trycker du på Retur för att ta bort testfilerna och avsluta demonstrationen.

Nästa steg

I den här snabbstarten har du lärt dig hur du laddar upp, laddar ned och listar blobar med Java.

Om du vill se Blob Storage-exempelappar fortsätter du till:

• Mer information finns i Azure SDK för Java.
• Självstudier, exempel, snabbstarter och annan dokumentation finns i Azure för Java-molnutvecklare.