Verwenden von Azure Table Storage oder der Azure Cosmos DB-Tabellen-API aus JavaHow to use Azure Table storage or Azure Cosmos DB Table API from Java

Tipp

Der Inhalt in diesem Artikel gilt für Azure-Tabellenspeicher und für die Azure Cosmos DB-Tabellen-API.The content in this article applies to Azure Table storage and the Azure Cosmos DB Table API. Die Azure Cosmos DB-Tabellen-API ist ein Premiumangebot für Tabellenspeicher und bietet Tabellen mit optimiertem Durchsatz, globale Verteilung und automatische sekundäre Indizes.The Azure Cosmos DB Table API is a premium offering for table storage that offers throughput-optimized tables, global distribution, and automatic secondary indexes.

ÜbersichtOverview

Dieser Artikel zeigt, wie Sie allgemeine Szenarien mit dem Azure Table Storage-Dienst und Azure Cosmos DB ausführen.This article demonstrates how to perform common scenarios using the Azure Table storage service and Azure Cosmos DB. Die Beispiele wurden in Java geschrieben und verwenden das Azure Storage-SDK für Java.The samples are written in Java and use the Azure Storage SDK for Java. Die erläuterten Szenarien umfassten das Erstellen, Auflisten und Löschen von Tabellen sowie das Einfügen, Abfragen, Ändern und Löschen von Entitäten in einer Tabelle.The scenarios covered include creating, listing, and deleting tables, as well as inserting, querying, modifying, and deleting entities in a table. Weitere Informationen zu Tabellen finden Sie im Abschnitt Nächste Schritte .For more information on tables, see the Next steps section.

Hinweis

Ein SDK steht für Entwickler zur Verfügung, die Azure Storage auf Android-Geräten verwenden.An SDK is available for developers who are using Azure Storage on Android devices. Weitere Informationen finden Sie unter Azure Storage-SDK für Android.For more information, see the Azure Storage SDK for Android.

Erstellen eines Azure-DienstkontosCreate an Azure service account

Sie können in Azure Table Storage oder in Azure Cosmos DB mit Tabellen arbeiten.You can work with tables using Azure Table storage or Azure Cosmos DB. Informationen zu den Unterschieden zwischen den Diensten finden Sie unter Tabellenangebote.To learn more about the differences between the services, see Table offerings. Sie müssen ein Konto für den Dienst erstellen, den Sie verwenden werden.You'll need to create an account for the service you're going to use.

Erstellen eines Azure-SpeicherkontosCreate an Azure storage account

Ein Azure-Speicherkonto erstellen Sie am einfachsten im Azure-Portal.The easiest way to create an Azure storage account is by using the Azure portal. Weitere Informationen finden Sie unter Erstellen von Speicherkonten.To learn more, see Create a storage account.

Sie können ein Azure-Speicherkonto auch mit Azure PowerShell oder mit der Azure CLI erstellen.You can also create an Azure storage account by using Azure PowerShell or Azure CLI.

Wenn Sie zu diesem Zeitpunkt kein Speicherkonto erstellen möchten, können Sie auch den Azure-Speicheremulator zum Ausführen und Testen Ihres Codes in einer lokalen Umgebung verwenden.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. Weitere Informationen finden Sie unter Einsatz des Azure-Speicheremulators für Entwicklung und Tests.For more information, see Use the Azure storage emulator for development and testing.

Erstellen eines Azure Cosmos DB-KontosCreate an Azure Cosmos DB account

Anweisungen zum Erstellen eines Kontos für die Azure Cosmos DB-Tabellen-API finden Sie unter Schnellstart: Erstellen einer Tabellen-API-App per .NET SDK und Azure Cosmos DB.For instructions on creating an Azure Cosmos DB Table API account, see Create a database account.

Erstellen einer Java-AnwendungCreate a Java application

In diesem Leitfaden verwenden Sie Speicherfunktionen, die lokal innerhalb einer Java-Anwendung oder in Code innerhalb einer Webrolle oder Workerrolle in Azure ausgeführt werden können.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.

Um die Beispiele in diesem Artikel zu verwenden, installieren Sie das Java Development Kit (JDK), und erstellen Sie dann ein Azure-Speicherkonto oder ein Azure Cosmos DB-Konto in Ihrem Azure-Abonnement.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. Sobald Sie dies erledigt haben, stellen Sie sicher, dass Ihr Entwicklungssystem die minimalen Anforderungen und Abhängigkeiten erfüllt, die im Repository Azure Storage-SDK für Java auf GitHub aufgeführt sind.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. Wenn Ihr System diese Anforderungen erfüllt, können Sie die Anweisungen für das Herunterladen und Installieren der Azure Storage-Bibliotheken für Java auf Ihr System von diesem Repository befolgen.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. Nach Abschluss dieser Aufgaben können Sie eine Java-Anwendung erstellen, die die Beispiele in diesem Artikel verwendet.After you complete those tasks, you can create a Java application that uses the examples in this article.

Konfigurieren Ihrer Anwendung für den Zugriff auf TabellenspeicherConfigure your application to access table storage

Fügen Sie folgende import-Anweisungen am Anfang der Java-Datei dort ein, wo Azure Storage-APIs oder die Azure Cosmos DB-Tabellen-API auf Tabellen zugreifen sollen: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.*;

Hinzufügen einer Azure-SpeicherverbindungszeichenfolgeAdd an Azure storage connection string

Ein Azure-Speicherclient verwendet eine Speicherverbindungszeichenfolge zum Speichern von Endpunkten und Anmeldeinformationen für den Zugriff auf Datenverwaltungsdienste.An Azure storage client uses a storage connection string to store endpoints and credentials for accessing data management services. Bei der Ausführung in einer Clientanwendung muss die Speicherverbindungszeichenfolge in dem unten gezeigten Format angegeben werden. Dabei müssen der Name Ihres Speicherkontos und der primäre Zugriffsschlüssel für das im Azure-Portal aufgeführte Speicherkonto als Werte für AccountName und AccountKey eingegeben werden.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.

Dieses Beispiel zeigt, wie Sie ein statisches Feld für die Verbindungszeichenfolge deklarieren: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";

Hinzufügen einer Verbindungszeichenfolge für die Azure Cosmos DB-Tabellen-APIAdd an Azure Cosmos DB Table API connection string

Ein Azure Cosmos DB-Konto verwendet eine Verbindungszeichenfolge, um den Endpunkt für die Tabelle und Ihre Anmeldeinformationen zu speichern.An Azure Cosmos DB account uses a connection string to store the table endpoint and your credentials. Bei der Ausführung in einer Clientanwendung muss die Azure Cosmos DB-Verbindungszeichenfolge in dem unten gezeigten Format angegeben werden. Dabei müssen der Name Ihres Azure Cosmos DB-Kontos und der primäre Zugriffsschlüssel für das im Azure-Portal aufgeführte Konto als Werte für AccountName und AccountKey eingegeben werden.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.

Dieses Beispiel zeigt, wie Sie ein statisches Feld für die Azure Cosmos DB-Verbindungszeichenfolge deklarieren: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 einer Anwendung, die in einer Azure-Rolle ausgeführt wird, können Sie diese Zeichenfolge in der Dienstkonfigurationsdatei ServiceConfiguration.cscfg speichern. Der Zugriff darauf kann dann durch Aufruf der Methode RoleEnvironment.getConfigurationSettings erfolgen.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. Dieses Beispiel zeigt, wie die Verbindungszeichenfolge von einem Setting-Element mit der Bezeichnung StorageConnectionString in der Dienstkonfigurationsdatei abgerufen wird: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");

Sie können die Verbindungszeichenfolge auch in der Datei „config.properties“ Ihres Projekts speichern: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/

In den folgenden Beispielen wird davon ausgegangen, dass Sie eine dieser Methoden verwendet haben, um die Speicherverbindungszeichenfolge abzurufen.The following samples assume that you have used one of these methods to get the storage connection string.

Erstellen einer TabelleCreate a table

Mit einem CloudTableClient-Objekt können Sie Referenzobjekte für Tabellen und Entitäten abrufen.A CloudTableClient object lets you get reference objects for tables and entities. Der folgende Code erstellt ein CloudTableClient-Objekt und verwendet es zum Erstellen eines neuen CloudTable-Objekts, das eine Tabelle mit der Bezeichnung „people“ darstellt.The following code creates a CloudTableClient object and uses it to create a new CloudTable object which represents a table named "people".

Hinweis

CloudStorageAccount-Objekte können auch auf andere Weise erstellt werden. Weitere Informationen finden Sie in der Referenz für Azure Storage-Client-SDKs unter CloudStorageAccount.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();
}

Auflisten der TabellenList the tables

Rufen Sie zum Abrufen einer Liste von Tabellen die Methode CloudTableClient.listTables() auf, um eine wiederholbare Liste der Tabellennamen abzurufen.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();
}

Hinzufügen einer Entität zu einer TabelleAdd an entity to a table

Entitäten werden mithilfe einer benutzerdefinierten Klasse, die TableEntitybereitstellt, Java-Objekten zugeordnet.Entities map to Java objects using a custom class implementing TableEntity. Der Einfachheit halber stellt die TableServiceEntity-Klasse TableEntity bereit und ordnet den für die Eigenschaften genannten Getter- und Setter-Methoden durch Reflexion Eigenschaften zu.For convenience, the TableServiceEntity class implements TableEntity and uses reflection to map properties to getter and setter methods named for the properties. Erstellen Sie zunächst eine Klasse, mit der die Eigenschaften der Entität definiert werden, um eine Entität zu einer Tabelle hinzuzufügen.To add an entity to a table, first create a class that defines the properties of your entity. Mit dem folgenden Code wird eine Entitätsklasse definiert, die den Vornamen des Kunden als Zeilenschlüssel und den Nachnamen als Partitionsschlüssel verwendet.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. In Kombination miteinander wird mit dem Partitions- und Zeilenschlüssel eine Entität in der Tabelle eindeutig identifiziert.Together, an entity's partition and row key uniquely identify the entity in the table. Entitäten mit demselben Partitionsschlüssel können schneller abgefragt werden als Entitäten mit verschiedenen Schlüsseln.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;
    }
}

Tabellenvorgänge, die Entitäten umfassen, benötigen ein TableOperation -Objekt.Table operations involving entities require a TableOperation object. Dieses Objekt definiert den für eine Entität vorgesehenen Vorgang, der mit einem CloudTable -Objekt ausgeführt werden kann.This object defines the operation to be performed on an entity, which can be executed with a CloudTable object. Durch den folgenden Code wird eine neue Instanz der CustomerEntity -Klasse erstellt, wobei einige Kundendaten gespeichert werden sollen.The following code creates a new instance of the CustomerEntity class with some customer data to be stored. Als Nächstes ruf der Code TableOperation.insertOrReplace auf, um ein TableOperation-Objekt für das Einfügen einer Entität in eine Tabelle zu erstellen, und weist dieser Entität die neue CustomerEntity zu.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. Abschließend ruft der Code die execute-Methode des CloudTable-Objekts auf und gibt dabei die Tabelle „people“ und die neue TableOperation an, die dann eine Anforderung an den Speicherdienst sendet, die neue Kundenentität in die Tabelle „people“ einzufügen oder die Entität zu ersetzen, wenn sie bereits vorhanden ist.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();
}

Einfügen eines EntitätsbatchsInsert a batch of entities

Sie können einen Entitätsbatch in einem Schreibvorgang in den Tabellendienst einfügen.You can insert a batch of entities to the table service in one write operation. Durch den folgenden Code wird ein TableBatchOperation -Objekt erstellt, zu dem anschließend drei Einfügevorgänge hinzugefügt werden.The following code creates a TableBatchOperation object, then adds three insert operations to it. Für jeden Einfügevorgang wird ein neues Entitätsobjekt erstellt, dessen Werte werden festgelegt, und dann wird die Methode insert für das TableBatchOperation-Objekt aufgerufen und die Entität einem neuen Einfügevorgang zugeordnet.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. Anschließend ruft der Code die execute-Methode für das CloudTable-Objekt auf und gibt dabei die Tabelle „people“ und das TableBatchOperation-Objekt an, das dann den Batch mit Tabellenvorgängen in einer einzelnen Anforderung an den Speicherdienst sendet.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();
}

Beachten Sie im Zusammenhang mit Batchvorgängen Folgendes:Some things to note on batch operations:

  • Bis zu 100 Einfüge-, Lösch-, Zusammenführungs-, Ersetzungs-, Einfüge- oder Zusammenführungs- und Einfüge- oder Ersetzungsvorgänge können in beliebiger Kombination in einem einzelnen Batch ausgeführt werden.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.
  • Ein Batchvorgang kann einen Abfragevorgang enthalten, allerdings nur als einzigen Vorgang in diesem Batch.A batch operation can have a retrieve operation, if it is the only operation in the batch.
  • Alle Entitäten in einem Batchvorgang müssen über denselben Partitionsschlüssel verfügen.All entities in a single batch operation must have the same partition key.
  • Ein Batchvorgang ist auf eine Nutzlast von 4 MB Daten beschränkt.A batch operation is limited to a 4MB data payload.

Abrufen aller Entitäten einer PartitionRetrieve all entities in a partition

Verwenden Sie ein TableQuery-Objekt, um eine Tabelle für Entitäten in einer Partition abzurufen.To query a table for entities in a partition, you can use a TableQuery. Rufen Sie TableQuery.from auf, um eine Abfrage in einer bestimmten Tabelle zu erstellen, die einen bestimmen Ergebnistyp übergibt.Call TableQuery.from to create a query on a particular table that returns a specified result type. Im folgenden Code wird ein Filter für Entitäten erstellt, wobei Smith der Partitionsschlüssel ist.The following code specifies a filter for entities where 'Smith' is the partition key. TableQuery.generateFilterCondition ist eine Helper-Methode für die Erstellung von Filtern für Abfragen.TableQuery.generateFilterCondition is a helper method to create filters for queries. Rufen Sie where für den von der TableQuery.from-Methode zurückgegebenen Verweis auf, um den Filter auf die Abfrage anzuwenden.Call where on the reference returned by the TableQuery.from method to apply the filter to the query. Wenn die Abfrage mit einem Aufruf der execute-Methode für das CloudTable-Objekt ausgeführt wird, übergibt sie einen Iterator mit CustomerEntity als Ergebnistyp.When the query is executed with a call to execute on the CloudTable object, it returns an Iterator with the CustomerEntity result type specified. Anschließend können Sie den übergebenen Iterator verwenden, um die Ergebnisse in jede Schleife einzubinden.You can then use the Iterator returned in a for each loop to consume the results. In diesem Code werden die Felder der einzelnen Entitäten in den Abfrageergebnissen an die Konsole ausgegeben.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();
}

Abrufen eines Entitätsbereichs in einer PartitionRetrieve a range of entities in a partition

Wenn Sie nicht alle Entitäten in einer Partition abrufen möchten, können Sie durch Verwendung von Vergleichsoperatoren einen Bereich angeben.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. Im folgenden Code werden zwei Filter kombiniert, um alle Entitäten in der Partition "Smith" abzurufen, deren Zeilenschlüssel (Vorname) mit einem Buchstaben vor dem Buchstaben "E" im Alphabet beginnen.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. Danach werden die Abfrageergebnisse ausgegeben.Then it prints the query results. Wenn Sie die im Bereich Batch-Einfügungen dieser Anleitung erstellten Entitäten verwenden, gibt diese Abfrage nur zwei Entitäten zurück (Ben und Denise Smith); Jeff Smith wird nicht zurückgegeben.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();
}

Abrufen einer einzelnen EntitätRetrieve a single entity

Sie können eine Abfrage schreiben, um eine einzelne bestimmte Entität abzurufen.You can write a query to retrieve a single, specific entity. Im folgenden Code wird der Kunde "Jeff Smith" nicht durch Erstellen einer TableQuery und Verwendung von Filtern übergeben, sondern durch Aufruf von TableOperation.retrieve mit Partitions- und Zeilenschlüsselparametern.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. Bei der Ausführung übergibt dieser Abfragevorgang nicht eine ganze Sammlung von Entitäten, sondern nur eine einzelne Entität.When executed, the retrieve operation returns just one entity, rather than a collection. Die Methode getResultAsType wandelt das Ergebnis in den Typ des Zuweisungsziels um, ein CustomerEntity-Objekt.The getResultAsType method casts the result to the type of the assignment target, a CustomerEntity object. Wenn dieser Typ mit dem für die Abfrage spezifizierten Typ nicht kompatibel ist, wird eine Ausnahme ausgelöst.If this type is not compatible with the type specified for the query, an exception is thrown. Wenn keine Entität mit exakter Partitions- und Zeilenübereinstimmung existiert, wird ein Nullwert zurückgegeben.A null value is returned if no entity has an exact partition and row key match. Die Angabe beider Schlüssel, Partition und Zeile, in einer Abfrage ist die schnellste Möglichkeit, um eine einzelne Entität aus dem Tabellenspeicherdienst abzurufen.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();
}

Ändern einer EntitätModify an entity

Um eine Entität zu ändern, rufen Sie sie aus dem Tabellendienst ab, ändern Sie das Entitätsobjekt, und speichern Sie die Änderungen dann mit einem Ersetzungs- oder Zusammenführungsvorgang im Tabellendienst.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. Mit dem folgenden Code wird die Telefonnummer eines vorhandenen Kunden geändert.The following code changes an existing customer's phone number. In diesem Fall wird nicht wie beim Einfügen TableOperation.insert, sondern TableOperation.replace aufgerufen.Instead of calling TableOperation.insert as we did to insert, this code calls TableOperation.replace. Die Methode CloudTable.execute ruft den Tabellendienst auf, und die Entität wird ersetzt, sofern sie nicht nach dem Aufruf durch diese Anwendung in der Zwischenzeit von einer anderen Anwendung geändert wurde.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. In diesem Fall wird eine Ausnahme ausgelöst, und die Entität muss erneut aufgerufen, geändert und gespeichert werden.When that happens, an exception is thrown, and the entity must be retrieved, modified, and saved again. Dieses auf dem "Optimistic Concurrency"-Verfahren (optimistisches Locking) basierende Muster für Wiederholungsversuche ist in verteilten Speichersystemen häufig anzutreffen.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();
}

Abfragen einer Teilmenge von EntitätseigenschaftenQuery a subset of entity properties

Mit einer Abfrage einer Tabelle können nur einige wenige Eigenschaften einer Entität aufgerufen werden.A query to a table can retrieve just a few properties from an entity. Mit dieser Technik, der sogenannten Projektion, wird die Bandbreite reduziert und die Abfrageleistung gesteigert, vor allem bei großen Entitäten.This technique, called projection, reduces bandwidth and can improve query performance, especially for large entities. Die Abfrage im folgenden Code übergibt mit der Methode select nur die E-Mail-Adressen von Entitäten in der Tabelle.The query in the following code uses the select method to return only the email addresses of entities in the table. Die Ergebnisse werden mit Unterstützung eines EntityResolver, der die Typumwandlung der vom Server übergebenen Entitäten übernimmt, in eine Sammlung von String-Objekten projiziert.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. Weitere Informationen zur Projektion finden Sie in [Azure Tables: Introducing Upsert and Query Projection (Azure-Tabellen: Einführung in Upsert- und Abfrageprojektion)][Azure Tables: Introducing Upsert and Query Projection].You can learn more about projection in [Azure Tables: Introducing Upsert and Query Projection][Azure Tables: Introducing Upsert and Query Projection]. Beachten Sie, dass die Projektion nicht auf dem lokalen Speicheremulator unterstützt wird und dieser Code deshalb nur bei der Verwendung eines Kontos für den Tabellendienst ausgeführt wird.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();
}

Einfügen oder Ersetzen einer EntitätInsert or Replace an entity

Es kommt häufig vor, dass Sie eine Entität in eine Tabelle einfügen möchten, ohne zuvor prüfen zu müssen, ob diese Entität bereits in der Tabelle vorhanden ist.Often you want to add an entity to a table without knowing if it already exists in the table. Mit einem Einfügen-oder-Ersetzen-Vorgang genügt eine einzelne Anforderung, um eine nicht vorhandene Entität einzufügen oder eine vorhandene zu ersetzen.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. Ausgehend von vorherigen Beispielen wird durch diesen Code die Entität für "Walter Harp" eingefügt oder ersetzt.Building on prior examples, the following code inserts or replaces the entity for "Walter Harp". Nachdem eine neue Entität erstellt worden ist, ruft dieser Code die Methode TableOperation.insertOrReplace auf.After creating a new entity, this code calls the TableOperation.insertOrReplace method. Anschließend ruft der Code die Methode execute für das CloudTable-Objekt auf und spezifiziert als Parameter die Tabelle und den Einfügen-oder-Ersetzen-Vorgang.This code then calls execute on the CloudTable object with the table and the insert or replace table operation as the parameters. Wenn nur ein Teil einer Entität aktualisiert werden sollen, kann stattdessen die Methode TableOperation.insertOrMerge verwendet werden.To update only part of an entity, the TableOperation.insertOrMerge method can be used instead. Hinweis: Einfügen-oder-Ersetzen-Vorgänge werden auf dem lokalen Speicheremulator nicht unterstützt, weshalb dieser Code nur bei Verwendung eines Kontos auf dem Tabellendienst ausgeführt wird.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. Weitere Informationen zu Einfügen-oder-Ersetzen- und Einfügen-oder-Zusammenfügen-Vorgängen finden Sie unter [Azure Tables: Introducing Upsert and Query Projection (Azure-Tabellen: Einführung in Upsert- und Abfrageprojektion)][Azure Tables: Introducing Upsert and Query Projection].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();
}

Löschen einer EntitätDelete an entity

Sie können eine Entität problemlos nach dem Abrufen löschen.You can easily delete an entity after you have retrieved it. Rufen Sie nach dem Abrufen der Entität die Methode TableOperation.delete mit der zu löschenden Entität auf.After the entity is retrieved, call TableOperation.delete with the entity to delete. Rufen Sie dann execute für das CloudTable-Objekt auf.Then call execute on the CloudTable object. Durch den nachstehenden Code wird eine Kundenentität aufgerufen und gelöscht.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();
}

Löschen einer TabelleDelete a table

Schließlich wird mit dem folgenden Code eine Tabelle aus einem Speicherkonto gelöscht.Finally, the following code deletes a table from a storage account. Etwa 40 Sekunden nach dem Löschen einer Tabelle können Sie sie nicht neu erstellen.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();
}

Tipp

Repository mit Azure Storage-CodebeispielenCheck out the Azure Storage code samples repository

In unserer Liste mit Azure Storage-Beispielen finden Sie benutzerfreundliche, umfassende Azure Storage-Codebeispiele, die Sie herunterladen und ausführen können.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.

Nächste SchritteNext steps

Weitere Informationen finden Sie im Artikel Azure für Java-Entwickler.For more information, visit Azure for Java developers.