Uso de Azure Table Storage y Table API de Azure Cosmos DB desde JavaHow to use Azure Table storage or Azure Cosmos DB Table API from Java

Sugerencia

El contenido de este artículo se aplica a Azure Table Storage y a Table API de Azure Cosmos DB.The content in this article applies to Azure Table storage and the Azure Cosmos DB Table API. La instancia de Table API de Azure Cosmos DB es una oferta premium que ofrece tablas con rendimiento optimizado, distribución global e índices secundarios automáticos.The Azure Cosmos DB Table API is a premium offering for table storage that offers throughput-optimized tables, global distribution, and automatic secondary indexes.

Información generalOverview

En este artículo se muestra cómo llevar a cabo escenarios comunes mediante el servicio Azure Table Storage y Azure Cosmos DB.This article demonstrates how to perform common scenarios using the Azure Table storage service and Azure Cosmos DB. Los ejemplos están escritos en Java y utilizan el SDK de Azure Storage para Java.The samples are written in Java and use the Azure Storage SDK for Java. Entre los escenarios descritos se incluyen crear, enumerar y eliminar tablas, así como insertar, consultar, modificar y eliminar entidades de una tabla.The scenarios covered include creating, listing, and deleting tables, as well as inserting, querying, modifying, and deleting entities in a table. Para obtener más información acerca de las tablas, consulte la sección Pasos siguientes .For more information on tables, see the Next steps section.

Nota

hay un SDK disponible para los desarrolladores que usen Azure Storage en dispositivos Android.An SDK is available for developers who are using Azure Storage on Android devices. Para obtener más información, vea el SDK de Azure Storage para Android.For more information, see the Azure Storage SDK for Android.

Creación de una cuenta de servicio de AzureCreate an Azure service account

Puede trabajar con tablas mediante Azure Table Storage o Azure Cosmos DB.You can work with tables using Azure Table storage or Azure Cosmos DB. Para más información acerca de las diferencias entre los servicios, lea Ofertas de Table.You can learn more about the differences between the services by reading Table offerings. Debe crear una cuenta para el servicio que se va a utilizar.You'll need to create an account for the service you're going to use.

Creación de una cuenta de Azure StorageCreate an Azure storage account

La forma más fácil de crear la primera cuenta de Azure Storage es a través de Azure Portal.The easiest way to create your first Azure storage account is by using the Azure portal. Para obtener más información, consulte Crear una cuenta de almacenamiento.To learn more, see Create a storage account.

También se puede crear una cuenta de Azure Storage mediante Azure PowerShell o la CLI de Azure.You can also create an Azure storage account by using Azure PowerShell or Azure CLI.

Si no desea crear una cuenta de almacenamiento en este momento, también puede utilizar el emulador de Almacenamiento de Azure para ejecutar y probar el código en un entorno local.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. Para más información, consulte Uso del emulador de Azure Storage para desarrollo y pruebas.For more information, see Use the Azure Storage Emulator for Development and Testing.

Creación de una cuenta de Azure Cosmos DBCreate an Azure Cosmos DB account

Para obtener instrucciones sobre cómo crear una cuenta de Table API de Azure Cosmos DB, consulte Creación de una cuenta de Table API.For instructions on creating an Azure Cosmos DB Table API account, see Create a Table API account.

Creación de una aplicación JavaCreate a Java application

En esta guía utilizará funciones del almacenamiento que puede ejecutar en una aplicación Java localmente o bien mediante código a través de un rol web o un rol de trabajo de 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.

Para usar los ejemplos de este artículo, deberá instalar el Kit de desarrollo de Java (JDK) y crear una cuenta de Azure Storage o una cuenta de Azure Cosmos DB en su suscripción a 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. Después de esto, compruebe que su sistema de desarrollo satisface los requisitos mínimos y las dependencias que se indican en el repositorio del SDK de Azure Storage para Java en 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. Si su sistema cumple esos requisitos, puede seguir las instrucciones para descargar e instalar las bibliotecas de Azure Storage para Java en su sistema desde ese repositorio.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. Después de completar esas tareas puede crear una aplicación Java que use los ejemplos de este artículo.After you complete those tasks, you can create a Java application that uses the examples in this article.

Configuración de la aplicación para acceder al almacenamiento de tablasConfigure your application to access table storage

Agregue las siguientes instrucciones de importación en la parte superior del archivo Java en el que desea utilizar las API de Azure Storage o Table API de Azure Cosmos DB para obtener acceso a las tablas: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.*;

Adición de una cadena de conexión de almacenamiento de AzureAdd an Azure storage connection string

Un cliente de almacenamiento de Azure utiliza una cadena de conexión de almacenamiento para almacenar extremos y credenciales con el fin de obtener acceso a los servicios de administración de datos.An Azure storage client uses a storage connection string to store endpoints and credentials for accessing data management services. Al ejecutarse en una aplicación cliente, debe proporcionar la cadena de conexión de almacenamiento en el siguiente formato, usando el nombre de su cuenta de almacenamiento y la clave de acceso principal de la cuenta de almacenamiento que se muestra en Azure Portal para los valores AccountName y 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.

En este ejemplo se muestra cómo puede declarar un campo estático para mantener la cadena de conexión: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";

Adición de una cadena de conexión de Table API de Azure Cosmos DBAdd an Azure Cosmos DB Table API connection string

Una cuenta de Azure Cosmos DB utiliza una cadena de conexión para almacenar el punto de conexión de la tabla y sus credenciales.An Azure Cosmos DB account uses a connection string to store the table endpoint and your credentials. Al ejecutarse en una aplicación cliente, debe proporcionar la cadena de conexión de Azure Cosmos DB en el siguiente formato, usando el nombre de su cuenta de Azure Cosmos DB y la clave de acceso principal de la cuenta que se muestra en Azure Portal para los valores AccountName y 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.

En este ejemplo se muestra cómo puede declarar un campo estático para mantener la cadena de conexión de 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;" ;

En una aplicación que se ejecuta en un rol de Azure, puede almacenar esta cadena en el archivo de configuración de servicio, ServiceConfiguration.cscfg, y se puede obtener acceso a él con una llamada al método 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. A continuación se muestra un ejemplo de cómo obtener la cadena de conexión desde un elemento de configuración denominado StorageConnectionString en el archivo de configuración del servicio: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");

También puede almacenar la cadena de conexión en el archivo config.properties del proyecto: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/

En los ejemplos siguientes se supone que usó uno de estos métodos para obtener la cadena de conexión de almacenamiento.The following samples assume that you have used one of these methods to get the storage connection string.

Creación de una tablaCreate a table

Los objetos CloudTableClient le permiten obtener objetos de referencia para tablas y entidades.A CloudTableClient object lets you get reference objects for tables and entities. El siguiente código crea un objeto CloudTableClient y lo usa para crear un nuevo objeto CloudTable que representa una tabla llamada "people".The following code creates a CloudTableClient object and uses it to create a new CloudTable object which represents a table named "people".

Nota

Existen otras maneras de crear objetos CloudStorageAccount. Para más información, consulte CloudStorageAccount en la Referencia del SDK del cliente de Azure Storage.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();
}

Enumeración de las tablasList the tables

Para obtener una lista de las tablas, llame al método CloudTableClient.listTables() para recuperar una lista que se puede iterar de nombres de tablas.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();
}

Adición de una entidad a una tablaAdd an entity to a table

Las entidades se asignan a objetos de Java utilizando una clase personalizada que implementa TableEntity.Entities map to Java objects using a custom class implementing TableEntity. Para mayor comodidad, la clase TableServiceEntity implementa TableEntity y usa la reflexión para asignar propiedades a los métodos de captador y establecedor indicados para las propiedades.For convenience, the TableServiceEntity class implements TableEntity and uses reflection to map properties to getter and setter methods named for the properties. Para agregar una entidad a una tabla, cree primero una clase que defina las propiedades de la entidad.To add an entity to a table, first create a class that defines the properties of your entity. El código siguiente define una clase de entidad que utiliza el nombre de pila del cliente como clave de fila y el apellido como clave de partición.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. En conjunto, la clave de partición y la clave de fila de una entidad la identifican inequívocamente en la tabla.Together, an entity's partition and row key uniquely identify the entity in the table. Puede realizarse una consulta en las entidades con la misma clave de partición de manera más rápida que en aquellas que tienen claves de partición distintas.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;
    }
}

Las operaciones de tabla que afectan a las entidades requieren un objeto TableOperation .Table operations involving entities require a TableOperation object. Este objeto define la operación que va a realizarse en una entidad, que puede ejecutarse con un objeto CloudTable .This object defines the operation to be performed on an entity, which can be executed with a CloudTable object. El código siguiente crea una instancia nueva de la clase CustomerEntity con algunos datos de clientes que se van a almacenar.The following code creates a new instance of the CustomerEntity class with some customer data to be stored. El código siguiente llama a TableOperation.insertOrReplace para crear un objeto TableOperation a fin de insertar una entidad en una tabla y asocia el objeto CustomerEntity a ella.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. Por último, el código llama al método execute en CloudTable, especificando la tabla "people" y el nuevo objeto TableOperation, que posteriormente envía una solicitud al servicio de almacenamiento para insertar la nueva entidad de cliente en la tabla "people" o sustituir la entidad si ya existe.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();
}

Inserción de un lote de entidadesInsert a batch of entities

Puede insertar un lote de entidades en el servicio Tabla mediante una operación de escritura.You can insert a batch of entities to the table service in one write operation. El siguiente código crea un objeto TableBatchOperation y, a continuación, le agrega tres operaciones de inserción.The following code creates a TableBatchOperation object, then adds three insert operations to it. Cada operación de inserción se agrega mediante la creación de un nuevo objeto de entidad, se configuran sus valores y, a continuación, se llama al método insert en el objeto TableBatchOperation para asociar la entidad a una nueva operación de inserción.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. A continuación, el código llama a execute en el objeto CloudTable, especificando la tabla "people" y el objeto TableBatchOperation, que envía el lote de operaciones de tabla al servicio de almacenamiento en una única solicitud.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();
}

Algunos aspectos que cabe tener en cuenta acerca de las operaciones por lotes:Some things to note on batch operations:

  • Puede ejecutar cualquier combinación de 100 operaciones de inserción, eliminación, combinación, reemplazo, inserción o combinación e inserción o reemplazo en un único lote.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.
  • Una operación por lotes puede tener una operación de recuperación, si es que es la única operación del lote.A batch operation can have a retrieve operation, if it is the only operation in the batch.
  • Todas las entidades de la misma operación por lotes deben compartir la misma clave de partición.All entities in a single batch operation must have the same partition key.
  • Una operación por lotes se limita a una carga de datos de 4 MB.A batch operation is limited to a 4MB data payload.

todas las entidades de una particiónRetrieve all entities in a partition

Para consultar una tabla a fin de obtener las entidades de una partición, use un objeto TableQuery.To query a table for entities in a partition, you can use a TableQuery. Llame a TableQuery.from para crear una consulta en una tabla concreta que devuelva un tipo de resultado específico.Call TableQuery.from to create a query on a particular table that returns a specified result type. El código siguiente especifica un filtro para las entidades en las que "Smith" es la clave de partición.The following code specifies a filter for entities where 'Smith' is the partition key. TableQuery.generateFilterCondition es un método auxiliar para crear filtros para las consultas.TableQuery.generateFilterCondition is a helper method to create filters for queries. Llame a where en la referencia devuelta por el método TableQuery.from para aplicar el filtro a la consulta.Call where on the reference returned by the TableQuery.from method to apply the filter to the query. Si la consulta se ejecuta con una llamada a execute en el objeto CloudTable, devuelve un iterador con el tipo de resultado CustomerEntity especificado.When the query is executed with a call to execute on the CloudTable object, it returns an Iterator with the CustomerEntity result type specified. A continuación, puede usar el iterador devuelto para cada bucle para consumir los resultados.You can then use the Iterator returned in a for each loop to consume the results. En este código, los campos de cada entidad se imprimen en la consola, como parte de los resultados de la consulta.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();
}

Recuperación de un rango de entidades de una particiónRetrieve a range of entities in a partition

Si no quiere consultar todas las entidades de una partición, puede especificar un rango mediante el uso de operadores de comparación en 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. El código siguiente combina dos filtros para obtener todas las entidades de la partición "Smith" en las que la clave de fila (nombre de pila) empieza por una letra hasta "E" en el alfabeto.The 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. A continuación, imprime los resultados de la consulta.Then it prints the query results. Si usa las entidades agregadas a la tabla en la sección de inserción por lotes de esta guía, solo se devuelven dos entidades en este momento (Ben y Denise Smith); Jeff Smith no se incluye.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();
}

una sola entidadRetrieve a single entity

Puede enviar una consulta para recuperar una sola entidad concreta.You can write a query to retrieve a single, specific entity. El código siguiente llama a TableOperation.retrieve con los parámetros de clave de partición y clave de fila para especificar el cliente "Jeff Smith", en lugar de crear un elemento TableQuery y usar filtros para realizar la misma operación.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. Cuando se ejecuta, la operación de recuperación devuelve solo una entidad, en lugar de una colección de entidades.When executed, the retrieve operation returns just one entity, rather than a collection. El método getResultAsType convierte el resultado en el tipo de objetivo de asignación, un objeto CustomerEntity.The getResultAsType method casts the result to the type of the assignment target, a CustomerEntity object. Si este tipo no es compatible con el tipo especificado para la consulta, se muestra una excepción.If this type is not compatible with the type specified for the query, an exception is thrown. Se devuelve un valor nulo si no coincide exactamente la clave de fila y de partición de ninguna entidad.A null value is returned if no entity has an exact partition and row key match. La forma más rápida de recuperar una sola entidad de Table service es especificar claves tanto de partición como de fila en las consultas.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();
}

Modificación de una entidadModify an entity

Para modificar una entidad, recupérela del servicio Tabla, realice los cambios en el objeto de entidad y vuelva a guardar los cambios en dicho servicio con una operación de reemplazo o combinación.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. El código siguiente cambia el número de teléfono de un cliente.The following code changes an existing customer's phone number. En lugar de llamar a TableOperation.insert como hicimos para la inserción, este código llama a TableOperation.replace.Instead of calling TableOperation.insert as we did to insert, this code calls TableOperation.replace. El método CloudTable.execute llama al servicio Tabla y la entidad se reemplaza, a no ser que otra aplicación la haya modificado desde que la aplicación la recuperó.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. Cuando se produce esa situación, se muestra una excepción y la entidad debe recuperarse, modificarse y guardarse de nuevo.When that happens, an exception is thrown, and the entity must be retrieved, modified, and saved again. Este patrón de reintento de simultaneidad optimista es común en un sistema de almacenamiento distribuido.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();
}

Consulta de un subconjunto de propiedades de las entidadesQuery a subset of entity properties

Una consulta de tabla puede recuperar solo algunas propiedades de una entidad.A query to a table can retrieve just a few properties from an entity. Esta técnica, denominada proyección, reduce el ancho de banda y puede mejorar el rendimiento de las consultas, en especial en el caso de entidades de gran tamaño.This technique, called projection, reduces bandwidth and can improve query performance, especially for large entities. La consulta del código siguiente usa el método select para devolver solo las direcciones de correo electrónico de las entidades de la tabla.The query in the following code uses the select method to return only the email addresses of entities in the table. Los resultados se proyectan en una colección de propiedades String con la ayuda de un objeto EntityResolver, que hace la conversión del tipo de entidades que el servidor devuelve.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. Puede aprender más sobre la proyección en [Tablas de Azure: Introducción de Upsert y proyección de consultas][Tablas de Azure: Introducción de Upsert y proyección de consultas].You can learn more about projection in [Azure Tables: Introducing Upsert and Query Projection][Azure Tables: Introducing Upsert and Query Projection]. Tenga en cuenta que la proyección no es compatible con el emulador de almacenamiento local, por lo que este código solo se ejecuta cuando se utiliza una cuenta del servicio Tabla.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();
}

Inserción o reemplazo de una entidadInsert or Replace an entity

En ocasiones, es posible que desee agregar una entidad a una tabla sin saber si ya existe en la tabla.Often you want to add an entity to a table without knowing if it already exists in the table. Una operación de inserción o reemplazo le permite realizar una consulta única que insertará la entidad si no existe o que reemplazará la existente si la hubiera.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. Según los ejemplos anteriores, el siguiente código inserta o reemplaza la entidad de "Walter Harp".Building on prior examples, the following code inserts or replaces the entity for "Walter Harp". Después de crear una nueva entidad, este código llama al método TableOperation.insertOrReplace .After creating a new entity, this code calls the TableOperation.insertOrReplace method. A continuación, este código llama a execute en el objeto CloudTable con la tabla y las operaciones de inserción o reemplazo de tabla como parámetros.This code then calls execute on the CloudTable object with the table and the insert or replace table operation as the parameters. Para actualizar solo parte de una entidad, en su lugar, se puede usar el método TableOperation.insertOrMerge .To update only part of an entity, the TableOperation.insertOrMerge method can be used instead. Tenga en cuenta que la inserción o el reemplazo no son compatibles con el emulador de almacenamiento local, por lo que este código solo se ejecuta cuando se utiliza una cuenta del servicio Tabla.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. Puede aprender más sobre las operaciones de inserción o reemplazo y de inserción o fusión en [Tablas de Azure: Introducción de Upsert y proyección de consultas][Tablas de Azure: Introducción de Upsert y proyección de consultas].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();
}

Eliminación de una entidadDelete an entity

Puede eliminar fácilmente una entidad después de que la haya recuperado.You can easily delete an entity after you have retrieved it. Tras recuperar la entidad, llame a TableOperation.delete con la entidad que se va a eliminar.After the entity is retrieved, call TableOperation.delete with the entity to delete. A continuación, llame a execute en el objeto CloudTable.Then call execute on the CloudTable object. El código siguiente recupera y elimina una entidad de cliente.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();
}

Eliminación de una tablaDelete a table

Finalmente, el código siguiente elimina una tabla de una cuenta de almacenamiento.Finally, the following code deletes a table from a storage account. Aproximadamente 40 segundos después de eliminar una tabla, no puede volver a crearla.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();
}

Sugerencia

Extraer del repositorio ejemplos de código de Azure StorageCheck out the Azure Storage code samples repository

Para encontrar ejemplos de código de Azure Storage de un extremo a otro y fáciles de usar que se pueden descargar y ejecutar, consulte nuestra lista de ejemplos de Azure Storage.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.

Pasos siguientesNext steps

Para más información, visite Azure para desarrolladores de Java.For more information, visit Azure for Java developers.