Rychlý Start: Správa objektů BLOB pomocí sady Java V12 SDKQuickstart: Manage blobs with Java v12 SDK

V tomto rychlém startu se naučíte spravovat objekty BLOB pomocí Java.In this quickstart, you learn to manage blobs by using Java. Objekty blob jsou objekty, které mohou obsahovat velké objemy textových nebo binárních dat, včetně obrázků, dokumentů, datových proudů médií a dat archivu.Blobs are objects that can hold large amounts of text or binary data, including images, documents, streaming media, and archive data. Můžete nahrávat, stahovat a vypisovat objekty BLOB a vytvářet a odstraňovat kontejnery.You'll upload, download, and list blobs, and you'll create and delete containers.

Další prostředky:Additional resources:

PožadavkyPrerequisites

Poznámka

Funkce popsané v tomto článku jsou nyní k dispozici pro účty, které mají hierarchický obor názvů.The features described in this article are now available to accounts that have a hierarchical namespace. Chcete-li zkontrolovat omezení, přečtěte si téma funkce služby Blob Storage dostupné v Azure Data Lake Storage Gen2 článku.To review limitations, see the Blob storage features available in Azure Data Lake Storage Gen2 article.

NastaveníSetting up

Tato část vás provede přípravou projektu pro práci s V12 klientské knihovny Azure Blob Storage pro Java.This section walks you through preparing a project to work with the Azure Blob Storage client library v12 for Java.

Vytvoření projektuCreate the project

Vytvořte aplikaci Java s názvem BLOB-Start-V12.Create a Java application named blob-quickstart-v12.

  1. V okně konzoly (například cmd, PowerShell nebo bash) použijte Maven a vytvořte novou konzolovou aplikaci s názvem objekt BLOB-rychlý Start-V12.In a console window (such as cmd, PowerShell, or Bash), use Maven to create a new console app with the name blob-quickstart-v12. Zadáním následujícího příkazu MVN vytvořte "Hello World!"Type the following mvn command to create a "Hello world!" Projekt Java.Java project.

    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. Výstup z generování projektu by měl vypadat přibližně takto:The output from generating the project should look something like this:

    [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. V adresáři objektů BLOB pro rychlý Start – V12 vytvořte další adresář s názvem data.In side the blob-quickstart-v12 directory, create another directory called data. V tomto umístění se vytvoří a uloží datové soubory objektů BLOB.This is where the blob data files will be created and stored.

    mkdir data
    

Instalace balíčkuInstall the package

Otevřete pom.xml soubor v textovém editoru.Open the pom.xml file in your text editor. Přidejte následující prvek závislosti do skupiny závislostí.Add the following dependency element to the group of dependencies.

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

Nastavení aplikační architekturySet up the app framework

Z adresáře projektu:From the project directory:

  1. Přejděte do adresáře /Src/Main/Java/com/BLOBs/QuickstartNavigate to the /src/main/java/com/blobs/quickstart directory
  2. Otevřete soubor App. Java v editoru.Open the App.java file in your editor
  3. Odstranění System.out.println("Hello world!"); příkazuDelete the System.out.println("Hello world!"); statement
  4. Přidat import direktivyAdd import directives

Zde je kód:Here's the code:

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

Zkopírování přihlašovacích údajů z webu Azure PortalCopy your credentials from the Azure portal

Když ukázková aplikace odešle požadavek na Azure Storage, musí být ověřena.When the sample application makes a request to Azure Storage, it must be authorized. K autorizaci žádosti přidejte do aplikace přihlašovací údaje účtu úložiště jako připojovací řetězec.To authorize a request, add your storage account credentials to the application as a connection string. Přihlašovací údaje účtu úložiště zobrazíte pomocí následujícího postupu:View your storage account credentials by following these steps:

  1. Přihlaste se k portálu Azure Portal.Sign in to the Azure portal.

  2. Vyhledejte svůj účet úložiště.Locate your storage account.

  3. V části Nastavení v přehledu účtu úložiště vyberte Přístupové klíče.In the Settings section of the storage account overview, select Access keys. Tady se zobrazí přístupové klíče vašeho účtu a úplný připojovací řetězec pro jednotlivé klíče.Here, you can view your account access keys and the complete connection string for each key.

  4. V části key1 vyhledejte hodnotu Připojovací řetězec a výběrem tlačítka Kopírovat zkopírujte připojovací řetězec.Find the Connection string value under key1, and select the Copy button to copy the connection string. V dalším kroku přidáte hodnotu připojovacího řetězce do proměnné prostředí.You will add the connection string value to an environment variable in the next step.

    Snímek obrazovky ukazující zkopírování připojovacího řetězce z webu Azure Portal

Konfigurace připojovacího řetězce úložištěConfigure your storage connection string

Po zkopírování připojovacího řetězce ho zapište do nové proměnné prostředí na místním počítači, na kterém aplikaci spouštíte.After you have copied your connection string, write it to a new environment variable on the local machine running the application. Proměnnou prostředí nastavíte tak, že otevřete okno konzoly a budete postupovat podle pokynů pro váš operační systém.To set the environment variable, open a console window, and follow the instructions for your operating system. Nahraďte <yourconnectionstring> skutečným připojovacím řetězcem.Replace <yourconnectionstring> with your actual connection string.

WindowsWindows

setx AZURE_STORAGE_CONNECTION_STRING "<yourconnectionstring>"

Po přidání proměnné prostředí v systému Windows je nutné spustit novou instanci příkazového okna.After you add the environment variable in Windows, you must start a new instance of the command window.

LinuxLinux

export AZURE_STORAGE_CONNECTION_STRING="<yourconnectionstring>"

macOSmacOS

export AZURE_STORAGE_CONNECTION_STRING="<yourconnectionstring>"

Restartovat programyRestart programs

Po přidání proměnné prostředí restartujte všechny spuštěné programy, které budou muset číst proměnnou prostředí.After you add the environment variable, restart any running programs that will need to read the environment variable. Před pokračováním například restartujte vývojové prostředí nebo editor.For example, restart your development environment or editor before continuing.

Objektový modelObject model

Azure Blob Storage je optimalizovaná pro ukládání obrovských objemů nestrukturovaných dat.Azure Blob Storage is optimized for storing massive amounts of unstructured data. Jde o data, která nevyhovují konkrétnímu datovému modelu nebo definici, například textová nebo binární data.Unstructured data is data that does not adhere to a particular data model or definition, such as text or binary data. Úložiště objektů BLOB nabízí tři typy prostředků:Blob storage offers three types of resources:

  • Účet úložištěThe storage account
  • Kontejner v účtu úložištěA container in the storage account
  • Objekt BLOB v kontejneruA blob in the container

Na následujícím diagramu jsou vztahy těchto prostředků.The following diagram shows the relationship between these resources.

Diagram architektury služby Blob Storage

K interakci s těmito prostředky použijte následující třídy Java:Use the following Java classes to interact with these resources:

  • BlobServiceClient: BlobServiceClient Třída umožňuje manipulovat s Azure Storage prostředky a kontejnery objektů BLOB.BlobServiceClient: The BlobServiceClient class allows you to manipulate Azure Storage resources and blob containers. Účet úložiště poskytuje obor názvů nejvyšší úrovně pro Blob service.The storage account provides the top-level namespace for the Blob service.
  • BlobServiceClientBuilder: BlobServiceClientBuilder Třída poskytuje rozhraní API pro tvůrce Fluent, které pomáhá pomoci při konfiguraci a vytváření instancí BlobServiceClient objektů.BlobServiceClientBuilder: The BlobServiceClientBuilder class provides a fluent builder API to help aid the configuration and instantiation of BlobServiceClient objects.
  • BlobContainerClient: BlobContainerClient Třída umožňuje manipulovat s kontejnery Azure Storage a jejich objekty blob.BlobContainerClient: The BlobContainerClient class allows you to manipulate Azure Storage containers and their blobs.
  • BlobClient: BlobClient Třída umožňuje manipulovat s objekty blob Azure Storage.BlobClient: The BlobClient class allows you to manipulate Azure Storage blobs.
  • BlobItem: BlobItem Třída reprezentuje jednotlivé objekty blob vrácené voláním listBlobs.BlobItem: The BlobItem class represents individual blobs returned from a call to listBlobs.

Příklady kóduCode examples

V těchto ukázkových fragmentech kódu se dozvíte, jak provést následující s klientskou knihovnou Azure Blob Storage pro Java:These example code snippets show you how to perform the following with the Azure Blob Storage client library for Java:

Získání připojovacího řetězceGet the connection string

Následující kód načte připojovací řetězec pro účet úložiště z proměnné prostředí vytvořené v oddílu konfigurace vašeho připojovacího řetězce úložiště .The code below retrieves the connection string for the storage account from the environment variable created in the Configure your storage connection string section.

Přidejte tento kód do Main metody:Add this code inside the Main method:

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

Vytvoření kontejneruCreate a container

Určete název nového kontejneru.Decide on a name for the new container. Následující kód připojí hodnotu UUID k názvu kontejneru, aby bylo zajištěno, že je jedinečný.The code below appends a UUID value to the container name to ensure that it is unique.

Důležité

Názvy kontejnerů musí být malými písmeny.Container names must be lowercase. Další informace o pojmenování kontejnerů a objektů blob najdete v tématu Názvy kontejnerů, objektů blob a metadat a odkazování na ně.For more information about naming containers and blobs, see Naming and Referencing Containers, Blobs, and Metadata.

Dále vytvořte instanci třídy BlobContainerClient a potom zavolejte metodu Create , která ve skutečnosti vytvoří kontejner v účtu úložiště.Next, create an instance of the BlobContainerClient class, then call the create method to actually create the container in your storage account.

Přidejte tento kód na konec Main metody:Add this code to the end of the Main method:

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

Nahrání objektů blob do kontejneruUpload blobs to a container

Následující fragment kódu:The following code snippet:

  1. Vytvoří textový soubor v místním datovém adresáři.Creates a text file in the local data directory.
  2. Získá odkaz na objekt BlobClient voláním metody getBlobClient na kontejneru z oddílu vytvoření kontejneru .Gets a reference to a BlobClient object by calling the getBlobClient method on the container from the Create a container section.
  3. Nahraje místní textový soubor do objektu BLOB voláním metody uploadFromFile .Uploads the local text file to the blob by calling the uploadFromFile method. Tato metoda vytvoří objekt blob, pokud ještě neexistuje, ale nepřepíše jej, pokud k tomu dojde.This method creates the blob if it doesn't already exist, but will not overwrite it if it does.

Přidejte tento kód na konec Main metody:Add this code to the end of the Main method:

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

Seznam objektů blob v kontejneruList the blobs in a container

Seznam objektů BLOB v kontejneru zavoláním metody listBlobs .List the blobs in the container by calling the listBlobs method. V tomto případě byl do kontejneru přidán pouze jeden objekt blob, takže operace výpisu vrátí pouze jeden objekt BLOB.In this case, only one blob has been added to the container, so the listing operation returns just that one blob.

Přidejte tento kód na konec Main metody:Add this code to the end of the Main method:

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

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

Stáhnout objekty blobDownload blobs

Stáhněte dřív vytvořený objekt BLOB voláním metody downloadToFile .Download the previously created blob by calling the downloadToFile method. Vzorový kód přidá příponu "DOWNLOAD" do názvu souboru, aby bylo možné zobrazit oba soubory v místním systému souborů.The example code adds a suffix of "DOWNLOAD" to the file name so that you can see both files in local file system.

Přidejte tento kód na konec Main metody:Add this code to the end of the Main method:

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

Odstranění kontejneruDelete a container

Následující kód vyčistí prostředky, které aplikace vytvořila, odebráním celého kontejneru pomocí metody Delete .The following code cleans up the resources the app created by removing the entire container using the delete method. Odstraní také místní soubory vytvořené aplikací.It also deletes the local files created by the app.

Aplikace pozastaví vstup uživatele voláním System.console().readLine() před odstraněním objektu blob, kontejneru a místních souborů.The app pauses for user input by calling System.console().readLine() before it deletes the blob, container, and local files. Tato možnost je vhodná pro ověření, že se prostředky správně vytvořily, než se odstraní.This is a good chance to verify that the resources were created correctly, before they are deleted.

Přidejte tento kód na konec Main metody:Add this code to the end of the Main method:

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

Spuštění kóduRun the code

Tato aplikace vytvoří testovací soubor v místní složce a nahraje ho do úložiště objektů BLOB.This app creates a test file in your local folder and uploads it to Blob storage. Příklad zobrazí seznam objektů BLOB v kontejneru a stáhne soubor s novým názvem, abyste mohli porovnat staré a nové soubory.The example then lists the blobs in the container and downloads the file with a new name so that you can compare the old and new files.

Přejděte do adresáře obsahujícího soubor pom.xml a zkompilujte projekt pomocí následujícího mvn příkazu.Navigate to the directory containing the pom.xml file and compile the project by using the following mvn command.

mvn compile

Pak Sestavte balíček.Then, build the package.

mvn package

Spusťte následující mvn příkaz, který aplikaci spustí.Run the following mvn command to execute the app.

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

Výstup aplikace je podobný následujícímu příkladu:The output of the app is similar to the following example:

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

Než zahájíte proces vyčištění, vyhledejte tyto dva soubory ve složce dat .Before you begin the clean up process, check your data folder for the two files. Můžete je otevřít a podívat se, že jsou identické.You can open them and observe that they are identical.

Po ověření souborů stiskněte klávesu ENTER , aby se odstranily soubory testu, a dokončete ukázku.After you've verified the files, press the Enter key to delete the test files and finish the demo.

Další krokyNext steps

V tomto rychlém startu jste zjistili, jak nahrávat, stahovat a vypisovat objekty BLOB pomocí Java.In this quickstart, you learned how to upload, download, and list blobs using Java.

Pokud chcete zobrazit ukázkové aplikace služby Blob Storage, pokračujte:To see Blob storage sample apps, continue to: