Come usare l'archiviazione tabelle di Azure o l'API Tabelle di Azure Cosmos DB da JavaHow to use Azure Table storage or Azure Cosmos DB Table API from Java

Suggerimento

Il contenuto di questo articolo è applicabile al servizio di archiviazione tabelle di Azure e all'API Tabelle di Azure Cosmos DB.The content in this article applies to Azure Table storage and the Azure Cosmos DB Table API. L'API Tabelle di Azure Cosmos DB è un'offerta Premium per il servizio di archiviazione tabelle, che include tabelle con ottimizzazione per la velocità effettiva, distribuzione globale e indici secondari automatici.The Azure Cosmos DB Table API is a premium offering for table storage that offers throughput-optimized tables, global distribution, and automatic secondary indexes.

PanoramicaOverview

Questo articolo illustra come eseguire scenari comuni usando il servizio di archiviazione tabelle di Azure e Azure Cosmos DB.This article demonstrates how to perform common scenarios using the Azure Table storage service and Azure Cosmos DB. Gli esempi sono scritti in Java e usano Azure Storage SDK per Java.The samples are written in Java and use the Azure Storage SDK for Java. Gli scenari presentati includono creazione, visualizzazione di un elenco ed eliminazione di tabelle, nonché inserimento, esecuzione di query, modifica ed eliminazione di entità in una tabella.The scenarios covered include creating, listing, and deleting tables, as well as inserting, querying, modifying, and deleting entities in a table. Per altre informazioni sulle tabelle, vedere la sezione Passaggi successivi .For more information on tables, see the Next steps section.

Nota

per gli sviluppatori che usano il servizio di archiviazione di Azure in dispositivi Android, è disponibile un SDK specifico.An SDK is available for developers who are using Azure Storage on Android devices. Per altre informazioni, vedere Azure Storage SDK per Android.For more information, see the Azure Storage SDK for Android.

Creare un account del servizio di AzureCreate an Azure service account

È possibile usare tabelle con l'archiviazione tabelle di Azure o con Azure Cosmos DB.You can work with tables using Azure Table storage or Azure Cosmos DB. Per altre informazioni sulle differenze tra i servizi, vedere Offerte per tabelle.You can learn more about the differences between the services by reading Table offerings. Sarà necessario creare un account per il servizio che si intende usare.You'll need to create an account for the service you're going to use.

Creare un account di archiviazione di AzureCreate an Azure storage account

Il modo più semplice per creare il primo account di archiviazione di Azure consiste nell'usare il portale di Azure.The easiest way to create your first Azure storage account is by using the Azure portal. Per altre informazioni, vedere Creare un account di archiviazione.To learn more, see Create a storage account.

È possibile anche creare un account di archiviazione di Azure usando Azure PowerShell o l'interfaccia della riga di comando di Azure.You can also create an Azure storage account by using Azure PowerShell or Azure CLI.

Se si preferisce non creare un account di archiviazione in questa fase, è anche possibile usare l'emulatore di archiviazione di Azure per eseguire e testare il codice in un ambiente locale.If you prefer not to create a storage account at this time, you can also use the Azure storage emulator to run and test your code in a local environment. Per altre informazioni, vedere Usare l'emulatore di archiviazione di Azure per sviluppo e test.For more information, see Use the Azure Storage Emulator for Development and Testing.

Creare un account Azure Cosmos DBCreate an Azure Cosmos DB account

Per istruzioni per la creazione di un account per l'API di tabella di Azure Cosmos DB, vedere Creare un account per un'API di tabella.For instructions on creating an Azure Cosmos DB Table API account, see Create a Table API account.

Creare un'applicazione JavaCreate a Java application

In questa guida si utilizzeranno le funzionalità di archiviazione che possono essere eseguite in un'applicazione Java in locale o nel codice in esecuzione in un ruolo Web o in un ruolo di lavoro in Azure.In this guide, you will use storage features that you can run in a Java application locally, or in code running in a web role or worker role in Azure.

Per usare gli esempi in questo articolo, installare Java Development Kit (JDK) e creare un account di archiviazione di Azure o un account di Azure Cosmos DB nella sottoscrizione di Azure.To use the samples in this article, install the Java Development Kit (JDK), then create an Azure storage account or Azure Cosmos DB account in your Azure subscription. Dopo avere eseguito questa operazione, verificare che il sistema di sviluppo in uso soddisfi i requisiti minimi e le dipendenze elencate nel repository Azure Storage SDK per Java su GitHub.Once you have done so, verify that your development system meets the minimum requirements and dependencies that are listed in the Azure Storage SDK for Java repository on GitHub. Se il sistema soddisfa i requisiti, è possibile seguire le istruzioni per scaricare e installare le librerie di Archiviazione di Azure per Java nel sistema dal repository indicato.If your system meets those requirements, you can follow the instructions to download and install the Azure Storage Libraries for Java on your system from that repository. Dopo avere completato queste attività, è possibile creare un'applicazione Java che usa gli esempi in questo articolo.After you complete those tasks, you can create a Java application that uses the examples in this article.

Configurare l'applicazione per l'accesso all'archiviazione tabelleConfigure your application to access table storage

Aggiungere le istruzioni import seguenti all'inizio del file Java in cui si desidera usare le API di archiviazione di Azure o l'API Tabelle di Azure Cosmos DB per accedere alle tabelle:Add the following import statements to the top of the Java file where you want to use Azure storage APIs or the Azure Cosmos DB Table API to access tables:

// Include the following imports to use table APIs
import com.microsoft.azure.storage.*;
import com.microsoft.azure.storage.table.*;
import com.microsoft.azure.storage.table.TableQuery.*;

Aggiungere una stringa di connessione di archiviazione di AzureAdd an Azure storage connection string

I client di archiviazione di Azure usano le stringhe di connessione di archiviazione per archiviare endpoint e credenziali per l'accesso ai servizi di gestione dati.An Azure storage client uses a storage connection string to store endpoints and credentials for accessing data management services. Quando si esegue un'applicazione client, è necessario specificare la stringa di connessione di archiviazione nel formato seguente, usando il nome dell'account di archiviazione e la chiave di accesso primaria relativa all'account di archiviazione riportata nel portale di Azure per i valori AccountName e AccountKey.When running in a client application, you must provide the storage connection string in the following format, using the name of your storage account and the Primary access key for the storage account listed in the Azure portal for the AccountName and AccountKey values.

In questo esempio viene illustrato come dichiarare un campo statico per memorizzare la stringa di connessione:This example shows how you can declare a static field to hold the connection string:

// Define the connection-string with your values.
public static final String storageConnectionString =
    "DefaultEndpointsProtocol=http;" +
    "AccountName=your_storage_account;" +
    "AccountKey=your_storage_account_key";

Aggiungere una stringa di connessione dell'API Tabelle di Azure Cosmos DBAdd an Azure Cosmos DB Table API connection string

Un account di Azure Cosmos DB usa una stringa di connessione per archiviare l'endpoint della tabella e le credenziali.An Azure Cosmos DB account uses a connection string to store the table endpoint and your credentials. Quando si esegue un'applicazione client, è necessario specificare la stringa di connessione di Azure Cosmos DB nel formato seguente, usando il nome dell'account di Azure Cosmos DB e la chiave di accesso primaria relativa all'account riportata nel portale di Azure per i valori AccountName e AccountKey.When running in a client application, you must provide the Azure Cosmos DB connection string in the following format, using the name of your Azure Cosmos DB account and the primary access key for the account listed in the Azure portal for the AccountName and AccountKey values.

Questo esempio illustra come dichiarare un campo statico per memorizzare la stringa di connessione di Azure Cosmos DB:This example shows how you can declare a static field to hold the Azure Cosmos DB connection string:

public static final String storageConnectionString =
    "DefaultEndpointsProtocol=https;" + 
    "AccountName=your_cosmosdb_account;" + 
    "AccountKey=your_account_key;" + 
    "TableEndpoint=https://your_endpoint;" ;

In un'applicazione in esecuzione in un ruolo di Azure, questa stringa può essere archiviata nel file di configurazione del servizio, ServiceConfiguration.cscfg, ed è accessibile con una chiamata al metodo RoleEnvironment.getConfigurationSettings.In an application running within a role in Azure, you can store this string in the service configuration file, ServiceConfiguration.cscfg, and you can access it with a call to the RoleEnvironment.getConfigurationSettings method. Nell'esempio seguente viene recuperata la stringa di connessione da un elemento Setting denominato StorageConnectionString nel file di configurazione del servizio:Here's an example of getting the connection string from a Setting element named StorageConnectionString in the service configuration file:

// Retrieve storage account from connection-string.
String storageConnectionString =
    RoleEnvironment.getConfigurationSettings().get("StorageConnectionString");

È anche possibile archiviare la stringa di connessione nel file config.properties del progetto:You can also store your connection string in your project's config.properties file:

StorageConnectionString = DefaultEndpointsProtocol=https;AccountName=your_account;AccountKey=your_account_key;TableEndpoint=https://your_table_endpoint/

Gli esempi seguenti presumono che sia stato usato uno di questi metodi per ottenere la stringa di connessione di archiviazione.The following samples assume that you have used one of these methods to get the storage connection string.

Creare una tabellaCreate a table

Per ottenere oggetti di riferimento per tabelle ed entità, è possibile usare un oggetto CloudTableClient.A CloudTableClient object lets you get reference objects for tables and entities. Il codice seguente consente di creare un oggetto CloudTableClient e di usarlo per creare un oggetto CloudTable che rappresenta una tabella denominata "people".The following code creates a CloudTableClient object and uses it to create a new CloudTable object which represents a table named "people".

Nota

Esistono altri modi per creare oggetti CloudStorageAccount. Per altre informazioni, vedere CloudStorageAccount nel Riferimento all'SDK del client di Archiviazione di Azure.There are other ways to create CloudStorageAccount objects; for more information, see CloudStorageAccount in the Azure Storage Client SDK Reference).

try
{
    // Retrieve storage account from connection-string.
    CloudStorageAccount storageAccount =
        CloudStorageAccount.parse(storageConnectionString);

    // Create the table client.
    CloudTableClient tableClient = storageAccount.createCloudTableClient();

    // Create the table if it doesn't exist.
    String tableName = "people";
    CloudTable cloudTable = tableClient.getTableReference(tableName);
    cloudTable.createIfNotExists();
}
catch (Exception e)
{
    // Output the stack trace.
    e.printStackTrace();
}

Elencare le tabelleList the tables

Per ottenere un elenco di tabelle, chiamare il metodo CloudTableClient.listTables() per recuperare un elenco iterabile di nomi di tabelle.To get a list of tables, call the CloudTableClient.listTables() method to retrieve an iterable list of table names.

try
{
    // Retrieve storage account from connection-string.
    CloudStorageAccount storageAccount =
        CloudStorageAccount.parse(storageConnectionString);

    // Create the table client.
    CloudTableClient tableClient = storageAccount.createCloudTableClient();

    // Loop through the collection of table names.
    for (String table : tableClient.listTables())
    {
        // Output each table name.
        System.out.println(table);
    }
}
catch (Exception e)
{
    // Output the stack trace.
    e.printStackTrace();
}

Aggiungere un'entità a una tabellaAdd an entity to a table

Per eseguire il mapping di entità a oggetti Java viene utilizzata una classe personalizzata che implementa TableEntity.Entities map to Java objects using a custom class implementing TableEntity. Per comodità, la classe TableServiceEntity implementa TableEntity e usa la reflection per eseguire il mapping di proprietà ai metodi Get e Set denominati per le proprietà.For convenience, the TableServiceEntity class implements TableEntity and uses reflection to map properties to getter and setter methods named for the properties. Per aggiungere un'entità a una classe, creare prima una classe che definisca le proprietà dell'entità.To add an entity to a table, first create a class that defines the properties of your entity. Il codice seguente consente di definire una classe di entità che usa il nome e il cognome del cliente rispettivamente come chiave di riga e chiave di partizione.The following code defines an entity class that uses the customer's first name as the row key, and last name as the partition key. La combinazione della chiave di riga e della chiave di partizione di un'entità consentono di identificare in modo univoco l'entità nella tabella.Together, an entity's partition and row key uniquely identify the entity in the table. Le query su entità con la stessa chiave di partizione vengono eseguite più rapidamente di quelle con chiavi di partizione diverse.Entities with the same partition key can be queried faster than those with different partition keys.

public class CustomerEntity extends TableServiceEntity {
    public CustomerEntity(String lastName, String firstName) {
        this.partitionKey = lastName;
        this.rowKey = firstName;
    }

    public CustomerEntity() { }

    String email;
    String phoneNumber;

    public String getEmail() {
        return this.email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getPhoneNumber() {
        return this.phoneNumber;
    }

    public void setPhoneNumber(String phoneNumber) {
        this.phoneNumber = phoneNumber;
    }
}

Per le operazioni su tabella che interessano entità è necessario un oggetto TableServiceContext .Table operations involving entities require a TableOperation object. Questo oggetto definisce l'operazione da eseguire su un'entità, che può essere eseguita con un oggetto CloudTable .This object defines the operation to be performed on an entity, which can be executed with a CloudTable object. Il codice seguente crea una nuova istanza della classe CustomerEntity con alcuni dati del cliente da memorizzare.The following code creates a new instance of the CustomerEntity class with some customer data to be stored. Il codice chiama quindi TableOperation.insertOrReplace per creare un oggetto TableOperation in modo da inserire un'entità in una tabella e vi associa la nuova classe CustomerEntity.The code next calls TableOperation.insertOrReplace to create a TableOperation object to insert an entity into a table, and associates the new CustomerEntity with it. Infine, il codice chiama il metodo execute sull'oggetto CloudTable, specificando la tabella "people" e il nuovo oggetto TableOperation, che quindi invia una richiesta al servizio di archiviazione per inserire la nuova entità cliente nella tabella "people" o sostituire l'entità se ne esiste già una.Finally, the code calls the execute method on the CloudTable object, specifying the "people" table and the new TableOperation, which then sends a request to the storage service to insert the new customer entity into the "people" table, or replace the entity if it already exists.

try
{
    // Retrieve storage account from connection-string.
    CloudStorageAccount storageAccount =
        CloudStorageAccount.parse(storageConnectionString);

    // Create the table client.
    CloudTableClient tableClient = storageAccount.createCloudTableClient();

    // Create a cloud table object for the table.
    CloudTable cloudTable = tableClient.getTableReference("people");

    // Create a new customer entity.
    CustomerEntity customer1 = new CustomerEntity("Harp", "Walter");
    customer1.setEmail("Walter@contoso.com");
    customer1.setPhoneNumber("425-555-0101");

    // Create an operation to add the new customer to the people table.
    TableOperation insertCustomer1 = TableOperation.insertOrReplace(customer1);

    // Submit the operation to the table service.
    cloudTable.execute(insertCustomer1);
}
catch (Exception e)
{
    // Output the stack trace.
    e.printStackTrace();
}

Inserire un batch di entitàInsert a batch of entities

Per inserire un batch di entità nel servizio tabelle, è possibile usare un'unica operazione di scrittura.You can insert a batch of entities to the table service in one write operation. Il codice seguente crea un oggetto TableBatchOperation quindi vi aggiunge tre operazioni di inserimento.The following code creates a TableBatchOperation object, then adds three insert operations to it. Ciascuna operazione di inserimento viene aggiunta creando un nuovo oggetto entità, impostandone i valori, quindi chiamando il metodo insert sull'oggetto TableBatchOperation per associare l'entità a una nuova operazione di inserimento.Each insert operation is added by creating a new entity object, setting its values, and then calling the insert method on the TableBatchOperation object to associate the entity with a new insert operation. Il codice chiama quindi il metodo execute sull'oggetto CloudTable, specificando la tabella "people" e l'oggetto TableBatchOperation, che invia il batch di operazioni su tabella al servizio di archiviazione in un'unica richiesta.Then the code calls execute on the CloudTable object, specifying the "people" table and the TableBatchOperation object, which sends the batch of table operations to the storage service in a single request.

try
{
    // Retrieve storage account from connection-string.
    CloudStorageAccount storageAccount =
        CloudStorageAccount.parse(storageConnectionString);

    // Create the table client.
    CloudTableClient tableClient = storageAccount.createCloudTableClient();

    // Define a batch operation.
    TableBatchOperation batchOperation = new TableBatchOperation();

    // Create a cloud table object for the table.
    CloudTable cloudTable = tableClient.getTableReference("people");

    // Create a customer entity to add to the table.
    CustomerEntity customer = new CustomerEntity("Smith", "Jeff");
    customer.setEmail("Jeff@contoso.com");
    customer.setPhoneNumber("425-555-0104");
    batchOperation.insertOrReplace(customer);

    // Create another customer entity to add to the table.
    CustomerEntity customer2 = new CustomerEntity("Smith", "Ben");
    customer2.setEmail("Ben@contoso.com");
    customer2.setPhoneNumber("425-555-0102");
    batchOperation.insertOrReplace(customer2);

    // Create a third customer entity to add to the table.
    CustomerEntity customer3 = new CustomerEntity("Smith", "Denise");
    customer3.setEmail("Denise@contoso.com");
    customer3.setPhoneNumber("425-555-0103");
    batchOperation.insertOrReplace(customer3);

    // Execute the batch of operations on the "people" table.
    cloudTable.execute(batchOperation);
}
catch (Exception e)
{
    // Output the stack trace.
    e.printStackTrace();
}

Di seguito sono riportate alcune informazioni sulle operazioni batch:Some things to note on batch operations:

  • È possibile eseguire fino a 100 operazioni di inserimento, eliminazione, unione, sostituzione, inserimento o unione e inserimento o sostituzione in qualsiasi combinazione in un unico batch.You can perform up to 100 insert, delete, merge, replace, insert or merge, and insert or replace operations in any combination in a single batch.
  • Un'operazione batch può prevedere un'operazione di recupero, se è l'unica operazione nel batch.A batch operation can have a retrieve operation, if it is the only operation in the batch.
  • A tutte le entità di una singola operazione batch deve essere associata la stessa chiave di partizione.All entities in a single batch operation must have the same partition key.
  • Un'operazione batch è limitata a un payload di dati di 4 MB.A batch operation is limited to a 4MB data payload.

Recuperare tutte le entità di una partizioneRetrieve all entities in a partition

Per eseguire una query su una tabella relativa alle entità in una partizione è possibile utilizzare TableQuery.To query a table for entities in a partition, you can use a TableQuery. Chiamare TableQuery.from per creare su una particolare tabella una query che restituisca un tipo di risultato specificato.Call TableQuery.from to create a query on a particular table that returns a specified result type. Nel codice seguente viene specificato un filtro per le entità in cui la chiave di partizione è 'Smith'.The following code specifies a filter for entities where 'Smith' is the partition key. TableQuery.generateFilterCondition è un metodo helper che consente di creare filtri per le query.TableQuery.generateFilterCondition is a helper method to create filters for queries. Chiamare where sul riferimento restituito dal metodo TableQuery.from per applicare il filtro alla query.Call where on the reference returned by the TableQuery.from method to apply the filter to the query. Quando la query viene eseguita con una chiamata a execute sull'oggetto CloudTable restituisce un oggetto Iterator con il tipo di risultato CustomerEntity specificato.When the query is executed with a call to execute on the CloudTable object, it returns an Iterator with the CustomerEntity result type specified. Per usufruire dei risultati, è quindi possibile utilizzare l'oggetto Iterator restituito in ogni ciclo.You can then use the Iterator returned in a for each loop to consume the results. Il codice seguente consente di stampare sulla console i campi di ogni entità inclusa nei risultati della query.This code prints the fields of each entity in the query results to the console.

try
{
    // Define constants for filters.
    final String PARTITION_KEY = "PartitionKey";
    final String ROW_KEY = "RowKey";
    final String TIMESTAMP = "Timestamp";

    // Retrieve storage account from connection-string.
    CloudStorageAccount storageAccount =
        CloudStorageAccount.parse(storageConnectionString);

    // Create the table client.
    CloudTableClient tableClient = storageAccount.createCloudTableClient();

    // Create a cloud table object for the table.
    CloudTable cloudTable = tableClient.getTableReference("people");

    // Create a filter condition where the partition key is "Smith".
    String partitionFilter = TableQuery.generateFilterCondition(
        PARTITION_KEY,
        QueryComparisons.EQUAL,
        "Smith");

    // Specify a partition query, using "Smith" as the partition key filter.
    TableQuery<CustomerEntity> partitionQuery =
        TableQuery.from(CustomerEntity.class)
        .where(partitionFilter);

    // Loop through the results, displaying information about the entity.
    for (CustomerEntity entity : cloudTable.execute(partitionQuery)) {
        System.out.println(entity.getPartitionKey() +
            " " + entity.getRowKey() +
            "\t" + entity.getEmail() +
            "\t" + entity.getPhoneNumber());
    }
}
catch (Exception e)
{
    // Output the stack trace.
    e.printStackTrace();
}

Recuperare un intervallo di entità in una partizioneRetrieve a range of entities in a partition

Se non si desidera eseguire una query su tutte le entità di una partizione, è possibile specificare un intervallo usando gli operatori di confronto in un filtro.If you don't want to query all the entities in a partition, you can specify a range by using comparison operators in a filter. Nel codice seguente vengono combinati due filtri per recuperare tutte le entità della partizione "Smith" in cui la chiave di riga (nome) inizia con una lettera che precede la 'E' nell'alfabetoThe following code combines two filters to get all entities in partition "Smith" where the row key (first name) starts with a letter up to 'E' in the alphabet. e quindi stampare i risultati della query.Then it prints the query results. Se si utilizzano le entità aggiunte alla tabella nella sezione di inserimento batch di questa guida, questa volta verranno restituite solo due entità, ovvero Ben e Denise Smith, mentre Jeff Smith non sarà incluso.If you use the entities added to the table in the batch insert section of this guide, only two entities are returned this time (Ben and Denise Smith); Jeff Smith is not included.

try
{
    // Define constants for filters.
    final String PARTITION_KEY = "PartitionKey";
    final String ROW_KEY = "RowKey";
    final String TIMESTAMP = "Timestamp";

    // Retrieve storage account from connection-string.
    CloudStorageAccount storageAccount =
        CloudStorageAccount.parse(storageConnectionString);

    // Create the table client.
    CloudTableClient tableClient = storageAccount.createCloudTableClient();

    // Create a cloud table object for the table.
    CloudTable cloudTable = tableClient.getTableReference("people");

    // Create a filter condition where the partition key is "Smith".
    String partitionFilter = TableQuery.generateFilterCondition(
        PARTITION_KEY,
        QueryComparisons.EQUAL,
        "Smith");

    // Create a filter condition where the row key is less than the letter "E".
    String rowFilter = TableQuery.generateFilterCondition(
        ROW_KEY,
        QueryComparisons.LESS_THAN,
        "E");

    // Combine the two conditions into a filter expression.
    String combinedFilter = TableQuery.combineFilters(partitionFilter,
        Operators.AND, rowFilter);

    // Specify a range query, using "Smith" as the partition key,
    // with the row key being up to the letter "E".
    TableQuery<CustomerEntity> rangeQuery =
        TableQuery.from(CustomerEntity.class)
        .where(combinedFilter);

    // Loop through the results, displaying information about the entity
    for (CustomerEntity entity : cloudTable.execute(rangeQuery)) {
        System.out.println(entity.getPartitionKey() +
            " " + entity.getRowKey() +
            "\t" + entity.getEmail() +
            "\t" + entity.getPhoneNumber());
    }
}
catch (Exception e)
{
    // Output the stack trace.
    e.printStackTrace();
}

Recuperare una singola entitàRetrieve a single entity

Per recuperare una singola entità specifica, è possibile scrivere una query.You can write a query to retrieve a single, specific entity. Il codice seguente chiama TableOperation.retrieve con i parametri della chiave di partizione e della chiave di riga per specificare il cliente "Jeff Smith", invece di creare un oggetto TableQuery e usare filtri per eseguire la stessa operazione.The following code calls TableOperation.retrieve with partition key and row key parameters to specify the customer "Jeff Smith", instead of creating a TableQuery and using filters to do the same thing. Quando si esegue l'operazione di recupero viene restituita una sola entità piuttosto che una raccolta.When executed, the retrieve operation returns just one entity, rather than a collection. Il metodo getResultAsType esegue il cast del risultato al tipo di destinazione dell'assegnazione, un oggetto CustomerEntity.The getResultAsType method casts the result to the type of the assignment target, a CustomerEntity object. Se questo tipo non è compatibile con il tipo specificato per la query, viene generata un'eccezione.If this type is not compatible with the type specified for the query, an exception is thrown. Viene restituito un valore Null se per nessuna entità è disponibile una corrispondenza esatta di chiave di riga e chiave di partizione.A null value is returned if no entity has an exact partition and row key match. La specifica delle chiavi di partizione e di riga in una query costituisce la soluzione più rapida per recuperare una singola entità dal servizio tabelle.Specifying both partition and row keys in a query is the fastest way to retrieve a single entity from the Table service.

try
{
    // Retrieve storage account from connection-string.
    CloudStorageAccount storageAccount =
        CloudStorageAccount.parse(storageConnectionString);

    // Create the table client.
    CloudTableClient tableClient = storageAccount.createCloudTableClient();

    // Create a cloud table object for the table.
    CloudTable cloudTable = tableClient.getTableReference("people");

    // Retrieve the entity with partition key of "Smith" and row key of "Jeff"
    TableOperation retrieveSmithJeff =
        TableOperation.retrieve("Smith", "Jeff", CustomerEntity.class);

    // Submit the operation to the table service and get the specific entity.
    CustomerEntity specificEntity =
        cloudTable.execute(retrieveSmithJeff).getResultAsType();

    // Output the entity.
    if (specificEntity != null)
    {
        System.out.println(specificEntity.getPartitionKey() +
            " " + specificEntity.getRowKey() +
            "\t" + specificEntity.getEmail() +
            "\t" + specificEntity.getPhoneNumber());
    }
}
catch (Exception e)
{
    // Output the stack trace.
    e.printStackTrace();
}

Modificare un'entitàModify an entity

Per modificare un'entità, recuperarla dal servizio tabelle, modificare l'oggetto entità e quindi salvare le modifiche nel servizio tabelle con un'operazione di sostituzione o unione.To modify an entity, retrieve it from the table service, make changes to the entity object, and save the changes back to the table service with a replace or merge operation. Il codice seguente consente di modificare il numero di telefono di un cliente esistente.The following code changes an existing customer's phone number. Anziché chiamare TableOperation.insert come fatto in precedenza per l'inserimento, questo codice chiama TableOperation.replace.Instead of calling TableOperation.insert as we did to insert, this code calls TableOperation.replace. Il metodo CloudTable.execute chiama il servizio tabelle e l'entità viene sostituita a meno che non sia stata modificata da un'altra applicazione da quando è stata recuperata dall'applicazione corrente.The CloudTable.execute method calls the table service, and the entity is replaced, unless another application changed it in the time since this application retrieved it. Se si verifica questa situazione, viene generata un'eccezione, pertanto è necessario recuperare, modificare e salvare di nuovo l'entità.When that happens, an exception is thrown, and the entity must be retrieved, modified, and saved again. Questo schema di ripetizione dei tentativi che supporta la concorrenza ottimistica è comune in un sistema di sistema di archiviazione distribuita.This optimistic concurrency retry pattern is common in a distributed storage system.

try
{
    // Retrieve storage account from connection-string.
    CloudStorageAccount storageAccount =
        CloudStorageAccount.parse(storageConnectionString);

    // Create the table client.
    CloudTableClient tableClient = storageAccount.createCloudTableClient();

    // Create a cloud table object for the table.
    CloudTable cloudTable = tableClient.getTableReference("people");

    // Retrieve the entity with partition key of "Smith" and row key of "Jeff".
    TableOperation retrieveSmithJeff =
        TableOperation.retrieve("Smith", "Jeff", CustomerEntity.class);

    // Submit the operation to the table service and get the specific entity.
    CustomerEntity specificEntity =
        cloudTable.execute(retrieveSmithJeff).getResultAsType();

    // Specify a new phone number.
    specificEntity.setPhoneNumber("425-555-0105");

    // Create an operation to replace the entity.
    TableOperation replaceEntity = TableOperation.replace(specificEntity);

    // Submit the operation to the table service.
    cloudTable.execute(replaceEntity);
}
catch (Exception e)
{
    // Output the stack trace.
    e.printStackTrace();
}

Eseguire query su un subset di proprietà di entitàQuery a subset of entity properties

Mediante una query su una tabella è possibile recuperare solo alcune proprietà da un'entità.A query to a table can retrieve just a few properties from an entity. Questa tecnica, denominata proiezione, consente di ridurre la larghezza di banda e di migliorare le prestazioni della query, in particolare per entità di grandi dimensioni.This technique, called projection, reduces bandwidth and can improve query performance, especially for large entities. La query nel codice seguente utilizza il metodo select per restituire solo gli indirizzi di posta elettronica di entità nella tabella.The query in the following code uses the select method to return only the email addresses of entities in the table. I risultati vengono proiettati in una raccolta di stringhe con l'aiuto di un oggetto EntityResolver, che esegue la conversione di tipo sulle entità restituite dal server.The results are projected into a collection of String with the help of an EntityResolver, which does the type conversion on the entities returned from the server. Per altre informazioni sulla proiezione, vedere [Introduzione di Upsert e proiezione di query in tabelle di Azure][Introduzione di Upsert e proiezione di query in tabelle di Azure].You can learn more about projection in [Azure Tables: Introducing Upsert and Query Projection][Azure Tables: Introducing Upsert and Query Projection]. Si noti che la proiezione non è supportata nell'emulatore di archiviazione locale, pertanto questo codice viene eseguito solo se si utilizza un account sul servizio tabelle.Note that projection is not supported on the local storage emulator, so this code runs only when using an account on the table service.

try
{
    // Retrieve storage account from connection-string.
    CloudStorageAccount storageAccount =
        CloudStorageAccount.parse(storageConnectionString);

    // Create the table client.
    CloudTableClient tableClient = storageAccount.createCloudTableClient();

    // Create a cloud table object for the table.
    CloudTable cloudTable = tableClient.getTableReference("people");

    // Define a projection query that retrieves only the Email property
    TableQuery<CustomerEntity> projectionQuery =
        TableQuery.from(CustomerEntity.class)
        .select(new String[] {"Email"});

    // Define an Entity resolver to project the entity to the Email value.
    EntityResolver<String> emailResolver = new EntityResolver<String>() {
        @Override
        public String resolve(String PartitionKey, String RowKey, Date timeStamp, HashMap<String, EntityProperty> properties, String etag) {
            return properties.get("Email").getValueAsString();
        }
    };

    // Loop through the results, displaying the Email values.
    for (String projectedString :
        cloudTable.execute(projectionQuery, emailResolver)) {
            System.out.println(projectedString);
    }
}
catch (Exception e)
{
    // Output the stack trace.
    e.printStackTrace();
}

Inserire o sostituire un'entitàInsert or Replace an entity

Spesso si desidera aggiungere un'entità a una tabella senza sapere se sia già esistente nella tabella.Often you want to add an entity to a table without knowing if it already exists in the table. Con un'operazione di inserimento o sostituzione è possibile creare una singola richiesta e inserire l'entità se non esiste oppure sostituirla se è già esistente.An insert-or-replace operation allows you to make a single request which will insert the entity if it does not exist or replace the existing one if it does. Sulla base degli esempi precedenti, il codice seguente consente di inserire o sostituire l'entità per "Walter Harp".Building on prior examples, the following code inserts or replaces the entity for "Walter Harp". Dopo aver creato una nuova entità, nel codice viene chiamato il metodo TableOperation.insertOrReplace .After creating a new entity, this code calls the TableOperation.insertOrReplace method. Questo codice chiama quindi il metodo execute sull'oggetto CloudTable con la tabella e l'operazione di inserimento o sostituzione tabella come parametri.This code then calls execute on the CloudTable object with the table and the insert or replace table operation as the parameters. Per aggiornare solo parte di un'entità, è invece possibile utilizzare il metodo TableOperation.insertOrMerge .To update only part of an entity, the TableOperation.insertOrMerge method can be used instead. Si noti che l'operazione di inserimento o sostituzione non è supportata nell'emulatore di archiviazione locale, pertanto questo codice viene eseguito solo se si usa un account sul servizio tabelle.Note that insert-or-replace is not supported on the local storage emulator, so this code runs only when using an account on the table service. Per altre informazioni sull'operazione di inserimento o sostituzione e l'operazione di inserimento o unione, vedere [Introduzione di Upsert e proiezione di query in tabelle di Azure][Introduzione di Upsert e proiezione di query in tabelle di Azure].You can learn more about insert-or-replace and insert-or-merge in this [Azure Tables: Introducing Upsert and Query Projection][Azure Tables: Introducing Upsert and Query Projection].

try
{
    // Retrieve storage account from connection-string.
    CloudStorageAccount storageAccount =
        CloudStorageAccount.parse(storageConnectionString);

    // Create the table client.
    CloudTableClient tableClient = storageAccount.createCloudTableClient();

    // Create a cloud table object for the table.
    CloudTable cloudTable = tableClient.getTableReference("people");

    // Create a new customer entity.
    CustomerEntity customer5 = new CustomerEntity("Harp", "Walter");
    customer5.setEmail("Walter@contoso.com");
    customer5.setPhoneNumber("425-555-0106");

    // Create an operation to add the new customer to the people table.
    TableOperation insertCustomer5 = TableOperation.insertOrReplace(customer5);

    // Submit the operation to the table service.
    cloudTable.execute(insertCustomer5);
}
catch (Exception e)
{
    // Output the stack trace.
    e.printStackTrace();
}

Eliminare un'entitàDelete an entity

È possibile eliminare facilmente un'entità dopo averla recuperata.You can easily delete an entity after you have retrieved it. Dopo il recupero dell'entità, chiamare TableOperation.delete con l'entità da eliminare.After the entity is retrieved, call TableOperation.delete with the entity to delete. Chiamare execute sull'oggetto CloudTable.Then call execute on the CloudTable object. Il codice seguente consente di recuperare ed eliminare un'entità customer.The following code retrieves and deletes a customer entity.

try
{
    // Retrieve storage account from connection-string.
    CloudStorageAccount storageAccount =
        CloudStorageAccount.parse(storageConnectionString);

    // Create the table client.
    CloudTableClient tableClient = storageAccount.createCloudTableClient();

    // Create a cloud table object for the table.
    CloudTable cloudTable = tableClient.getTableReference("people");

    // Create an operation to retrieve the entity with partition key of "Smith" and row key of "Jeff".
    TableOperation retrieveSmithJeff = TableOperation.retrieve("Smith", "Jeff", CustomerEntity.class);

    // Retrieve the entity with partition key of "Smith" and row key of "Jeff".
    CustomerEntity entitySmithJeff =
        cloudTable.execute(retrieveSmithJeff).getResultAsType();

    // Create an operation to delete the entity.
    TableOperation deleteSmithJeff = TableOperation.delete(entitySmithJeff);

    // Submit the delete operation to the table service.
    cloudTable.execute(deleteSmithJeff);
}
catch (Exception e)
{
    // Output the stack trace.
    e.printStackTrace();
}

Eliminare una tabellaDelete a table

Nell'esempio di codice seguente viene infine illustrato come eliminare una tabella da un account di archiviazione.Finally, the following code deletes a table from a storage account. Per circa 40 secondi in seguito all'eliminazione di una tabella, non è possibile ricrearla.For about 40 seconds after you delete a table, you cannot recreate it.

try
{
    // Retrieve storage account from connection-string.
    CloudStorageAccount storageAccount =
        CloudStorageAccount.parse(storageConnectionString);

    // Create the table client.
    CloudTableClient tableClient = storageAccount.createCloudTableClient();

    // Delete the table and all its data if it exists.
    CloudTable cloudTable = tableClient.getTableReference("people");
    cloudTable.deleteIfExists();
}
catch (Exception e)
{
    // Output the stack trace.
    e.printStackTrace();
}

Suggerimento

Estrarre il repository degli esempi di codice di Archiviazione di AzureCheck out the Azure Storage code samples repository

Per esempi di codice end-to-end facile da usare che è possibile scaricare ed eseguire, vedere l'elenco di esempi di Archiviazione di Azure.For easy-to-use end-to-end Azure Storage code samples that you can download and run, please check out our list of Azure Storage Samples.

Passaggi successiviNext steps

Per altre informazioni, vedere Azure for Java developers (Azure per sviluppatori Java).For more information, visit Azure for Java developers.