Jak používat službu Azure Table Storage nebo rozhraní Table API služby Azure Cosmos DB z JavyHow to use Azure Table storage or Azure Cosmos DB Table API from Java

PLATÍ pro: rozhraní API pro tabulky

Tip

Obsah v tomto článku se vztahuje na službu Azure Table Storage a rozhraní Azure Cosmos DB Table API.The content in this article applies to Azure Table storage and the Azure Cosmos DB Table API. Rozhraní Azure Cosmos DB Table API je nabídka služby Table Storage úrovně Premium, která nabízí tabulky optimalizované pro zvýšení propustnosti, globální distribuci a automatické sekundární indexy.The Azure Cosmos DB Table API is a premium offering for table storage that offers throughput-optimized tables, global distribution, and automatic secondary indexes.

V tomto článku se dozvíte, jak vytvářet tabulky, ukládat data a provádět operace CRUD s daty.This article shows you how to create tables, store your data, and perform CRUD operations on the data. Vyberte buď Azure Table service, nebo rozhraní API pro tabulky Azure Cosmos DB.Choose either the Azure Table service or the Azure Cosmos DB Table API. Ukázky jsou napsané v jazyce Java a používají sadu Azure Storage SDK V8 for Java.The samples are written in Java and use the Azure Storage SDK v8 for Java. Popsané scénáře zahrnují vytváření, výpis a odstraňování tabulek a také vkládání, dotazování, úpravy a odstraňování entit v tabulce.The scenarios covered include creating, listing, and deleting tables, as well as inserting, querying, modifying, and deleting entities in a table. Další informace o tabulkách najdete v části Další kroky.For more information on tables, see the Next steps section.

Důležité

Poslední verze sady Azure Storage SDK podporující Table Storage je V8.The last version of the Azure Storage SDK supporting Table Storage is v8. Brzy bude dostupná nová verze sady Table Storage SDK pro jazyk Java.A new version of the Table Storage SDK for Java will be coming soon.

Poznámka

Sada SDK je k dispozici pro vývojáře používající službu Azure Storage na zařízeních s Androidem.An SDK is available for developers who are using Azure Storage on Android devices. Další informace najdete v tématu Sada SDK služby Azure Storage pro Android.For more information, see the Azure Storage SDK for Android.

Vytvoření účtu služby AzureCreate an Azure service account

S tabulkami můžete pracovat pomocí služby Azure Table Storage nebo Azure Cosmos DB.You can work with tables using the Azure Table storage or the Azure Cosmos DB. Další informace o rozdílech mezi nabídkami tabulek v těchto dvou službách najdete v článku věnovaném nabídkám pro tabulky .To learn more about the differences between table offerings in these two services, see the Table offerings article. U služby, kterou budete používat, si budete muset vytvořit účet.You'll need to create an account for the service you're going to use. V následujících částech se dozvíte, jak vytvořit službu Azure Table Storage a účet Azure Cosmos DB, ale stačí použít jednu z nich.The following sections show how to create both Azure Table storage and the Azure Cosmos DB account, however you can just use one of them.

Vytvoření účtu úložiště AzureCreate an Azure storage account

Nejjednodušší způsob, jak vytvořit účet úložiště Azure, je použít Azure Portal.The easiest way to create an Azure storage account is by using the Azure portal. Další informace najdete v tématu Vytvoření účtu úložiště.To learn more, see Create a storage account.

Účet úložiště Azure můžete vytvořit také pomocí Azure PowerShellu nebo Azure CLI.You can also create an Azure storage account by using Azure PowerShell or Azure CLI.

Pokud nechcete v tomto okamžiku vytvořit účet úložiště, můžete také použít emulátor Azure Storage ke spuštění a otestování kódu v místním prostředí.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. Další informace najdete v tématu použití emulátoru Azure Storage pro vývoj a testování.For more information, see Use the Azure Storage Emulator for development and testing.

Vytvoření účtu služby Azure Cosmos DBCreate an Azure Cosmos DB account

Pokyny k vytvoření účtu Azure Cosmos DB rozhraní API pro tabulky najdete v tématu vytvoření databázového účtu.For instructions on creating an Azure Cosmos DB Table API account, see Create a database account.

Vytvoření aplikace JavaCreate a Java application

V této příručce budete používat funkce úložiště, které můžete spustit místně v aplikaci Java nebo v kódu spuštěném ve webové roli nebo roli pracovního procesu v 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.

Pokud chcete využít ukázky v tomto článku, nainstalujte si sadu Java Development Kit (JDK) a pak ve svém předplatném Azure vytvořte účet úložiště Azure nebo účet služby Azure Cosmos DB.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. Jakmile to provedete, ověřte, že váš vývojový systém splňuje minimální požadavky a obsahuje závislosti uvedené v úložišti sady SDK služby Azure Storage pro Javu na GitHubu.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. Pokud váš systém splňuje tyto požadavky, můžete z tohoto adresáře podle uvedených pokynů stáhnout a nainstalovat ve svém systému knihovny služby Azure Storage pro Javu.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. Po dokončení těchto úloh můžete vytvořit aplikaci Java využívající příklady v tomto článku.After you complete those tasks, you can create a Java application that uses the examples in this article.

Konfigurace aplikace pro přístup ke službě Table StorageConfigure your application to access table storage

Na začátek souboru Java, ve kterém chcete pro přístup k tabulkám použít rozhraní API úložiště Azure nebo rozhraní Table API služby Azure Cosmos DB, vložte následující příklady pro import: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.*;

Přidat připojovací řetězecAdd your connection string

Můžete se buď připojit k účtu služby Azure Storage nebo účtu Azure Cosmos DB rozhraní API pro tabulky.You can either connect to the Azure storage account or the Azure Cosmos DB Table API account. Získejte připojovací řetězec na základě typu účtu, který používáte.Get the connection string based on the type of account you are using.

Přidání připojovacího řetězce úložiště AzureAdd an Azure storage connection string

Klient úložiště Azure používá připojovací řetězec úložiště k uložení koncových bodů a přihlašovacích údajů pro přístup ke službám správy dat.An Azure storage client uses a storage connection string to store endpoints and credentials for accessing data management services. Při spuštění klientské aplikace musíte zadat připojovací řetězec úložiště v následujícím formátu a jako hodnoty AccountName a AccountKey použít název a primární přístupový klíč vašeho účtu úložiště uvedené na webu Azure Portal.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.

Tento příklad ukazuje deklaraci statického pole pro uložení připojovacího řetězce: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";

Přidání připojovacího řetězce rozhraní Table API služby Azure Cosmos DBAdd an Azure Cosmos DB Table API connection string

Účet služby Azure Cosmos DB používá připojovací řetězec k uložení koncového bodu tabulky a vašich přihlašovacích údajů.An Azure Cosmos DB account uses a connection string to store the table endpoint and your credentials. Při spuštění klientské aplikace musíte zadat připojovací řetězec služby Azure Cosmos DB v následujícím formátu a jako hodnoty AccountName a AccountKey použít název a primární přístupový klíč vašeho účtu služby Azure Cosmos DB uvedené na webu Azure Portal.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.

Tento příklad ukazuje deklaraci statického pole pro uložení připojovacího řetězce služby 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;" ;

V aplikaci spuštěné v rámci role v Azure můžete tento řetězec uložit do konfiguračního souboru služby ServiceConfiguration.cscfg a přistupovat k němu voláním metody 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. Tady je příklad získání připojovacího řetězce StorageConnectionString z elementu Settings (Nastavení) v konfiguračním souboru služby: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");

Připojovací řetězec můžete uložit také do souboru config.properties vašeho projektu: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/

V následujících ukázkách se předpokládá, že jste pomocí některé z těchto metod získali připojovací řetězec úložiště.The following samples assume that you have used one of these methods to get the storage connection string.

Vytvoření tabulkyCreate a table

CloudTableClientObjekt umožňuje získat referenční objekty pro tabulky a entity.A CloudTableClient object lets you get reference objects for tables and entities. Následující kód vytvoří CloudTableClient objekt a použije ho k vytvoření nového CloudTable objektu, který představuje tabulku s názvem "lidé".The following code creates a CloudTableClient object and uses it to create a new CloudTable object, which represents a table named "people".

Poznámka

Existují i jiné způsoby, jak vytvářet CloudStorageAccount objekty. Další informace naleznete CloudStorageAccount v tématu [Azure Storage odkaz na sadu SDK klienta]).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();
}

Výpis tabulekList the tables

Pokud chcete zobrazit seznam tabulek, zavolejte metodu CloudTableClient.listTables(), která načte seznam názvů tabulek s možností iterace.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();
}

Přidání entity do tabulkyAdd an entity to a table

Entity se mapují na objekty Java pomocí implementace vlastní třídy TableEntity .Entities map to Java objects using a custom class implementing TableEntity. Pro pohodlí TableServiceEntity Třída implementuje TableEntity a používá reflexi k mapování vlastností na metody getter a setter s názvem pro vlastnosti.For convenience, the TableServiceEntity class implements TableEntity and uses reflection to map properties to getter and setter methods named for the properties. Pokud chcete do tabulky přidat entitu, nejprve vytvořte třídu, která definuje vlastnosti vaší entity.To add an entity to a table, first create a class that defines the properties of your entity. Následující kód definuje třídu entity, která používá jméno zákazníka jako klíč řádku a jeho příjmení jako klíč oddílu.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. Společně pak klíč oddílu a řádku entity jednoznačně identifikují entitu v tabulce.Together, an entity's partition and row key uniquely identify the entity in the table. Entity se stejným klíčem oddílu je možné dotazovat rychleji než entity s různými klíči oddílu.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;
    }
}

Operace s tabulkami zahrnující entity vyžadují TableOperation objekt.Table operations involving entities require a TableOperation object. Tento objekt definuje operaci, která má být provedena u entity, která může být provedena s CloudTable objektem.This object defines the operation to be performed on an entity, which can be executed with a CloudTable object. Následující kód vytvoří novou instanci CustomerEntity třídy s některými Zákaznickými daty, která mají být uložena.The following code creates a new instance of the CustomerEntity class with some customer data to be stored. Kód Next volá TableOperation . insertOrReplace * * pro vytvoření TableOperation objektu pro vložení entity do tabulky a přidruží k ní nový objekt 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. Nakonec kód volá execute metodu CloudTable objektu, zadáním tabulky "lidé" a nového TableOperation , která poté pošle požadavek službě úložiště, aby vložila novou entitu zákazníka do tabulky "lidé", nebo nahradí entitu, pokud již existuje.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();
}

Vložení dávky entitInsert a batch of entities

V rámci jedné operace zápisu můžete do služby Table Storage vložit dávku entit.You can insert a batch of entities to the table service in one write operation. Následující kód vytvoří TableBatchOperation objekt a poté přidá do něj tři operace vložení.The following code creates a TableBatchOperation object, then adds three insert operations to it. Každá operace vložení je přidána vytvořením nového objektu entity, nastavením jeho hodnot a následným voláním insert metody TableBatchOperation objektu k přidružení entity k nové operaci vložení.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. Potom kód volá execute CloudTable objekt a určí tabulku "lidé" a TableBatchOperation objekt, který odešle dávku operací tabulky do služby úložiště v jednom požadavku.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();
}

O dávkových operacích byste měli vědět několik věcí:Some things to note on batch operations:

  • V jedné dávce můžete provést jakoukoli kombinaci až 100 operací vložení, odstranění, sloučení, nahrazení, vložení nebo sloučení a vložení nebo nahrazení.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.
  • Dávková operace může obsahovat operaci načtení, pokud se jedná o jedinou operaci v dávce.A batch operation can have a retrieve operation, if it is the only operation in the batch.
  • Všechny entity v jedné dávkové operaci musí mít stejný klíč oddílu.All entities in a single batch operation must have the same partition key.
  • Velikost datové části dávkové operace je omezená na 4 MB.A batch operation is limited to a 4-MB data payload.

Načtení všech entit v oddíluRetrieve all entities in a partition

Chcete-li zadat dotaz na tabulku pro entity v oddílu, můžete použít TableQuery .To query a table for entities in a partition, you can use a TableQuery. Volá TableQuery.from se, aby se vytvořil dotaz na konkrétní tabulce, která vrací zadaný typ výsledku.Call TableQuery.from to create a query on a particular table that returns a specified result type. Následující kód určuje filtr pro entity, kde Smith je klíč oddílu.The following code specifies a filter for entities where 'Smith' is the partition key. TableQuery.generateFilterCondition je pomocná metoda pro vytváření filtrů pro dotazy.TableQuery.generateFilterCondition is a helper method to create filters for queries. Zavolejte where na odkaz vrácený TableQuery.from metodou pro použití filtru pro dotaz.Call where on the reference returned by the TableQuery.from method to apply the filter to the query. Když se dotaz spustí s voláním execute na CloudTable objekt, vrátí Iterator se s CustomerEntity zadaným typem výsledku.When the query is executed with a call to execute on the CloudTable object, it returns an Iterator with the CustomerEntity result type specified. Pak můžete použít Iterator vrácenou smyčku foreach k využití výsledků.You can then use the Iterator returned in a "ForEach" loop to consume the results. Tento kód v konzole zobrazí pole každé entity z výsledků dotazu.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();
}

Načtení rozsahu entit v oddíluRetrieve a range of entities in a partition

Pokud nechcete dotazovat všechny entity v oddílu, můžete ve filtru zadat rozsah pomocí operátorů porovnání.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. Následující kód pomocí kombinace dvou filtrů získá všechny entity v oddílu Smith, kde klíč řádku (jméno) začíná písmenem abecedy až do písmene E.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. Pak zobrazí výsledky dotazu.Then it prints the query results. Pokud používáte entity přidané do tabulky v části této příručky věnované dávkovému vložení, vrátí se teď pouze dvě entity (Ben a Denise Smith), Jeff Smith se nevrátí.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();
}

Načtení jedné entityRetrieve a single entity

Můžete napsat dotaz pro načtení jedné konkrétní entity.You can write a query to retrieve a single, specific entity. Následující kód volá TableOperation.retrieve Parametry klíče oddílu a klíče řádku k určení zákazníka "Jan Novák" místo vytvoření Table Query a použití filtrů ke stejnému účelu.The following code calls TableOperation.retrieve with partition key and row key parameters to specify the customer "Jeff Smith", instead of creating a Table Query and using filters to do the same thing. Po spuštění operace načtení vrátí místo kolekce pouze jednu entitu.When executed, the retrieve operation returns just one entity, rather than a collection. getResultAsTypeMetoda přetypování výsledku na typ cíle přiřazení, CustomerEntity objekt.The getResultAsType method casts the result to the type of the assignment target, a CustomerEntity object. Pokud tento typ není kompatibilní s typem zadaným pro dotaz, vyvolá se výjimka.If this type is not compatible with the type specified for the query, an exception is thrown. Pokud se žádná entita zcela neshoduje s klíčem oddílu a řádku, vrátí se hodnota null.A null value is returned if no entity has an exact partition and row key match. Určení jak klíčů oddílu, tak klíčů řádků v dotazu představuje nejrychlejší způsob, jak načíst jednu entitu ze služby Table service.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();
}

Úprava entityModify an entity

Pokud chcete entitu upravit, načtěte ji ze služby Table Storage, proveďte změny objektu entity a uložte změny zpět do služby Table Storage pomocí operace nahrazení nebo sloučení.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. Následující kód změní telefonní číslo stávajícího zákazníka.The following code changes an existing customer's phone number. Místo volání metody TableOperation.insert, kterou jsme použili k vložení, volá tento kód metodu TableOperation.replace.Instead of calling TableOperation.insert as we did to insert, this code calls TableOperation.replace. Metoda CloudTable.execute zavolá službu Table Storage a entita se nahradí, pokud ji od načtení touto aplikací nějaká jiná aplikace nezměnila.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. Pokud k tomu dojde, vyvolá se výjimka a entitu je potřeba znovu načíst, upravit a uložit.When that happens, an exception is thrown, and the entity must be retrieved, modified, and saved again. Tento vzorec opakování využívající optimistickou souběžnost je běžný v systémech distribuovaného úložiště.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();
}

Dotaz na podmnožinu vlastností entityQuery a subset of entity properties

Dotaz na tabulku dokáže z entity načíst pouze několik vlastností.A query to a table can retrieve just a few properties from an entity. Tato technika, které se říká projekce, snižuje šířku pásma a může zlepšit výkon dotazů, zejména u velkých entit.This technique, called projection, reduces bandwidth and can improve query performance, especially for large entities. Dotaz v následujícím kódu používá select metodu pro vrácení pouze e-mailových adres entit v tabulce.The query in the following code uses the select method to return only the email addresses of entities in the table. Výsledky jsou probíhají do kolekce String s použitím Entity Resolver , což vede k převodu typu u entit vrácených ze serveru.The results are projected into a collection of String with the help of an Entity Resolver, which does the type conversion on the entities returned from the server. Další informace o projekci najdete v článku [tabulky Azure: představení Upsert a projekce dotazů] [tabulky Azure: představení Upsert a projekce dotazů].You can learn more about projection in [Azure Tables: Introducing Upsert and Query Projection][Azure Tables: Introducing Upsert and Query Projection]. Projekce není podporována v emulátoru místního úložiště, takže tento kód bude spuštěn pouze při použití účtu ve službě Table Service.The 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();
}

Vložení nebo nahrazení entityInsert or Replace an entity

Často chcete do tabulky přidat entitu, aniž byste věděli, jestli v ní již neexistuje.Often you want to add an entity to a table without knowing if it already exists in the table. Operace INSERT-or-Replace umožňuje vytvořit jeden požadavek, který entitu vloží, pokud neexistuje, nebo nahradit existující entitu, pokud k ní dojde.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. Následující kód staví na předchozích příkladech a vloží nebo nahradí entitu Walter Harp.Building on prior examples, the following code inserts or replaces the entity for "Walter Harp". Po vytvoření nové entity tento kód zavolá metodu TableOperation.insertOrReplace.After creating a new entity, this code calls the TableOperation.insertOrReplace method. Tento kód pak zavolá metodu Execute pro objekt cloudové tabulky s tabulkou a operaci vložení nebo nahrazení tabulky jako parametry.This code then calls execute on the Cloud Table object with the table and the insert or replace table operation as the parameters. Pokud chcete aktualizovat pouze část entity, můžete místo toho použít metodu TableOperation.insertOrMerge.To update only part of an entity, the TableOperation.insertOrMerge method can be used instead. Příkaz INSERT-nebo-Replace není podporován v emulátoru místního úložiště, takže tento kód bude spuštěn pouze při použití účtu ve službě Table Service.Insert-or-replace is not supported on the local storage emulator, so this code runs only when using an account on the table service. Další informace o vložení nebo nahrazení a vložení nebo sloučení najdete v tomto [tabulkách Azure: představení Upsert a projekce dotazů] [tabulky Azure: představení Upsert a projekce dotazů].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();
}

Odstranění entityDelete an entity

Entitu můžete snadno odstranit po jejím načtení.You can easily delete an entity after you have retrieved it. Po načtení entity zavolejte TableOperation.delete s entitou, která se má odstranit.After the entity is retrieved, call TableOperation.delete with the entity to delete. Pak zavolejte execute na CloudTable objekt.Then call execute on the CloudTable object. Následující kód načte a odstraní entitu zákazníka.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();
}

Odstranění tabulkyDelete a table

Následující kód nakonec odstraní tabulku z účtu úložiště.Finally, the following code deletes a table from a storage account. Přibližně 40 sekund po odstranění tabulky ji nemůžete znovu vytvořit.Around 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();
}

Tip

Projděte si úložiště s ukázkami kódu pro Azure StorageCheck out the Azure Storage code samples repository

Snadno použitelné a úplné ukázky kódu pro Azure Storage, které si můžete stáhnout a použít, jsou shrnuté v seznamu ukázky pro 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.

Další krokyNext steps

Další informace najdete na webu Azure pro vývojáře v Javě.For more information, visit Azure for Java developers.