Quickstart: Een API voor Table-app bouwen met Java SDK en Azure Cosmos DB
VAN TOEPASSING OP:
Tabel
In deze quickstart ziet u hoe u toegang hebt tot de Tabellen-API van Azure Cosmos DB vanuit een Java-toepassing. De Tabellen-API van Azure Cosmos DB is een schemaloos gegevensarchief waarmee toepassingen gestructureerde NoSQL-gegevens kunnen opslaan in de cloud. Omdat gegevens worden opgeslagen in een schemaloos ontwerp, worden nieuwe eigenschappen (kolommen) automatisch aan de tabel toegevoegd wanneer een object met een nieuw kenmerk aan de tabel wordt toegevoegd.
Java-toepassingen hebben toegang tot de Tabellen-API van Azure Cosmos DB met behulp van de clientbibliotheek azure-data-tables .
Vereisten
De voorbeeldtoepassing is geschreven in Spring Boot 2.6.4. U kunt Visual Studio Code of IntelliJ IDEA gebruiken als een IDE.
Als u geen Azure-abonnement hebt, maakt u een gratis account voordat u begint.
Voorbeeldtoepassing
De voorbeeldtoepassing voor deze zelfstudie kan worden gekloond of gedownload uit de opslagplaats https://github.com/Azure-Samples/msdocs-azure-data-tables-sdk-java. Zowel een starters- als een voltooide app zijn opgenomen in de voorbeeldopslagplaats.
git clone https://github.com/Azure-Samples/msdocs-azure-data-tables-sdk-java
De voorbeeldtoepassing gebruikt weergegevens als voorbeeld om de mogelijkheden van de Tables-API te demonstreren. Objecten die weerobservaties vertegenwoordigen, worden opgeslagen en opgehaald met behulp van de API voor Table, inclusief het opslaan van objecten met aanvullende eigenschappen om de schemaloze mogelijkheden van de Tabellen-API te demonstreren.
1 - Een Azure Cosmos DB-account maken
U moet eerst een Azure Cosmos DB Tables API-account maken dat de tabel(s) bevat die in uw toepassing worden gebruikt. Dit kan worden gedaan met behulp van de Azure Portal, Azure CLI of Azure PowerShell.
Meld u aan bij de Azure Portal en volg deze stappen om een Azure Cosmos DB-account te maken.
| Instructies | Schermopname |
|---|---|
In Azure Portal:
|
|
| Selecteer +Maken op de pagina Azure Cosmos DB. | 
|
| Kies op de pagina API-optie selecteren de optie Azure-tabel . | 
|
Vul op de pagina Azure Cosmos DB-account maken - Azure Table het formulier als volgt in.
|
|
2 - Een tabel maken
Vervolgens moet u een tabel maken in uw Azure Cosmos DB-account die uw toepassing kan gebruiken. In tegenstelling tot een traditionele database hoeft u alleen de naam van de tabel op te geven, niet de eigenschappen (kolommen) in de tabel. Wanneer gegevens in de tabel worden geladen, worden de eigenschappen (kolommen) automatisch gemaakt als dat nodig is.
Voer in de Azure Portal de volgende stappen uit om een tabel te maken in uw Azure Cosmos DB-account.
| Instructies | Schermopname |
|---|---|
| Ga in de Azure Portal naar de overzichtspagina voor het Azure Cosmos DB-account. U kunt naar de overzichtspagina voor uw Azure Cosmos DB-account navigeren door de naam (cosmos-msdocs-tables-sdk-demo-XYZ) van uw Azure Cosmos DB-account in de bovenste zoekbalk te typen en te kijken onder de kop resources. Selecteer de naam van uw Azure Cosmos DB-account om naar de overzichtspagina te gaan. | 
|
| Selecteer +Tabel toevoegen op de overzichtspagina. Het dialoogvenster Nieuwe tabel wordt vanaf de rechterkant van de pagina naar buiten geschoven. | 
|
Vul in het dialoogvenster Nieuwe tabel het formulier als volgt in.
|
|
3 - Azure Cosmos DB-connection string ophalen
Voor toegang tot uw tabel(s) in Azure Cosmos DB heeft uw app de tabel connection string nodig voor het CosmosDB Storage-account. De connection string kan worden opgehaald met behulp van de Azure Portal, Azure CLI of Azure PowerShell.
| Instructies | Schermopname |
|---|---|
| Zoek aan de linkerkant van de azure Cosmos DB-accountpagina het menu-item met de naam Verbindingsreeks onder de kop Instellingen en selecteer deze. U wordt naar een pagina geleid waar u de connection string voor het opslagaccount kunt ophalen. | 
|
| Kopieer de waarde van PRIMARY CONNECTION STRING die u in uw toepassing wilt gebruiken. | 
|
De connection string voor uw Azure Cosmos DB-account wordt beschouwd als een app-geheim en moet net als elk ander app-geheim of wachtwoord worden beveiligd. In dit voorbeeld wordt de POM gebruikt om de connection string tijdens de ontwikkeling op te slaan en beschikbaar te maken voor de toepassing.
<profiles>
<profile>
<id>local</id>
<properties>
<azure.tables.connection.string>
<![CDATA[YOUR-DATA-TABLES-SERVICE-CONNECTION-STRING]]>
</azure.tables.connection.string>
<azure.tables.tableName>WeatherData</azure.tables.tableName>
</properties>
<activation>
<activeByDefault>true</activeByDefault>
</activation>
</profile>
</profiles>
4 - Neem het pakket azure-data-tables op
Neem het pakket azure-data-tables op om toegang te krijgen tot de Azure Cosmos DB Tables-API vanuit een Java-toepassing.
<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-data-tables</artifactId>
<version>12.2.1</version>
</dependency>
5 - De tabelclient configureren in TableServiceConfig.java
De Azure SDK communiceert met Azure met behulp van clientobjecten om verschillende bewerkingen uit te voeren op Azure. Het TableClient-object is het object dat wordt gebruikt om te communiceren met de Azure Cosmos DB Tables-API.
Een toepassing maakt doorgaans één TableClient-object per tabel dat in de hele toepassing moet worden gebruikt. Het wordt aanbevolen om aan te geven dat een methode een TableClient-objectbak produceert die moet worden beheerd door de Spring-container en als een singleton om dit te bereiken.
Bewerk in het TableServiceConfig.java bestand van de toepassing de tableClientConfiguration() methode zodat deze overeenkomt met het volgende codefragment:
@Configuration
public class TableServiceConfiguration {
private static String TABLE_NAME;
private static String CONNECTION_STRING;
@Value("${azure.tables.connection.string}")
public void setConnectionStringStatic(String connectionString) {
TableServiceConfiguration.CONNECTION_STRING = connectionString;
}
@Value("${azure.tables.tableName}")
public void setTableNameStatic(String tableName) {
TableServiceConfiguration.TABLE_NAME = tableName;
}
@Bean
public TableClient tableClientConfiguration() {
return new TableClientBuilder()
.connectionString(CONNECTION_STRING)
.tableName(TABLE_NAME)
.buildClient();
}
}
U moet ook de volgende instructie toevoegen aan de bovenkant van het TableServiceConfig.java bestand.
import com.azure.data.tables.TableClient;
import com.azure.data.tables.TableClientBuilder;
6 - Azure Cosmos DB-tabelbewerkingen implementeren
Alle Azure Cosmos DB-tabelbewerkingen voor de voorbeeld-app worden geïmplementeerd in de TablesServiceImpl klasse die zich in de map Services bevindt. U moet het com.azure.data.tables SDK-pakket importeren.
import com.azure.data.tables.TableClient;
import com.azure.data.tables.models.ListEntitiesOptions;
import com.azure.data.tables.models.TableEntity;
import com.azure.data.tables.models.TableTransactionAction;
import com.azure.data.tables.models.TableTransactionActionType;
Voeg aan het begin van de TableServiceImpl klasse een lidvariabele toe voor het TableClient-object en een constructor zodat het TableClient-object kan worden geïnjecteerd in de klasse.
@Autowired
private TableClient tableClient;
Rijen ophalen uit een tabel
De klasse TableClient bevat een methode met de naam listEntities waarmee u rijen uit de tabel kunt selecteren. Omdat in dit voorbeeld geen parameters worden doorgegeven aan de methode, worden alle rijen uit de tabel geselecteerd.
De methode gebruikt ook een algemene parameter van het type TableEntity die aangeeft dat de modelklassegegevens als worden geretourneerd. In dit geval wordt de ingebouwde klasse TableEntity gebruikt, wat betekent dat de listEntities methode een PagedIterable<TableEntity> verzameling als resultaat retourneert.
public List<WeatherDataModel> retrieveAllEntities() {
List<WeatherDataModel> modelList = tableClient.listEntities().stream()
.map(WeatherDataUtils::mapTableEntityToWeatherDataModel)
.collect(Collectors.toList());
return Collections.unmodifiableList(WeatherDataUtils.filledValue(modelList));
}
De TableEntity-klasse die in het com.azure.data.tables.models pakket is gedefinieerd, heeft eigenschappen voor de partitiesleutel en rijsleutelwaarden in de tabel. Samen zijn deze twee waarden voor een unieke sleutel voor de rij in de tabel. In deze voorbeeldtoepassing wordt de naam van het weerstation (plaats) opgeslagen in de partitiesleutel en wordt de datum/tijd van de waarneming opgeslagen in de rijsleutel. Alle andere eigenschappen (temperatuur, vochtigheid, windsnelheid) worden opgeslagen in een woordenlijst in het TableEntity object.
Het is gebruikelijk om een TableEntity-object toe te wijzen aan een object van uw eigen definitie. De voorbeeldtoepassing definieert voor dit doel een klasse WeatherDataModel in de map Modellen . Deze klasse heeft eigenschappen voor de naam van het station en de observatiedatum waaraan de partitiesleutel en rijsleutel worden toegewezen, waardoor meer betekenisvolle eigenschapsnamen voor deze waarden worden geboden. Vervolgens wordt een woordenlijst gebruikt om alle andere eigenschappen op het object op te slaan. Dit is een veelvoorkomend patroon bij het werken met Table Storage, omdat een rij een willekeurig aantal willekeurige eigenschappen kan hebben en we willen dat onze modelobjecten deze allemaal kunnen vastleggen. Deze klasse bevat ook methoden om de eigenschappen van de klasse weer te geven.
public class WeatherDataModel {
public WeatherDataModel(String stationName, String observationDate, OffsetDateTime timestamp, String etag) {
this.stationName = stationName;
this.observationDate = observationDate;
this.timestamp = timestamp;
this.etag = etag;
}
private String stationName;
private String observationDate;
private OffsetDateTime timestamp;
private String etag;
private Map<String, Object> propertyMap = new HashMap<String, Object>();
public String getStationName() {
return stationName;
}
public void setStationName(String stationName) {
this.stationName = stationName;
}
public String getObservationDate() {
return observationDate;
}
public void setObservationDate(String observationDate) {
this.observationDate = observationDate;
}
public OffsetDateTime getTimestamp() {
return timestamp;
}
public void setTimestamp(OffsetDateTime timestamp) {
this.timestamp = timestamp;
}
public String getEtag() {
return etag;
}
public void setEtag(String etag) {
this.etag = etag;
}
public Map<String, Object> getPropertyMap() {
return propertyMap;
}
public void setPropertyMap(Map<String, Object> propertyMap) {
this.propertyMap = propertyMap;
}
}
De mapTableEntityToWeatherDataModel methode wordt gebruikt om een TableEntity-object toe te wijzen aan een WeatherDataModel -object. De mapTableEntityToWeatherDataModel methode wijst de PartitionKeyeigenschappen , RowKey, Timestampen Etag rechtstreeks toe en gebruikt vervolgens de properties.keySet om de andere eigenschappen in het TableEntity object te herhalen en toe te wijzen aan het WeatherDataModel object, minus de eigenschappen die al rechtstreeks zijn toegewezen.
Bewerk de code in de mapTableEntityToWeatherDataModel methode zodat deze overeenkomt met het volgende codeblok.
public static WeatherDataModel mapTableEntityToWeatherDataModel(TableEntity entity) {
WeatherDataModel observation = new WeatherDataModel(
entity.getPartitionKey(), entity.getRowKey(),
entity.getTimestamp(), entity.getETag());
rearrangeEntityProperties(observation.getPropertyMap(), entity.getProperties());
return observation;
}
private static void rearrangeEntityProperties(Map<String, Object> target, Map<String, Object> source) {
Constants.DEFAULT_LIST_OF_KEYS.forEach(key -> {
if (source.containsKey(key)) {
target.put(key, source.get(key));
}
});
source.keySet().forEach(key -> {
if (Constants.DEFAULT_LIST_OF_KEYS.parallelStream().noneMatch(defaultKey -> defaultKey.equals(key))
&& Constants.EXCLUDE_TABLE_ENTITY_KEYS.parallelStream().noneMatch(defaultKey -> defaultKey.equals(key))) {
target.put(key, source.get(key));
}
});
}
Rijen filteren die worden geretourneerd vanuit een tabel
Als u de rijen wilt filteren die uit een tabel worden geretourneerd, kunt u een OData-stijlfilterreeks doorgeven aan de methode listEntities . Als u bijvoorbeeld alle weerwaarden voor Chicago wilt ophalen tussen 1 juli 2021 middernacht en 2 juli 2021 (inclusief) middernacht, geeft u de volgende filtertekenreeks door.
PartitionKey eq 'Chicago' and RowKey ge '2021-07-01 12:00 AM' and RowKey le '2021-07-02 12:00 AM'
U kunt alle OData-filteroperators op de OData-website weergeven in de sectie Filtersysteemqueryoptie
In de voorbeeldtoepassing is het FilterResultsInputModel object ontworpen om filtercriteria vast te leggen die door de gebruiker zijn opgegeven.
public class FilterResultsInputModel implements Serializable {
private String partitionKey;
private String rowKeyDateStart;
private String rowKeyTimeStart;
private String rowKeyDateEnd;
private String rowKeyTimeEnd;
private Double minTemperature;
private Double maxTemperature;
private Double minPrecipitation;
private Double maxPrecipitation;
public String getPartitionKey() {
return partitionKey;
}
public void setPartitionKey(String partitionKey) {
this.partitionKey = partitionKey;
}
public String getRowKeyDateStart() {
return rowKeyDateStart;
}
public void setRowKeyDateStart(String rowKeyDateStart) {
this.rowKeyDateStart = rowKeyDateStart;
}
public String getRowKeyTimeStart() {
return rowKeyTimeStart;
}
public void setRowKeyTimeStart(String rowKeyTimeStart) {
this.rowKeyTimeStart = rowKeyTimeStart;
}
public String getRowKeyDateEnd() {
return rowKeyDateEnd;
}
public void setRowKeyDateEnd(String rowKeyDateEnd) {
this.rowKeyDateEnd = rowKeyDateEnd;
}
public String getRowKeyTimeEnd() {
return rowKeyTimeEnd;
}
public void setRowKeyTimeEnd(String rowKeyTimeEnd) {
this.rowKeyTimeEnd = rowKeyTimeEnd;
}
public Double getMinTemperature() {
return minTemperature;
}
public void setMinTemperature(Double minTemperature) {
this.minTemperature = minTemperature;
}
public Double getMaxTemperature() {
return maxTemperature;
}
public void setMaxTemperature(Double maxTemperature) {
this.maxTemperature = maxTemperature;
}
public Double getMinPrecipitation() {
return minPrecipitation;
}
public void setMinPrecipitation(Double minPrecipitation) {
this.minPrecipitation = minPrecipitation;
}
public Double getMaxPrecipitation() {
return maxPrecipitation;
}
public void setMaxPrecipitation(Double maxPrecipitation) {
this.maxPrecipitation = maxPrecipitation;
}
}
Wanneer dit object wordt doorgegeven aan de retrieveEntitiesByFilter methode in de TableServiceImpl klasse, wordt er een filtertekenreeks gemaakt voor elke niet-null-eigenschapswaarde. Vervolgens wordt een gecombineerde filtertekenreeks gemaakt door alle waarden samen te voegen met een 'and'-component. Deze gecombineerde filtertekenreeks wordt doorgegeven aan de methode listEntities in het TableClient-object en alleen rijen die overeenkomen met de filtertekenreeks worden geretourneerd. U kunt een vergelijkbare methode in uw code gebruiken om geschikte filterreeksen te maken, zoals vereist door uw toepassing.
public List<WeatherDataModel> retrieveEntitiesByFilter(FilterResultsInputModel model) {
List<String> filters = new ArrayList<>();
if (!StringUtils.isEmptyOrWhitespace(model.getPartitionKey())) {
filters.add(String.format("PartitionKey eq '%s'", model.getPartitionKey()));
}
if (!StringUtils.isEmptyOrWhitespace(model.getRowKeyDateStart())
&& !StringUtils.isEmptyOrWhitespace(model.getRowKeyTimeStart())) {
filters.add(String.format("RowKey ge '%s %s'", model.getRowKeyDateStart(), model.getRowKeyTimeStart()));
}
if (!StringUtils.isEmptyOrWhitespace(model.getRowKeyDateEnd())
&& !StringUtils.isEmptyOrWhitespace(model.getRowKeyTimeEnd())) {
filters.add(String.format("RowKey le '%s %s'", model.getRowKeyDateEnd(), model.getRowKeyTimeEnd()));
}
if (model.getMinTemperature() != null) {
filters.add(String.format("Temperature ge %f", model.getMinTemperature()));
}
if (model.getMaxTemperature() != null) {
filters.add(String.format("Temperature le %f", model.getMaxTemperature()));
}
if (model.getMinPrecipitation() != null) {
filters.add(String.format("Precipitation ge %f", model.getMinPrecipitation()));
}
if (model.getMaxPrecipitation() != null) {
filters.add(String.format("Precipitation le %f", model.getMaxPrecipitation()));
}
List<WeatherDataModel> modelList = tableClient.listEntities(new ListEntitiesOptions()
.setFilter(String.join(" and ", filters)), null, null).stream()
.map(WeatherDataUtils::mapTableEntityToWeatherDataModel)
.collect(Collectors.toList());
return Collections.unmodifiableList(WeatherDataUtils.filledValue(modelList));
}
Gegevens invoegen met behulp van een TableEntity-object
De eenvoudigste manier om gegevens aan een tabel toe te voegen, is met behulp van een TableEntity-object . In dit voorbeeld worden gegevens vanuit een invoermodelobject toegewezen aan een TableEntity-object . De eigenschappen van het invoerobject die de naam van het weerstation en de observatiedatum/-tijd vertegenwoordigen, worden toegewezen aan respectievelijk de PartitionKey eigenschappen en RowKey) die samen een unieke sleutel vormen voor de rij in de tabel. Vervolgens worden de aanvullende eigenschappen van het invoermodelobject toegewezen aan woordenlijsteigenschappen in het TableClient-object . Ten slotte wordt de methode createEntity voor het TableClient-object gebruikt om gegevens in de tabel in te voegen.
Wijzig de insertEntity klasse in de voorbeeldtoepassing zodat deze de volgende code bevat.
public void insertEntity(WeatherInputModel model) {
tableClient.createEntity(WeatherDataUtils.createTableEntity(model));
}
Gegevens upsert met behulp van een TableEntity-object
Als u probeert een rij in te voegen in een tabel met een combinatie van partitiesleutel en rijsleutel die al in die tabel bestaat, krijgt u een foutmelding. Daarom is het vaak beter om de upsertEntity te gebruiken in plaats van de insertEntity methode bij het toevoegen van rijen aan een tabel. Als de opgegeven combinatie van partitiesleutel/rijsleutel al in de tabel bestaat, wordt de bestaande rij bijgewerkt met de methode upsertEntity . Anders wordt de rij toegevoegd aan de tabel.
public void upsertEntity(WeatherInputModel model) {
tableClient.upsertEntity(WeatherDataUtils.createTableEntity(model));
}
Gegevens invoegen of upserten met variabele eigenschappen
Een van de voordelen van het gebruik van de Tabellen-API van Azure Cosmos DB is dat als een object dat in een tabel wordt geladen nieuwe eigenschappen bevat, deze eigenschappen automatisch worden toegevoegd aan de tabel en de waarden die zijn opgeslagen in Azure Cosmos DB. U hoeft geen DDL-instructies uit te voeren om ALTER TABLE kolommen toe te voegen zoals in een traditionele database.
Dit model biedt uw toepassing flexibiliteit bij het omgaan met gegevensbronnen die in de loop van de tijd kunnen toevoegen of wijzigen welke gegevens moeten worden vastgelegd, of wanneer verschillende invoergegevens verschillende gegevens leveren aan uw toepassing. In de voorbeeldtoepassing kunnen we een weerstation simuleren dat niet alleen de basisweergegevens verzendt, maar ook enkele aanvullende waarden. Wanneer een object met deze nieuwe eigenschappen voor het eerst in de tabel wordt opgeslagen, worden de bijbehorende eigenschappen (kolommen) automatisch aan de tabel toegevoegd.
In de voorbeeldtoepassing is de ExpandableWeatherObject klasse gebouwd rond een interne woordenlijst ter ondersteuning van een set eigenschappen op het object. Deze klasse vertegenwoordigt een typisch patroon voor wanneer een object een willekeurige set eigenschappen moet bevatten.
public class ExpandableWeatherObject {
private String stationName;
private String observationDate;
private Map<String, Object> propertyMap = new HashMap<String, Object>();
public String getStationName() {
return stationName;
}
public void setStationName(String stationName) {
this.stationName = stationName;
}
public String getObservationDate() {
return observationDate;
}
public void setObservationDate(String observationDate) {
this.observationDate = observationDate;
}
public Map<String, Object> getPropertyMap() {
return propertyMap;
}
public void setPropertyMap(Map<String, Object> propertyMap) {
this.propertyMap = propertyMap;
}
public boolean containsProperty(String key) {
return this.propertyMap.containsKey(key);
}
public Object getPropertyValue(String key) {
return containsProperty(key) ? this.propertyMap.get(key) : null;
}
public void putProperty(String key, Object value) {
this.propertyMap.put(key, value);
}
public List<String> getPropertyKeys() {
List<String> list = Collections.synchronizedList(new ArrayList<String>());
Iterator<String> iterators = this.propertyMap.keySet().iterator();
while (iterators.hasNext()) {
list.add(iterators.next());
}
return Collections.unmodifiableList(list);
}
public Integer getPropertyCount() {
return this.propertyMap.size();
}
}
Als u een dergelijk object wilt invoegen of upsert met behulp van de API voor Tabel, wijst u de eigenschappen van het uitbreidbare object toe aan een TableEntity-object en gebruikt u de methoden createEntity of upsertEntity op het TableClient-object .
public void insertExpandableEntity(ExpandableWeatherObject model) {
tableClient.createEntity(WeatherDataUtils.createTableEntity(model));
}
public void upsertExpandableEntity(ExpandableWeatherObject model) {
tableClient.upsertEntity(WeatherDataUtils.createTableEntity(model));
}
Een entiteit bijwerken
Entiteiten kunnen worden bijgewerkt door de methode updateEntity aan te roepen voor het TableClient-object . Omdat een entiteit (rij) die is opgeslagen met behulp van de Tables-API elke willekeurige set eigenschappen kan bevatten, is het vaak handig om een updateobject te maken op basis van een woordenlijstobject dat vergelijkbaar is met het ExpandableWeatherObject eerder besproken object. In dit geval is het enige verschil de toevoeging van een etag eigenschap die wordt gebruikt voor gelijktijdigheidsbeheer tijdens updates.
public class UpdateWeatherObject {
private String stationName;
private String observationDate;
private String etag;
private Map<String, Object> propertyMap = new HashMap<String, Object>();
public String getStationName() {
return stationName;
}
public void setStationName(String stationName) {
this.stationName = stationName;
}
public String getObservationDate() {
return observationDate;
}
public void setObservationDate(String observationDate) {
this.observationDate = observationDate;
}
public String getEtag() {
return etag;
}
public void setEtag(String etag) {
this.etag = etag;
}
public Map<String, Object> getPropertyMap() {
return propertyMap;
}
public void setPropertyMap(Map<String, Object> propertyMap) {
this.propertyMap = propertyMap;
}
}
In de voorbeeld-app wordt dit object doorgegeven aan de updateEntity methode in de TableServiceImpl klasse . Met deze methode wordt eerst de bestaande entiteit uit de Tables-API geladen met behulp van de methode getEntity op de TableClient. Vervolgens wordt dat entiteitsobject bijgewerkt en wordt de updateEntity methode gebruikt om de updates op te slaan in de database. U ziet hoe de updateEntity-methode de huidige Etag van het object gebruikt om ervoor te zorgen dat het object niet is gewijzigd sinds het in eerste instantie is geladen. Als u de entiteit toch wilt bijwerken, kunt u een waarde van etag doorgeven aan de updateEntity methode.
public void updateEntity(UpdateWeatherObject model) {
TableEntity tableEntity = tableClient.getEntity(model.getStationName(), model.getObservationDate());
Map<String, Object> propertiesMap = model.getPropertyMap();
propertiesMap.keySet().forEach(key -> tableEntity.getProperties().put(key, propertiesMap.get(key)));
tableClient.updateEntity(tableEntity);
}
Een entiteit verwijderen
Als u een entiteit uit een tabel wilt verwijderen, roept u de methode deleteEntity aan op het TableClient-object met de partitiesleutel en rijsleutel van het object.
public void deleteEntity(WeatherInputModel model) {
tableClient.deleteEntity(model.getStationName(),
WeatherDataUtils.formatRowKey(model.getObservationDate(), model.getObservationTime()));
}
7 - De code uitvoeren
Voer de voorbeeldtoepassing uit om te communiceren met de Azure Cosmos DB Tables-API. De eerste keer dat u de toepassing uitvoert, zijn er geen gegevens omdat de tabel leeg is. Gebruik een van de knoppen boven aan de toepassing om gegevens toe te voegen aan de tabel.
Als u de knop Invoegen met tabelentiteit selecteert, wordt een dialoogvenster geopend waarin u een nieuwe rij kunt invoegen of een nieuwe rij kunt wijzigen met behulp van een TableEntity -object.
Als u de knop Invoegen met uitvouwbare gegevens selecteert, wordt een dialoogvenster geopend waarin u een object met aangepaste eigenschappen kunt invoegen. Hiermee wordt gedemonstreerd hoe de Azure Cosmos DB Tables-API automatisch eigenschappen (kolommen) aan de tabel toevoegt wanneer dat nodig is. Gebruik de knop Aangepast veld toevoegen om een of meer nieuwe eigenschappen toe te voegen en deze mogelijkheid te demonstreren.
Gebruik de knop Voorbeeldgegevens invoegen om voorbeeldgegevens in uw Azure Cosmos DB-tabel te laden.
Selecteer het item Resultaten filteren in het bovenste menu om naar de pagina Resultaten filteren te gaan. Vul op deze pagina de filtercriteria in om te laten zien hoe een filtercomponent kan worden gebouwd en doorgegeven aan de Azure Cosmos DB Tables-API.
Resources opschonen
Wanneer u klaar bent met de voorbeeldtoepassing, moet u alle Azure-resources met betrekking tot dit artikel verwijderen uit uw Azure-account. U kunt dit doen door de resourcegroep te verwijderen.
Een resourcegroep kan als volgt worden verwijderd met behulp van de Azure Portal.
| Instructies | Schermopname |
|---|---|
| Als u naar de resourcegroep wilt gaan, typt u in de zoekbalk de naam van de resourcegroep. Selecteer vervolgens op het tabblad Resourcegroepen de naam van de resourcegroep. | 
|
| Selecteer Resourcegroep verwijderen op de werkbalk bovenaan de pagina van de resourcegroep. | 
|
Er verschijnt een dialoogvenster aan de rechterkant van het scherm waarin u wordt gevraagd om het verwijderen van de resourcegroep te bevestigen.
|
|
Volgende stappen
In deze Quick Start hebt u geleerd hoe u een Azure Cosmos DB-account kunt maken, hebt u een tabel gemaakt met de Data Explorer en hebt u een app uitgevoerd. U kunt nu een query uitvoeren op uw gegevens met behulp van de API voor Tabel.