Rövid útmutató: API létrehozása Table-alkalmazáshoz Java SDK-val és Azure Cosmos DB-vel
A KÖVETKEZŐKRE VONATKOZIK:
Táblázat
Ez a rövid útmutató bemutatja, hogyan érheti el az Azure Cosmos DB Tables API-t egy Java-alkalmazásból. Az Azure Cosmos DB Tables API egy séma nélküli adattár, amellyel az alkalmazások strukturált NoSQL-adatokat tárolnak a felhőben. Mivel az adatok séma nélküli kialakításban vannak tárolva, a rendszer automatikusan új tulajdonságokat (oszlopokat) ad hozzá a táblához, amikor egy új attribútummal rendelkező objektumot ad hozzá a táblához.
A Java-alkalmazások az Azure Cosmos DB Tables API-t az azure-data-tables ügyfélkódtár használatával érhetik el.
Előfeltételek
A mintaalkalmazás a Spring Boot 2.6.4-ben, a Visual Studio Code-ot vagy az IntelliJ IDEA-t használhatja IDE-ként.
Ha nem rendelkezik Azure-előfizetéssel, a kezdés előtt hozzon létre egy ingyenes fiókot .
Mintaalkalmazás
Az oktatóanyaghoz tartozó mintaalkalmazás klónozható vagy letölthető az adattárból https://github.com/Azure-Samples/msdocs-azure-data-tables-sdk-java. A mintaadattárban egy kezdő és egy befejezett alkalmazás is szerepel.
git clone https://github.com/Azure-Samples/msdocs-azure-data-tables-sdk-java
A mintaalkalmazás az időjárási adatokat használja példaként a Tables API képességeinek szemléltetésére. Az időjárás-megfigyeléseket képviselő objektumok tárolása és lekérése a Table API használatával történik, beleértve az objektumok további tulajdonságokkal való tárolását a Tables API séma nélküli képességeinek szemléltetéséhez.
1 – Azure Cosmos DB-fiók létrehozása
Először létre kell hoznia egy Azure Cosmos DB Tables API-fiókot, amely tartalmazza az alkalmazásban használt táblá(ka)t. Ez a Azure Portal, az Azure CLI vagy Azure PowerShell használatával végezhető el.
Jelentkezzen be a Azure Portal, és kövesse az alábbi lépéseket egy Azure Cosmos DB-fiók létrehozásához.
| Utasítások | Képernyőfelvétel |
|---|---|
Az Azure Portalon:
|
|
| Az Azure Cosmos DB lapon válassza a +Létrehozás lehetőséget. | 
|
| Az API kiválasztása lapon válassza az Azure Table lehetőséget. | 
|
Az Azure Cosmos DB-fiók létrehozása – Azure Table lapon töltse ki az űrlapot az alábbiak szerint.
|
|
2 – Tábla létrehozása
Ezután létre kell hoznia egy táblát az Azure Cosmos DB-fiókban az alkalmazás használatához. A hagyományos adatbázisokkal ellentétben csak a tábla nevét kell megadnia, a táblában lévő tulajdonságokat (oszlopokat) nem. Az adatok a táblázatba való betöltésekor a tulajdonságok (oszlopok) szükség szerint automatikusan létrejönnek.
Az Azure Portal végezze el az alábbi lépéseket, hogy létrehozhasson egy táblát az Azure Cosmos DB-fiókban.
| Utasítások | Képernyőfelvétel |
|---|---|
| A Azure Portal lépjen az Azure Cosmos DB-fiók áttekintési oldalára. Az Azure Cosmos DB-fiók áttekintési lapjára úgy léphet, hogy beírja az Azure Cosmos DB-fiók nevét (cosmos-msdocs-tables-sdk-demo-XYZ) a felső keresősávba, és az erőforrások fejléce alá néz. Válassza ki az Azure Cosmos DB-fiók nevét az áttekintési lap megnyitásához. | 
|
| Az áttekintés lapon válassza a +Táblázat hozzáadása lehetőséget. Az Új táblázat párbeszédpanel a lap jobb oldaláról jelenik meg. | 
|
Az Új tábla párbeszédpanelen töltse ki az űrlapot az alábbiak szerint.
|
|
3 – Azure Cosmos DB-kapcsolati sztring lekérése
Ha az Azure Cosmos DB-ben szeretné elérni a táblá(ka)t, az alkalmazásnak szüksége lesz a CosmosDB Storage-fiókhoz kapcsolati sztring táblára. A kapcsolati sztring az Azure Portal, az Azure CLI vagy a Azure PowerShell használatával kérhetők le.
| Utasítások | Képernyőfelvétel |
|---|---|
| Az Azure Cosmos DB-fiók oldalának bal oldalán keresse meg a Kapcsolati sztring nevű menüelemet a Beállítások fejléc alatt, és válassza ki. A rendszer egy olyan oldalra kerül, ahol lekérheti a tárfiók kapcsolati sztring. | 
|
| Másolja ki az ELSŐDLEGES KAPCSOLATI SZTRING értéket az alkalmazásban való használathoz. | 
|
Az Azure Cosmos DB-fiókhoz tartozó kapcsolati sztring alkalmazás titkos alkalmazásnak minősül, és minden más alkalmazáskulcshoz vagy jelszóhoz hasonlóan védeni kell. Ez a példa a POM használatával tárolja a kapcsolati sztring a fejlesztés során, és elérhetővé teszi az alkalmazás számára.
<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 – Az azure-data-tables csomag belefoglalása
Ha egy Java-alkalmazásból szeretné elérni az Azure Cosmos DB Tables API-t, vegye fel az azure-data-tables csomagot.
<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-data-tables</artifactId>
<version>12.2.1</version>
</dependency>
5 – A Table-ügyfél konfigurálása a TableServiceConfig.java-ban
Az Azure SDK ügyfélobjektumok használatával kommunikál az Azure-ral különböző műveletek végrehajtásához az Azure-on. A TableClient objektum az Azure Cosmos DB Tables API-val való kommunikációhoz használt objektum.
Az alkalmazások általában egyetlen TableClient objektumot hoznak létre táblánként, amelyet az alkalmazás egészében használnak. Javasoljuk, hogy jelezze, hogy egy metódus létrehoz egy TableClient objektumbaant, amelyet a Spring-tároló kezel, és egyetlentonként, hogy ezt végrehajtsa.
TableServiceConfig.java Az alkalmazás fájljában szerkessze a metódusttableClientConfiguration(), hogy megfeleljen a következő kódrészletnek:
@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();
}
}
Az alábbi utasítást is hozzá kell adnia a TableServiceConfig.java fájl tetején.
import com.azure.data.tables.TableClient;
import com.azure.data.tables.TableClientBuilder;
6 – Azure Cosmos DB-táblaműveletek implementálása
A mintaalkalmazás összes Azure Cosmos DB-táblaművelete a TablesServiceImplServices könyvtárban található osztályban van implementálva. Importálnia kell az com.azure.data.tables SDK-csomagot.
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;
Az osztály elején TableServiceImpl adjon hozzá egy tagváltozót a TableClient objektumhoz és egy konstruktort, amely lehetővé teszi a TableClient objektum beszúrását az osztályba.
@Autowired
private TableClient tableClient;
Sorok lekérése táblázatból
A TableClient osztály tartalmaz egy listEntities nevű metódust , amellyel sorokat választhat ki a táblából. Ebben a példában, mivel nem adnak át paramétereket a metódusnak, az összes sor ki lesz választva a táblából.
A metódus egy TableEntity típusú általános paramétert is használ, amely megadja a modellosztály adatait. Ebben az esetben a TableEntity beépített osztályt használja a rendszer, ami azt jelenti, hogy a listEntities metódus egy gyűjteményt ad eredményül PagedIterable<TableEntity> .
public List<WeatherDataModel> retrieveAllEntities() {
List<WeatherDataModel> modelList = tableClient.listEntities().stream()
.map(WeatherDataUtils::mapTableEntityToWeatherDataModel)
.collect(Collectors.toList());
return Collections.unmodifiableList(WeatherDataUtils.filledValue(modelList));
}
A csomagban com.azure.data.tables.modelsdefiniált TableEntity osztály a partíciókulcs és a sorkulcs értékeinek tulajdonságait tartalmazza a táblában. Ez a két érték együttesen a tábla sorához tartozó egyedi kulcs értékét tartalmazza. Ebben a példában az időjárás-állomás (város) neve a partíciókulcsban, a megfigyelés dátuma/időpontja pedig a sorkulcsban van tárolva. Minden más tulajdonság (hőmérséklet, páratartalom, szélsebesség) az objektum szótárában TableEntity van tárolva.
A TableEntity objektumokat gyakran saját definíciós objektumhoz rendelik. A mintaalkalmazás erre a célra definiál egy osztályt WeatherDataModel a Models könyvtárban. Ez az osztály a partíciókulcs és a sorkulcs által leképezendő állomás nevének és megfigyelési dátumának tulajdonságaival rendelkezik, és értelmesebb tulajdonságneveket ad ezeknek az értékeknek. Ezután szótár használatával tárolja az objektum összes többi tulajdonságát. Ez egy gyakori minta a Table Storage használatakor, mivel egy sor tetszőleges számú tulajdonsággal rendelkezhet, és azt szeretnénk, hogy a modellobjektumok mindegyike rögzíthető legyen. Ez az osztály metódusokat is tartalmaz az osztály tulajdonságainak listázásához.
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;
}
}
A mapTableEntityToWeatherDataModel metódus egy TableEntity objektum objektumhoz való leképezésére WeatherDataModel szolgál. A mapTableEntityToWeatherDataModel metódus közvetlenül leképezi a PartitionKey, RowKey, Timestampés Etag tulajdonságokat, majd az properties.keySet használatával iterálja át az TableEntity objektum többi tulajdonságát, és megfelelteti azokat az WeatherDataModel objektumnak, levonva a már közvetlenül leképezett tulajdonságokat.
Szerkessze a metódus kódját, mapTableEntityToWeatherDataModel hogy megfeleljen az alábbi kódblokknak.
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));
}
});
}
Táblázatból visszaadott sorok szűrése
A táblákból visszaadott sorok szűréséhez átadhat egy OData-stílusú szűrősztringet a listEntities metódusnak. Ha például 2021. július 1. éjfél és 2021. július 2. éjfél között szeretné megkapni a Békéscsaba összes időjárási adatát (beleértve a 2021. július 2-án éjfélt), a következő szűrősztringet kell megadnia.
PartitionKey eq 'Chicago' and RowKey ge '2021-07-01 12:00 AM' and RowKey le '2021-07-02 12:00 AM'
Az OData webhely összes OData-szűrőoperátorát megtekintheti a Rendszerlekérdezés szűrése lehetőség című szakaszban.
A példaalkalmazásban az FilterResultsInputModel objektum úgy van kialakítva, hogy rögzítse a felhasználó által megadott szűrési feltételeket.
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;
}
}
Amikor ezt az objektumot átadja a retrieveEntitiesByFilterTableServiceImpl osztály metódusának, létrehoz egy szűrősztringet minden nem null tulajdonságértékhez. Ezután létrehoz egy kombinált szűrősztringet úgy, hogy az összes értéket egy "és" záradékkal összekapcsolja. Ez az egyesített szűrősztring a TableClient objektum listEntities metódusának lesz átadva, és csak a szűrősztringnek megfelelő sorok lesznek visszaadva. A kódban egy hasonló módszerrel megfelelő szűrősztringeket hozhat létre az alkalmazás által megkövetelt módon.
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));
}
Adatok beszúrása TableEntity objektummal
Az adatok táblázatba való felvételének legegyszerűbb módja egy TableEntity objektum használata. Ebben a példában az adatok egy bemeneti modell objektumából egy TableEntity objektumba lesznek leképezve. Az időjárási állomás nevét és a megfigyelési dátumot/időt ábrázoló bemeneti objektum tulajdonságai az és RowKeya PartitionKey tulajdonságra vannak leképezve, amelyek együttesen a tábla sorának egyedi kulcsát alkotják. Ezután a bemeneti modell objektum további tulajdonságai a TableClient objektum szótártulajdonságainak lesznek megfeleltetve. Végül a TableClient objektum createEntity metódusával adatokat szúrhat be a táblába.
Módosítsa a insertEntity példaalkalmazás osztályát úgy, hogy az tartalmazza a következő kódot.
public void insertEntity(WeatherInputModel model) {
tableClient.createEntity(WeatherDataUtils.createTableEntity(model));
}
Adatok mentése TableEntity objektum használatával
Ha olyan táblába próbál beszúrni egy sort, amelyben már létezik partíciókulcs/sorkulcs kombináció, hibaüzenet jelenik meg. Ezért gyakran előnyösebb az upsertEntity használata a metódus helyett, insertEntity amikor sorokat ad hozzá egy táblához. Ha a megadott partíciókulcs/sorkulcs kombináció már létezik a táblában, az upsertEntity metódus frissíti a meglévő sort. Ellenkező esetben a sor hozzá lesz adva a táblához.
public void upsertEntity(WeatherInputModel model) {
tableClient.upsertEntity(WeatherDataUtils.createTableEntity(model));
}
Adatok beszúrása vagy frissítése változó tulajdonságokkal
Az Azure Cosmos DB Tables API használatának egyik előnye, hogy ha egy táblába betöltött objektum bármilyen új tulajdonságot tartalmaz, akkor a rendszer automatikusan hozzáadja ezeket a tulajdonságokat a táblához és az Azure Cosmos DB-ben tárolt értékekhez. Nincs szükség DDL-utasítások futtatására, például ALTER TABLE oszlopok hozzáadására, mint egy hagyományos adatbázisban.
Ez a modell rugalmasságot biztosít az alkalmazásnak az olyan adatforrások kezelésekor, amelyek hozzáadhatják vagy módosíthatják, hogy milyen adatokat kell rögzíteni az idő múlásával, vagy amikor a különböző bemenetek eltérő adatokat biztosítanak az alkalmazásnak. A mintaalkalmazásban olyan időjárási állomást szimulálhatunk, amely nem csak az alap időjárási adatokat, hanem további értékeket is küld. Ha egy ilyen új tulajdonsággal rendelkező objektumot először tárol a táblában, a rendszer automatikusan hozzáadja a megfelelő tulajdonságokat (oszlopokat) a táblához.
A mintaalkalmazásban az ExpandableWeatherObject osztály egy belső szótár köré épül, amely támogatja az objektum bármely tulajdonságkészletét. Ez az osztály egy tipikus mintát jelöl arra az esetre, ha egy objektumnak tetszőleges tulajdonságkészletet kell tartalmaznia.
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();
}
}
Ha egy ilyen objektumot a Table API használatával szeretne beszúrni vagy bővíteni, a bővíthető objektum tulajdonságait egy TableEntity objektumba kell képeznie, és szükség szerint használja a TableClient objektum createEntity vagy upsertEntity metódusait.
public void insertExpandableEntity(ExpandableWeatherObject model) {
tableClient.createEntity(WeatherDataUtils.createTableEntity(model));
}
public void upsertExpandableEntity(ExpandableWeatherObject model) {
tableClient.upsertEntity(WeatherDataUtils.createTableEntity(model));
}
Entitás frissítése
Az entitások frissíthetők az updateEntity metódus meghívásával a TableClient objektumon. Mivel a Tables API használatával tárolt entitás (sor) tetszőleges tulajdonságkészletet tartalmazhat, gyakran hasznos, ha a korábban tárgyalthoz ExpandableWeatherObject hasonló szótárobjektumon alapuló frissítési objektumot hoz létre. Ebben az esetben az egyetlen különbség egy tulajdonság hozzáadása etag , amelyet az egyidejűség-vezérléshez használnak a frissítések során.
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;
}
}
A mintaalkalmazásban ezt az objektumot a osztály metódusa TableServiceImpl továbbítjaupdateEntity. Ez a metódus először betölti a meglévő entitást a TableClientgetEntity metódusával a Tables API-ból. Ezután frissíti az entitásobjektumot, és a metódussal updateEntity menti a frissítéseket az adatbázisba. Figyelje meg, hogy az updateEntity metódus hogyan veszi át az objektum aktuális Etagját annak biztosítása érdekében, hogy az objektum az eredeti betöltése óta ne változzon. Ha függetlenül szeretné frissíteni az entitást, a metódusnak átadhat egy értéket etagupdateEntity .
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);
}
Entitás eltávolítása
Ha el szeretne távolítani egy entitást egy táblából, hívja meg a DeleteEntity metódust a TableClient objektumon az objektum partíciókulcsával és sorkulcsával.
public void deleteEntity(WeatherInputModel model) {
tableClient.deleteEntity(model.getStationName(),
WeatherDataUtils.formatRowKey(model.getObservationDate(), model.getObservationTime()));
}
7 – A kód futtatása
Futtassa a mintaalkalmazást az Azure Cosmos DB Tables API használatához. Az alkalmazás első futtatásakor nem lesznek adatok, mert a tábla üres. Az alkalmazás tetején található gombok bármelyikével adatokat adhat hozzá a táblához.
A Beszúrás táblaentitás használatával gombra kattintva megnyílik egy párbeszédpanel, amellyel új sort szúrhat be vagy szúrhat be egy TableEntity objektummal.
Ha a Beszúrás bővíthető adatokkal gombot választja, megjelenik egy párbeszédpanel, amellyel egyéni tulajdonságokkal rendelkező objektumokat szúrhat be, és bemutatja, hogy az Azure Cosmos DB Tables API szükség esetén automatikusan hogyan ad hozzá tulajdonságokat (oszlopokat) a táblához. Az Egyéni mező hozzáadása gomb használatával adjon hozzá egy vagy több új tulajdonságot, és mutassa be ezt a képességet.
A Mintaadatok beszúrása gombbal betölthet néhány mintaadatot az Azure Cosmos DB-táblába.
Válassza ki a felső menü Eredmények szűrése elemét, és lépjen az Eredmények szűrése lapra. Ezen a lapon töltse ki a szűrési feltételeket, hogy bemutassa, hogyan hozható létre és adható át szűrő záradék az Azure Cosmos DB Tables API-nak.
Az erőforrások eltávolítása
Ha végzett a mintaalkalmazással, távolítsa el a cikkhez kapcsolódó összes Azure-erőforrást az Azure-fiókjából. Ezt az erőforráscsoport törlésével teheti meg.
Az erőforráscsoport az Azure Portal az alábbi lépésekkel törölhető.
| Utasítások | Képernyőfelvétel |
|---|---|
| Az erőforráscsoportra való ugráshoz írja be az erőforráscsoport nevét a keresősávba. Ezután az Erőforráscsoportok lapon válassza ki az erőforráscsoport nevét. | 
|
| Válassza az Erőforráscsoport törlése lehetőséget az erőforráscsoport lap tetején található eszköztáron. | 
|
A képernyő jobb oldalán megjelenik egy párbeszédpanel, amely arra kéri, hogy erősítse meg az erőforráscsoport törlését.
|
|
Következő lépések
Ebben a rövid útmutatóban bemutattuk, hogyan lehet Azure Cosmos DB-fiókot létrehozni, hogyan lehet az Adatkezelő segítségével táblát készíteni, és hogyan lehet futtatni az alkalmazást. Most már lekérdezheti az adatokat a Table API használatával.