Quickstart: Een API voor table-app bouwen met Java SDK en Azure Cosmos DB
VAN TOEPASSING OP: 
Tafel
In deze quickstart ziet u hoe u toegang hebt tot de Azure Cosmos DB Tables-API vanuit een Java-toepassing. De Azure Cosmos DB Tables-API is een schemaloze gegevensopslag waarmee toepassingen gestructureerde NoSQL-gegevens in de cloud kunnen opslaan. Omdat gegevens worden opgeslagen in een schemaloos ontwerp, worden nieuwe eigenschappen (kolommen) automatisch toegevoegd aan de tabel wanneer een object met een nieuw kenmerk wordt toegevoegd aan de tabel.
Java-toepassingen hebben toegang tot de Azure Cosmos DB Tables-API met behulp van de azure-data-tables-clientbibliotheek .
Vereisten
De voorbeeldtoepassing is geschreven in Spring Boot 2.6.4. U kunt Visual Studio Code of IntelliJ IDEA als een IDE gebruiken.
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 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, waaronder het opslaan van objecten met extra eigenschappen om de schemaloze mogelijkheden van de Tables-API te demonstreren.
1 - Een Azure Cosmos DB-account maken
U moet eerst een Azure Cosmos DB Tables-API-account maken dat de tabellen bevat die in uw toepassing worden gebruikt. U kunt dit doen met behulp van Azure Portal, Azure CLI of Azure PowerShell.
Meld u aan bij Azure Portal en volg deze stappen om een Azure Cosmos DB-account te maken.
| Instructies | Schermafbeelding |
|---|---|
In Azure Portal:
|
|
| Selecteer +Maken op de pagina Azure Cosmos DB. | 
|
| Kies op de pagina API-optie selecteren de optie Azure Table . | 
|
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 om uw toepassing te kunnen 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 uw tabel worden geladen, worden de eigenschappen (kolommen) automatisch zo nodig gemaakt.
Voer in Azure Portal de volgende stappen uit om een tabel in uw Azure Cosmos DB-account te maken.
| Instructies | Schermafbeelding |
|---|---|
| Navigeer in 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 onder de kop resources te kijken. 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 schuift vanaf de rechterkant van de pagina uit. | 
|
Vul in het dialoogvenster Nieuwe tabel het formulier als volgt in.
|
|
3 - Azure Cosmos DB-verbindingsreeks ophalen
Voor toegang tot uw tabellen in Azure Cosmos DB heeft uw app de tabel verbindingsreeks nodig voor het CosmosDB-opslagaccount. De verbindingsreeks kunnen worden opgehaald met behulp van Azure Portal, Azure CLI of Azure PowerShell.
| Instructies | Schermafbeelding |
|---|---|
| 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 gaat naar een pagina waar u de verbindingsreeks voor het opslagaccount kunt ophalen. | 
|
| Kopieer de waarde PRIMARY CONNECTION STRING die u wilt gebruiken in uw toepassing. | 
|
De verbindingsreeks voor uw Azure Cosmos DB-account wordt beschouwd als een app-geheim en moet worden beveiligd als elk ander app-geheim of wachtwoord. In dit voorbeeld wordt de POM gebruikt om de verbindingsreeks op te slaan tijdens de ontwikkeling en deze 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 - Het pakket azure-data-tables opnemen
Als u toegang wilt krijgen tot de Azure Cosmos DB Tables-API vanuit een Java-toepassing, neemt u het pakket azure-data-tables op.
<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 is raadzaam om aan te geven dat een methode een TableClient-object-bean produceert om te 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 using-instructie toevoegen boven aan 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 in de klasse kan worden geïnjecteerd.
@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 er 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 waarmee de modelklassegegevens worden geretourneerd als. In dit geval wordt de ingebouwde klasse TableEntity gebruikt, wat betekent dat de listEntities methode een PagedIterable<TableEntity> verzameling retourneert als de resultaten.
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 observatie 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 hiervoor een klasse WeatherDataModel in de map Modellen . Deze klasse heeft eigenschappen voor de stationnaam en observatiedatum waarnaar de partitiesleutel en rijsleutel worden toegewezen, wat zinvollere eigenschapsnamen voor deze waarden biedt. 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 alle objecten 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 PartitionKey, RowKey, en TimestampEtag eigenschappen rechtstreeks toe en gebruikt vervolgens de properties.keySet methode om de andere eigenschappen in het TableEntity object te herhalen en deze 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 uit een tabel
Als u de rijen wilt filteren die worden geretourneerd uit een tabel, kunt u een OData-stijlfilterreeks doorgeven aan de methode ListEntities . Als u bijvoorbeeld alle weermetingen voor Chicago tussen middernacht 1 juli 2021 en middernacht van 2 juli 2021 (inclusief) wilt ophalen, 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 bekijken in de sectie Filtersysteemqueryoptie
In de voorbeeldtoepassing is het FilterResultsInputModel object ontworpen om filtercriteria vast te leggen die door de gebruiker worden geleverd.
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 'en'-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 voor 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 toe te voegen aan een tabel is met behulp van een TableEntity-object . In dit voorbeeld worden gegevens uit 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 en RowKey) eigenschappen 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 in 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));
}
Upsert-gegevens met behulp van een TableEntity-object
Als u probeert een rij in te voegen in een tabel met een combinatie van partitiesleutel/rijtoetsen 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 bestaat in de tabel, wordt de bestaande rij bijgewerkt met de upsertEntity-methode . Anders wordt de rij toegevoegd aan de tabel.
public void upsertEntity(WeatherInputModel model) {
tableClient.upsertEntity(WeatherDataUtils.createTableEntity(model));
}
Gegevens invoegen of upsert met variabele eigenschappen
Een van de voordelen van het gebruik van de Azure Cosmos DB Tables-API is dat als een object dat wordt geladen in een tabel nieuwe eigenschappen bevat, deze eigenschappen automatisch worden toegevoegd aan de tabel en de waarden die zijn opgeslagen in Azure Cosmos DB. U hoeft DDL-instructies niet uit te voeren, zoals ALTER TABLE kolommen toevoegen in een traditionele database.
Dit model biedt uw toepassing flexibiliteit bij het omgaan met gegevensbronnen die kunnen toevoegen of wijzigen welke gegevens in de loop van de tijd moeten worden vastgelegd of wanneer verschillende invoergegevens verschillende gegevens aan uw toepassing leveren. In de voorbeeldtoepassing kunnen we een weerstation simuleren dat niet alleen de basisweergegevens verzendt, maar ook enkele extra waarden. Wanneer een object met deze nieuwe eigenschappen voor het eerst in de tabel wordt opgeslagen, worden de bijbehorende eigenschappen (kolommen) automatisch toegevoegd aan de tabel.
In de voorbeeldtoepassing wordt de ExpandableWeatherObject klasse gebouwd rond een interne woordenlijst ter ondersteuning van een set eigenschappen in 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, indien van toepassing.
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 op het TableClient-object . Omdat een entiteit (rij) die is opgeslagen met behulp van de Tabellen-API willekeurige set eigenschappen kan bevatten, is het vaak handig om een bijwerkobject 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 in TableClient. Vervolgens wordt dat entiteitsobject bijgewerkt en worden updateEntity de updates opgeslagen in de database. Houd er rekening mee dat de methode updateEntity 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 wilt bijwerken, kunt u een waarde van etag de updateEntity methode doorgeven.
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 de rijsleutel van het object.
public void deleteEntity(WeatherInputModel model) {
tableClient.deleteEntity(model.getStationName(),
WeatherDataUtils.formatRowKey(model.getObservationDate(), model.getObservationTime()));
}
7 - Voer de code uit
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 bovenaan de toepassing om gegevens aan de tabel toe te voegen.
Als u de knop Invoegen met tabelentiteit selecteert, wordt een dialoogvenster geopend waarin u een nieuwe rij kunt invoegen of een nieuwe rij kunt invoegen met behulp van een TableEntity object.
Als u de knop Invoegen selecteert met behulp van uitvouwbare gegevens , wordt een dialoogvenster geopend waarmee u een object met aangepaste eigenschappen kunt invoegen, waarmee wordt gedemonstreerd hoe de Azure Cosmos DB Tables-API automatisch eigenschappen (kolommen) toevoegt aan de tabel 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 enkele 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 verwijderen die betrekking hebben op dit artikel uit uw Azure-account. U kunt dit doen door de resourcegroep te verwijderen.
U kunt een resourcegroep verwijderen met behulp van Azure Portal door het volgende te doen.
| Instructies | Schermafbeelding |
|---|---|
| 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 in de werkbalk boven aan de pagina van de resourcegroep. | 
|
Rechts van het scherm wordt een dialoogvenster weergegeven 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 query's uitvoeren op uw gegevens met behulp van de API voor Table.