Condividi tramite

Usare Java per gestire directory e file in Azure Data Lake Storage

  • Articolo

Questo articolo illustra come usare Java per creare e gestire directory e file negli account di archiviazione con uno spazio dei nomi gerarchico.

Per informazioni su come ottenere, impostare e aggiornare gli elenchi di controllo di accesso (ACL) di directory e file, vedere Usare . Java per gestire gli elenchi di controllo di accesso in Azure Data Lake Storage.

Pacchetto (Maven) | Esempi | Riferimento API | Mapping da Gen1 a Gen2 | Fornisci feedback

Prerequisiti

  • Una sottoscrizione di Azure. Per altre informazioni, vedere Ottenere la versione di valutazione gratuita di Azure.

  • Un account di archiviazione con spazio dei nomi gerarchico abilitato. Per crearne uno, seguire queste istruzioni.

Impostare il progetto

Per iniziare, aprire questa pagina e trovare la versione più recente della libreria Java. Aprire quindi il file pom.xml nell'editor di testo. Aggiungere un elemento di dipendenza che fa riferimento a tale versione.

Se si prevede di autenticare l'applicazione client usando Microsoft Entra ID, aggiungere una dipendenza alla libreria di identità di Azure. Per altre informazioni, vedere Libreria client di Identità di Azure per Java.

Aggiungere quindi queste istruzioni imports al file di codice.

import com.azure.identity.*;
import com.azure.storage.common.StorageSharedKeyCredential;
import com.azure.core.http.rest.PagedIterable;
import com.azure.core.util.BinaryData;
import com.azure.storage.file.datalake.*;
import com.azure.storage.file.datalake.models.*;
import com.azure.storage.file.datalake.options.*;

Nota

L'accesso multi-protocollo in Data Lake Storage consente alle applicazioni di usare sia le API BLOB che le API Data Lake Storage Gen2 per lavorare con i dati negli account di archiviazione con spazio dei nomi gerarchico (HNS) abilitato. Quando si usano funzionalità specifiche di Data Lake Storage Gen2, ad esempio operazioni di directory e ACL, usare le API data Lake Storage Gen2, come illustrato in questo articolo.

Quando si scelgono le API da usare in uno scenario specifico, prendere in considerazione il carico di lavoro e le esigenze dell'applicazione, insieme ai problemi noti e all'impatto di HNS su carichi di lavoro e applicazioni.

Autorizzare l'accesso e connettersi alle risorse dati

Per usare gli esempi di codice in questo articolo, è necessario creare un'istanza di DataLakeServiceClient autorizzata che rappresenta l'account di archiviazione. È possibile autorizzare un DataLakeServiceClient oggetto usando l'ID Microsoft Entra, una chiave di accesso all'account o una firma di accesso condiviso.

È possibile usare la libreria client di identità di Azure per Java per autenticare l'applicazione con Microsoft Entra ID.

Creare un'istanza di DataLakeServiceClient e passare una nuova istanza della classe DefaultAzureCredential .

static public DataLakeServiceClient GetDataLakeServiceClient(String accountName){
    DefaultAzureCredential defaultCredential = new DefaultAzureCredentialBuilder().build();

    DataLakeServiceClient dataLakeServiceClient = new DataLakeServiceClientBuilder()
        .endpoint("https://" + accountName + ".dfs.core.windows.net")
        .credential(defaultCredential)
        .buildClient();

    return dataLakeServiceClient;
}

Per altre informazioni sull'uso di DefaultAzureCredential per autorizzare l'accesso ai dati, vedere Libreria client di Identità di Azure per Java.

Creazione di un contenitore

Un contenitore funge da file system per i file. È possibile creare un contenitore usando il metodo seguente:

Nell'esempio di codice seguente viene creato un contenitore e viene restituito un oggetto DataLakeFileSystemClient per un uso successivo:

public DataLakeFileSystemClient CreateFileSystem(
        DataLakeServiceClient serviceClient,
        String fileSystemName) {

    DataLakeFileSystemClient fileSystemClient = serviceClient.createFileSystem(fileSystemName);

    return fileSystemClient;
}

Creare una directory

È possibile creare un riferimento alla directory nel contenitore usando il metodo seguente:

L'esempio di codice seguente aggiunge una directory a un contenitore, quindi aggiunge una sottodirectory e restituisce un oggetto DataLakeDirectoryClient per un uso successivo:

public DataLakeDirectoryClient CreateDirectory(
        DataLakeFileSystemClient fileSystemClient,
        String directoryName,
        String subDirectoryName) {

    DataLakeDirectoryClient directoryClient = fileSystemClient.createDirectory(directoryName);

    return directoryClient.createSubdirectory(subDirectoryName);
}

Rinominare o spostare una directory

È possibile rinominare o spostare una directory usando il metodo seguente:

Passare il percorso della directory desiderata come parametro. L'esempio di codice seguente illustra come rinominare una sottodirectory:

public DataLakeDirectoryClient RenameDirectory(
        DataLakeFileSystemClient fileSystemClient,
        String directoryPath,
        String subdirectoryName,
        String subdirectoryNameNew) {

    DataLakeDirectoryClient directoryClient = fileSystemClient
            .getDirectoryClient(String.join("/", directoryPath, subdirectoryName));

    return directoryClient.rename(
            fileSystemClient.getFileSystemName(),
            String.join("/", directoryPath, subdirectoryNameNew));
}

Nell'esempio di codice seguente viene illustrato come spostare una sottodirectory da una directory a una directory diversa:

public DataLakeDirectoryClient MoveDirectory(
        DataLakeFileSystemClient fileSystemClient,
        String directoryPathFrom,
        String directoryPathTo,
        String subdirectoryName) {

    DataLakeDirectoryClient directoryClient = fileSystemClient
            .getDirectoryClient(String.join("/", directoryPathFrom, subdirectoryName));

    return directoryClient.rename(
            fileSystemClient.getFileSystemName(),
            String.join("/", directoryPathTo, subdirectoryName));
}

Caricare un file in una directory

È possibile caricare contenuto in un file nuovo o esistente usando il metodo seguente:

L'esempio di codice seguente illustra come caricare un file locale in una directory usando il uploadFromFile metodo :

public void UploadFile(
        DataLakeDirectoryClient directoryClient,
        String fileName) {

    DataLakeFileClient fileClient = directoryClient.getFileClient(fileName);

    fileClient.uploadFromFile("filePath/sample-file.txt");
}

È possibile usare questo metodo per creare e caricare contenuto in un nuovo file oppure impostare il overwrite parametro su true per sovrascrivere un file esistente.

Accodare dati a un file

È possibile caricare i dati da aggiungere a un file usando il metodo seguente:

Nell'esempio di codice seguente viene illustrato come aggiungere dati alla fine di un file attenendosi alla procedura seguente:

  • Creare un DataLakeFileClient oggetto per rappresentare la risorsa file con cui si sta lavorando.
  • Caricare i dati nel file usando il DataLakeFileClient.append metodo .
  • Completare il caricamento chiamando il DataLakeFileClient.flush metodo per scrivere i dati caricati in precedenza nel file.
public void AppendDataToFile(
        DataLakeDirectoryClient directoryClient) {

    DataLakeFileClient fileClient = directoryClient.getFileClient("sample-file.txt");
    long fileSize = fileClient.getProperties().getFileSize();

    String sampleData = "Data to append to end of file";
    fileClient.append(BinaryData.fromString(sampleData), fileSize);

    fileClient.flush(fileSize + sampleData.length(), true);
}

Scaricare da una directory

Nell'esempio di codice seguente viene illustrato come scaricare un file da una directory in un file locale attenendosi alla procedura seguente:

  • Creare un DataLakeFileClient oggetto per rappresentare il file da scaricare.
  • Usare il DataLakeFileClient.readToFile metodo per leggere il file. In questo esempio il overwrite parametro viene impostato su true, che sovrascrive un file esistente.
public void DownloadFile(
        DataLakeDirectoryClient directoryClient,
        String fileName) {

    DataLakeFileClient fileClient = directoryClient.getFileClient(fileName);

    fileClient.readToFile("filePath/sample-file.txt", true);
}

Elencare il contenuto della directory

È possibile elencare il contenuto della directory usando il metodo seguente ed enumerando il risultato:

L'enumerazione dei percorsi nel risultato può effettuare più richieste al servizio durante il recupero dei valori.

L'esempio di codice seguente stampa i nomi di ogni file che si trova in una directory:

public void ListFilesInDirectory(
        DataLakeFileSystemClient fileSystemClient,
        String directoryName) {

    ListPathsOptions options = new ListPathsOptions();
    options.setPath(directoryName);

    PagedIterable<PathItem> pagedIterable = fileSystemClient.listPaths(options, null);

    java.util.Iterator<PathItem> iterator = pagedIterable.iterator();
    PathItem item = iterator.next();

    while (item != null) {
        System.out.println(item.getName());

        if (!iterator.hasNext()) {
            break;
        }
        item = iterator.next();
    }

}

Eliminare una directory

È possibile eliminare una directory usando uno dei metodi seguenti:

Nell'esempio di codice seguente viene deleteWithResponse usato per eliminare una directory nonempty e tutti i percorsi sotto la directory:

public void DeleteDirectory(
        DataLakeFileSystemClient fileSystemClient,
        String directoryName) {

    DataLakeDirectoryClient directoryClient = fileSystemClient.getDirectoryClient(directoryName);

    // Set to true to delete all paths beneath the directory
    boolean recursive = true;

    directoryClient.deleteWithResponse(recursive, null, null, null);
}

Vedi anche