Cvičení – vytvoření, čtení, aktualizace a odstranění dat NoSQL prostřednictvím kódu programu

10 min

Navázali jste připojení k Azure Cosmos DB. V této lekci vytvoříte dokumenty uživatele ve vaší kolekci WebCustomers. Poté je budete moci načíst podle ID, nahradit a odstranit.

Práce s dokumenty prostřednictvím kódu programu

Data se ve službě Azure Cosmos DB ukládají do dokumentů JSON. Dokumenty lze vytvářet, načítat, nahrazovat nebo odstraňovat na portálu nebo programově. Toto cvičení se zaměřuje na programové operace. Azure Cosmos DB poskytuje klientské sady SDK pro .NET, .NET Core, Javu, Node.js a Python, z nichž každá tyto operace podporuje. V tomto modulu k provádění operací CRUD (vytvoření, načtení, aktualizace a odstranění) s daty typu NoSQL uloženými v Azure Cosmos DB použijeme sadu Java SDK.

Hlavní operace pro dokumenty Azure Cosmos DB jsou součástí třídy CosmosAsyncContainer:

Upsert provede operaci vytvoření nebo nahrazení v závislosti na tom, jestli už příslušný dokument existuje.

Abyste mohli provádět libovolné z těchto operací, budete potřebovat pomocné třídy (třídy Java POJO), které představují objekty uložené v databázi. Protože pracujeme s databází uživatelů, budete potřebovat třídu User představující entity uživatelů. Tato třída bude ukládat primární data, jako je křestní jméno, příjmení a ID uživatele. (Toto ID je povinné, protože to je klíč oddílu, který umožňuje horizontální škálování.)

Každý uživatel má přidruženy určité předvolby dopravy a kupóny, takže budete potřebovat také datové typy ShippingPreference a CouponsUsed, které představují tyto entity. Každý uživatel může mít také určitou historii objednávek, která je potenciálně nevázaná, takže potřebujete samostatné entity OrderHistory s odpovídající třídou Java POJO.

Přejděte na src/main/java/com/azure/azure-cosmos-java-sql-app-mslearn a nahlédněte do složky datatypes. Uvidíte několik tříd POJO: User, ShippingPreference, OrderHistory a CouponsUsed. Poskytli jsme tedy POJO a jejich pomocné třídy pro všechny entity.

Dále vytvoříme několik entit a provedeme několik základních operací CRUD s kontejnerem Azure Cosmos DB a dokumenty, které obsahuje. Azure Cosmos DB můžete předat ObjectNode Jackson, který přímo specifikuje dokument JSON. Ale Azure Cosmos DB dokáže serializovat Java POJO na JSON, což je postup, který doporučujeme jako ten nejjednodušší.

Vytvoření dokumentů

Otevřete soubor User.java a prohlédněte si jeho obsah. Měla by vypadat přibližně takto:

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.List;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {

    /** Document ID (required by Azure Cosmos DB). */
    private String id;

    /** User ID. */
    private String userId;

    /** User last name. */
    private String lastName;

    /** User first name. */
    private String firstName;

    /** User email address. */
    private String email;

    /** User dividend setting. */
    private String dividend;

    /** User shipping preferences. */
    private ShippingPreference shippingPreference;

    /** User order history. */
    private List<OrderHistory> orderHistory;

    /** Coupons recorded by the user. */
    private List<CouponsUsed> coupons;
}

Všimněte si, že přístupové metody pro pole id, userId atd. jsou implicitní (nedefinované v kódu). Toto chování je možné, protože k jejich automatickému vytváření používáme anotaci @Data pro Project Lombok.

Anotace @NoArgsConstructor vygeneruje konstruktor bez argumentů, který nastaví výchozí hodnoty polí. Anotace @AllArgsConstructor vygeneruje konstruktor s úplnou sadou argumentů, který specifikuje hodnoty všech polí přímo.

Všimněte si, že User má vlastnost id. Všechny dokumenty Azure Cosmos DB vyžadují vlastnost id, proto všechna POJO, která hodláme serializovat na dokumenty JSON, musí obsahovat pole id.

Přidejte následující metodu CosmosApp.java:

/**
 * Take in list of Java POJOs, check if each exists, and if not insert it.
 * @param users List of User POJOs to insert.
 */
private static void createUserDocumentsIfNotExist(final List<User> users) {
    Flux.fromIterable(users).flatMap(user -> {
        try {
            container.readItem(user.getId(), new PartitionKey(user.getUserId()), User.class).block();
            logger.info("User {} already exists in the database", user.getId());
            return Mono.empty();
        } catch (Exception err) {
            logger.info("Creating User {}", user.getId());
            return container.createItem(user, new PartitionKey(user.getUserId()), new CosmosItemRequestOptions());
        }
    }).blockLast();
}

Pak se vraťte k metodě basicOperations a na konec této metody přidejte před volání client.close() následující kód.

User maxaxam = new User(
    "1",
    "maxaxam",
    "Axam",
    "Max",
    "maxaxam@contoso.com",
    "2.0",
    new ShippingPreference(
        1,
        "90 W 8th St",
        "",
        "New York",
        "NY",
        "10001",
        "USA"
    ),
    new ArrayList<OrderHistory>(Arrays.asList(
        new OrderHistory(
            "3",
            "1000",
            "08/17/2018",
            "52.49"
        )
    )),
    new ArrayList<CouponsUsed>(Arrays.asList(
        new CouponsUsed(
            "A7B89F"
        )
    ))
);

User nelapin = new User(
        "2",
        "nelapin",
        "Pindakova",
        "Nela",
        "nelapin@contoso.com",
        "8.50",
        new ShippingPreference(
            1,
            "505 NW 5th St",
            "",
            "New York",
            "NY",
            "10001",
            "USA"
        ),
        new ArrayList<OrderHistory>(Arrays.asList(
            new OrderHistory(
                "4",
                "1001",
                "08/17/2018",
                "105.89"
            )
        )),
        new ArrayList<CouponsUsed>(Arrays.asList(
            new CouponsUsed(
                "Fall 2018"
            )
        ))
);

createUserDocumentsIfNotExist(new ArrayList<User>(Arrays.asList(maxaxam, nelapin)));

Sestavte a spusťte program CosmosApp.java v integrovaném vývojovém prostředí, nebo ho spusťte v terminálu příkazem:
```
mvn clean package
mvn exec:java -Dexec.mainClass="com.azure.cosmos.examples.mslearnbasicapp.CosmosApp"
```
Terminál zobrazí výstup vždy, když aplikace vytvoří nový dokument uživatele.
```
INFO: Database and container validation complete
INFO: Creating User 1
INFO: Creating User 2
```
V protokolu se může zobrazit nějaký další text, například časová razítka.

Gratulujeme! V Azure Cosmos DB jste z aplikace v Javě vytvořili první data. Na chvíli se zastavme a vyhodnoťme, co jste udělali.

V basicOperations jsou tři nové akce:

Vytvoření instance maxaxam User.
Vytvoření instance nelapin User.
Volání createUserDocumentsIfNotExist, které maxaxam a nelapin předává v seznamu.

Volání createUserDocumentsIfNotExist vloží obě instance User jako položky/dokumenty do Azure Cosmos DB. Tím, že instance User předáváme v podobě seznamu, hodláme modelovat výkonnou metodu pro rychlé ingestování POJO do Azure Cosmos DB pomocí minimálních výpočetních prostředků. createUserDocumentsIfNotExist implementuje efektivní asynchronní vkládání seznamu POJO.

Předpokládejme, že naším cílem je maximalizovat počet žádostí za sekundu na vlákno. Pro porovnání, synchronní přístup k zápisu createUserDocumentsIfNotExist – na chvíli ignorujme kontrolu readItem – by byla iterace přes všechny instance User v users. Pro všechny User u, použijeme blokovací volání createItem:

container.createItem(u, new PartitionKey(u.getUserId()), new CosmosItemRequestOptions()).block(); // <= Note the .block() which loops until request response.

Tento synchronní styl implementuje intuitivní proces: vydání žádosti, čekání na odpověď a vydání další žádosti. createUserDocumentsIfNotExist ale tento přístup nevyužívá, protože blokovací volání budou během doby odpovědi na žádost v podstatě plýtvat cykly procesoru, což způsobí nízký počet žádostí za sekundu.

Tomuto problému s počtem žádostí za sekundu se můžete vyhnout vytvořením několika vláken, která budou paralelně volat žádosti o blokování. Několik vláken přinese zlepšení doby provádění. Pokud je ale vaším cílem ušetřit prostředky vlákna, jde pořád o plýtvání. Každé vlákno se během doby odpovědi na žádost cykluje ve smyčce, zatímco by mohlo provádět multitasking nebo něco jiného, a výsledkem je nízký počet žádostí za sekundu na vlákno.

Z tohoto důvodu a proto, abychom vám ukázali vkládání POJO Java efektivní z hlediska vláken, jsme místo toho poskytli asynchronní příklad vkládání dokumentů. Podpora asynchronnosti v sadě Azure Cosmos DB Java SDK verze 4 pochází z projektu Reactor, což je architektura aplikací Java, která poskytuje streamovaný programovací model deklarativního toku dat pro programování řízené asynchronními událostmi. createDocumentsIfNotExist implementuje asynchronní programování projektu Reactor.

V createUserDocumentsIfNotExist existuje Flux.fromIterable(users), což je metoda factory projektu Reactor. Vytvoří instanci Flux, jež je zdrojem asynchronních událostí. V tomto případě zahrnuje každá asynchronní „událost“ argument instance User. Instance Flux obsahuje dvě takové události, jednu pro maxaxam a jednu pro nelapin. Kód uvnitř .flatMap( ... ).blockLast(); definuje kanál sekvenčních operací, které mají být provedeny s událostmi, jež vydává Flux.

Jednou z těchto operací je createItem. Myšlenka je taková, že tento kanál je víceméně stejný jako synchronní implementace s tou výjimkou, že u volání createItem nedochází k blokování. Volání blockLast() se konkrétně přihlásí k odběru sestaveného kanálu, což způsobí, že Flux asynchronně vydá dvě události. Kanál uvnitř .flatMap( ... ).blockLast(); zpracuje každou z těchto událostí pseudoparalelním způsobem. Když je vydána jedna žádost a čeká se na odpověď, zpracovává projekt Reactor na pozadí jiné žádosti, což je kritický faktor při maximalizaci počtu žádostí za sekundu na vlákno.

Teď, když jsme pomocí projektu Reactor ukázali efektivní asynchronní žádosti databáze, pro jednoduchost se ve zbytku tohoto cvičení budou používat blokovací (synchronní) volání. Další informace o projektu Reactor najdete v příručce vzorů Reactor pro Azure Cosmos DB.

Čtení dokumentů

Pro čtení dokumentů z databáze přidejte následující metodu do CosmosApp.

/**
 * Take in a Java POJO argument, extract ID and partition key, and read the corresponding document from the container.
 * In this case the ID is the partition key.
 * @param user User POJO to pull ID and partition key from.
 */
private static CosmosItemResponse<User> readUserDocument(final User user) {
    CosmosItemResponse<User> userReadResponse = null;

    try {
        userReadResponse = container.readItem(user.getId(), new PartitionKey(user.getUserId()), User.class).block();
        logger.info("Read user {}", user.getId());
    } catch (CosmosException de) {
        logger.error("Failed to read user {}", user.getId(), de);
    }

    return userReadResponse;
}

Zkopírujte následující kód a vložte ho na konec metody basicOperations za kód pro vytvoření dokumentu:
```
readUserDocument(maxaxam);
```
Sestavte a spusťte program CosmosApp.java v integrovaném vývojovém prostředí, nebo ho spusťte v terminálu příkazem:
```
mvn clean package
mvn exec:java -Dexec.mainClass="com.azure.cosmos.examples.mslearnbasicapp.CosmosApp"
```
V terminálu se zobrazí následující výstup, kde „Read user 1“ (Byl načten uživatel 1) značí načtení dokumentu.
```
INFO: Database and container validation complete
INFO: User 1 already exists in the database
INFO: User 2 already exists in the database
INFO: Read user 1
```
V protokolu se také může zobrazit další text.

Nahrazení dokumentů

Azure Cosmos DB podporuje nahrazování dokumentů JSON. V tomto případě aktualizujeme záznam uživatele, aby se projevila změna příjmení.

Přidejte metodu replaceUserDocument za metodu readUserDocument v souboru CosmosApp.java.

/**
 * Take in a Java POJO argument, extract ID and partition key,
 * and replace the existing document with the same ID and partition key to match.
 * @param user User POJO representing the document update.
 */
private static void replaceUserDocument(final User user) {
    try {
        CosmosItemResponse<User> userReplaceResponse = container.replaceItem(user, user.getId(), new PartitionKey(user.getUserId())).block();
        logger.info("Replaced User {}", user.getId());
    } catch (CosmosException de) {
        logger.error("Failed to replace User {}", user.getUserId());
    }
}

Zkopírujte a vložte následující kód na konec basicOperations metody za kód čtení dokumentu.
```
maxaxam.setLastName("Suh");
replaceUserDocument(maxaxam);
```

Sestavte a spusťte program CosmosApp.java v integrovaném vývojovém prostředí, nebo ho spusťte v terminálu příkazem:

mvn clean package
mvn exec:java -Dexec.mainClass="com.azure.cosmos.examples.mslearnbasicapp.CosmosApp"

V terminálu se zobrazí následující výstup, kde „Replaced last name for Suh“ (Příjmení se nahradilo za Suh) značí nahrazení dokumentu.

INFO: Database and container validation complete
INFO: User 1 already exists in the database
INFO: User 2 already exists in the database
INFO: Read user 1
INFO: Replaced last name for Suh

Odstranění dokumentů

Zkopírujte metodu deleteUserDocument a vložte ji pod metodu replaceUserDocument.

/**
 * Take in a Java POJO argument, extract ID and partition key,
 * and delete the corresponding document.
 * @param user User POJO representing the document update.
 */
private static void deleteUserDocument(final User user) {
    try {
        container.deleteItem(user.getId(), new PartitionKey(user.getUserId())).block();
        logger.info("Deleted user {}", user.getId());
    } catch (CosmosException de) {
        logger.error("User {} could not be deleted.", user.getId());
    }
}

Zkopírujte následující kód a vložte ho na konec metody basicOperations.
```
deleteUserDocument(maxaxam);
```

Sestavte a spusťte program CosmosApp.java v integrovaném vývojovém prostředí, nebo ho spusťte v terminálu příkazem:

mvn clean package
mvn exec:java -Dexec.mainClass="com.azure.cosmos.examples.mslearnbasicapp.CosmosApp"

V terminálu se zobrazí následující výstup, kde „Deleted user 1“ (Odstranil se uživatel 1) značí odstranění dokumentu.

INFO: Database and container validation complete
INFO: User 1 already exists in the database
INFO: User 2 already exists in the database
INFO: Read User 1
INFO: Replaced last name for Suh
INFO: Deleted User 1

Práce s dokumenty prostřednictvím kódu programu

Data se ve službě Azure Cosmos DB ukládají do dokumentů JSON. Dokumenty lze vytvářet, načítat, nahrazovat nebo odstraňovat na portálu nebo programově. Toto cvičení se zaměřuje na programové operace. Všechny tyto operace jsou k dispozici v sadě Java SDK služby Azure Cosmos DB a jsou přístupné také prostřednictvím programovacího modelu Spring Data. V tomto modulu použijeme Spring Data Azure Cosmos DB k provádění operací CRUD (vytvoření, načtení, aktualizace a odstranění) s daty typu NoSQL uloženými v Azure Cosmos DB.

Hlavní operace pro dokumenty Spring Data Azure Cosmos DB jsou základními operacemi v programovacím modelu Spring Data:

save – zápis nebo aktualizace dokumentu v závislosti na tom, jestli dokument už existuje
view – čtení dokumentu
delete – odstranění dokumentu

Abyste mohli provádět libovolné z těchto operací, budete potřebovat pomocné třídy (třídy Java POJO), které představují objekty uložené v databázi. Protože pracujeme s databází online zákazníků, budete pro vyjádření entit uživatelů potřebovat použít třídu WebCustomer. Tato třída bude ukládat primární data, jako je křestní jméno, příjmení a ID uživatele. (Toto ID je povinné, protože to je klíč oddílu, který umožňuje horizontální škálování.)

Každý zákazník webu má přidruženy určité předvolby dopravy a kupóny, takže pro vyjádření těchto entit budete potřebovat také datové typy ShippingPreference a CouponsUsed. Každý zákazník webu může mít také určitou historii objednávek, která je potenciálně nevázaná, takže potřebujete samostatné entity OrderHistory s odpovídající třídou Java POJO.

Přejděte na src/main/java/com/azure/cosmos/examples/springexamples. Uvidíte třídu POJO WebCustomer. Teď se podívejte do složky common. Uvidíte několik tříd POJO: ShippingPreference, OrderHistory a CouponsUsed. Poskytli jsme tedy POJO a jejich pomocné třídy pro všechny entity.

Vytváření a aktualizace dokumentů

Otevřete soubor WebCustomer.java a prohlédněte si jeho obsah. Měla by vypadat přibližně takto:

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
package com.azure.cosmos.examples.springexamples;

import com.azure.cosmos.examples.springexamples.common.CouponsUsed;
import com.azure.cosmos.examples.springexamples.common.OrderHistory;
import com.azure.cosmos.examples.springexamples.common.ShippingPreference;
import com.azure.spring.data.cosmos.core.mapping.Container;
import com.azure.spring.data.cosmos.core.mapping.PartitionKey;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.List;

@Data
@NoArgsConstructor
@AllArgsConstructor
@Container(containerName = "WebCustomer", ru = "400")
public class WebCustomer {

    /** Document ID (required by Azure Cosmos DB). */
    private String id;

    /** WebCustomer ID. */
    private String userId;

    /** WebCustomer last name. */
    @PartitionKey
    private String lastName;

    /** WebCustomer first name. */
    private String firstName;

    /** WebCustomer email address. */
    private String email;

    /** WebCustomer dividend setting. */
    private String dividend;

    /** WebCustomer shipping preferences. */
    private ShippingPreference shippingPreference;

    /** WebCustomer order history. */
    private List<OrderHistory> orderHistory;

    /** Coupons recorded by the user. */
    private List<CouponsUsed> coupons;
}

Všimněte si, že WebCustomer má vlastnost id. Všechny dokumenty Azure Cosmos DB vyžadují vlastnost id, proto všechna POJO, která hodláme serializovat na dokumenty JSON, musí obsahovat pole id.

Do souboru CosmosSample.java přidejte následující metodu:

/**
 * Take in list of Java POJOs and insert them into the database.
 * @param webCustomers List of WebCustomer POJOs to insert.
 */
private void createWebCustomerDocumentsIfNotExist(final List<WebCustomer> webCustomers) {
    Flux.fromIterable(webCustomers).flatMap(webCustomer -> {
        logger.info("Creating WebCustomer {}", webCustomer.getId());
        return this.reactiveWebCustomerRepository.save(webCustomer);
    }).blockLast();
}

Najděte metodu run a na konec této metody přidejte následující kód.

WebCustomer maxaxam = new WebCustomer(
        "1",
        "maxaxam",
        "Axam",
        "Max",
        "maxaxam@contoso.com",
        "2.0",
        new ShippingPreference(
                1,
                "90 W 8th St",
                "",
                "New York",
                "NY",
                "10001",
                "USA"
        ),
        new ArrayList<OrderHistory>(Arrays.asList(
                new OrderHistory(
                        "3",
                        "1000",
                        "08/17/2018",
                        "52.49"
                )
        )),
        new ArrayList<CouponsUsed>(Arrays.asList(
                new CouponsUsed(
                        "A7B89F"
                )
        ))
);

WebCustomer nelapin = new WebCustomer(
        "2",
        "nelapin",
        "Pindakova",
        "Nela",
        "nelapin@contoso.com",
        "8.50",
        new ShippingPreference(
                1,
                "505 NW 5th St",
                "",
                "New York",
                "NY",
                "10001",
                "USA"
        ),
        new ArrayList<OrderHistory>(Arrays.asList(
                new OrderHistory(
                        "4",
                        "1001",
                        "08/17/2018",
                        "105.89"
                )
        )),
        new ArrayList<CouponsUsed>(Arrays.asList(
                new CouponsUsed(
                        "Fall 2018"
                )
        ))
);

createWebCustomerDocumentsIfNotExist(new ArrayList(Arrays.asList(maxaxam, nelapin)));

Sestavte a spusťte CosmosSample.java v integrovaném vývojovém prostředí, nebo program spusťte v terminálu těmito příkazy:
```
mvn clean package
mvn spring-boot:run
```
Ve výstupu terminálu byste měli vidět
```
INFO: Creating WebCustomer 1
INFO: Creating WebCustomer 2
```

Gratulujeme! V Azure Cosmos DB jste z aplikace Java vytvořili a/nebo aktualizovali první data. Na chvíli se zastavme a vyhodnoťme, co jste udělali.

V run jsou tři nové akce:

Vytvoření/aktualizace instance WebCustomer maxaxam.
Vytvoření/aktualizace instance WebCustomer nelapin.
Volání createWebCustomerDocumentsIfNotExist, které maxaxam a nelapin předává v seznamu.

Volání createWebCustomerDocumentsIfNotExist vloží obě instance WebCustomer jako položky/dokumenty do Azure Cosmos DB. Tím, že instance WebCustomer předáváme v podobě seznamu, hodláme modelovat výkonnou metodu pro rychlé ingestování POJO do Azure Cosmos DB pomocí minimálních výpočetních prostředků. createWebCustomerDocumentsIfNotExist implementuje efektivní asynchronní vkládání seznamu POJO. Pokud už některý soubor existuje, provede save aktualizaci místo vytvoření dokumentu.

Předpokládejme, že naším cílem je maximalizovat počet žádostí za sekundu na vlákno. Pro porovnání, synchronní přístup k zápisu createWebCustomerDocumentsIfNotExist by byla iterace přes všechny instance WebCustomer v webCustomers. Pro všechny WebCustomer webCustomer, použijeme blokovací volání save:

this.reactiveWebCustomerRepository.save(webCustomer).block(); // <= Note the .block() which loops until request response.

Tento synchronní styl implementuje intuitivní proces: vydání žádosti, čekání na odpověď a vydání další žádosti. createWebCustomerDocumentsIfNotExist ale tento přístup nevyužívá, protože blokovací volání budou během doby odpovědi na žádost v podstatě plýtvat cykly procesoru, což způsobí nízký počet žádostí za sekundu.

Z tohoto důvodu a proto, abychom vám ukázali vkládání POJO Java efektivní z hlediska vláken, jsme místo toho poskytli asynchronní příklad vkládání dokumentů. Podpora asynchronnosti v modelu Spring Data pochází z projektu Reactor, což je architektura aplikací Java, která poskytuje streamovaný programovací model deklarativního toku dat pro programování řízené asynchronními událostmi. createWebCustomerDocumentsIfNotExist implementuje asynchronní programování projektu Reactor.

V createWebCustomerDocumentsIfNotExist existuje Flux.fromIterable(webCustomers), což je metoda factory projektu Reactor. Vytvoří instanci Flux, jež je zdrojem asynchronních událostí. V tomto případě zahrnuje každá asynchronní „událost“ argument instance WebCustomer. Instance Flux obsahuje dvě takové události, jednu pro maxaxam a jednu pro nelapin. Kód uvnitř .flatMap( ... ).blockLast(); definuje kanál sekvenčních operací, které mají být provedeny s událostmi, jež vydává Flux.

V tomto případě jsou těmito dvěma operacemi v kanálu volání save. Myšlenka je taková, že tento kanál je víceméně stejný jako synchronní implementace s tou výjimkou, že u volání save nedochází k blokování. Volání blockLast() se konkrétně přihlásí k odběru sestaveného kanálu, což způsobí, že Flux asynchronně vydá dvě události. Kanál uvnitř .flatMap( ... ).blockLast(); zpracuje každou z těchto událostí pseudoparalelním způsobem. Když je vydána jedna žádost a čeká se na odpověď, zpracovává projekt Reactor na pozadí jiné žádosti, což je kritický faktor při maximalizaci počtu žádostí za sekundu na vlákno.

Teď, když jsme pomocí projektu Reactor ukázali efektivní asynchronní žádosti databáze, pro jednoduchost se ve zbytku tohoto cvičení budou používat blokovací asynchronní volání (ve skutečnosti synchronní volání). Další informace o projektu Reactor najdete v příručce vzorů Reactor pro Azure Cosmos DB.

Čtení dokumentů

Pro čtení dokumentů z databáze přidejte následující metodu do CosmosSample.

/**
 * Take in a Java POJO argument, extract ID and partition key, and read the corresponding document from the container.
 * In this case the ID is the partition key.
 * @param webCustomer User POJO to pull ID and partition key from.
 */
private WebCustomer readWebCustomerDocument(final WebCustomer webCustomer) {
    WebCustomer webCustomerResult = null;

    try {
        logger.info("Read webCustomer {}", webCustomer.getId());
        webCustomerResult = this.reactiveWebCustomerRepository.findById(webCustomer.getId(), new PartitionKey(webCustomer.getLastName())).block();
    } catch (CosmosException de) {
        logger.error("Failed to read webCustomer {}", webCustomer.getId(), de);
    }

    return webCustomer;
}

Zkopírujte následující kód a vložte ho na konec metody run za kód pro vytvoření dokumentu:
```
readWebCustomerDocument(maxaxam);
```
Sestavte a spusťte CosmosSample.java v integrovaném vývojovém prostředí, nebo program spusťte v terminálu těmito příkazy:
```
mvn clean package
mvn spring-boot:run
```
Ve výstupu terminálu byste měli vidět následující řádky. „Read user 1“ označuje, že dokument byl načten.
```
INFO: Read webCustomer 1
```

Odstranění dokumentů

Zkopírujte metodu deleteWebCustomerDocument a vložte ji pod metodu readWebCustomerDocument.

/**
 * Take in a Java POJO argument, extract ID and partition key,
 * and delete the corresponding document.
 * @param webCustomer User POJO representing the document update.
 */
private void deleteWebCustomerDocument(final WebCustomer webCustomer) {
    try {
        this.reactiveWebCustomerRepository.deleteById(webCustomer.getId(),new PartitionKey(webCustomer.getLastName())).block();
        logger.info("Deleted webCustomer {}", webCustomer.getId());
    } catch (CosmosException de) {
        logger.error("User {} could not be deleted.", webCustomer.getId());
    }
}

Zkopírujte následující kód a vložte ho na konec metody run.
```
deleteWebCustomerDocument(maxaxam);
```
Sestavte a spusťte CosmosSample.java v integrovaném vývojovém prostředí, nebo program spusťte v terminálu těmito příkazy:
```
mvn clean package
mvn spring-boot:run
```
Ve výstupu terminálu byste měli vidět následující řádky. „Deleted user 1“ označuje, že dokument byl odstraněn.
```
INFO: Deleted webCustomer 1
```

V této lekci jste vytvořili, aktualizovali, přečetli a odstranili dokumenty v databázi Azure Cosmos DB.

Cvičení – vytvoření, čtení, aktualizace a odstranění dat NoSQL prostřednictvím kódu programu

Práce s dokumenty prostřednictvím kódu programu

Vytvoření dokumentů

Čtení dokumentů

Nahrazení dokumentů

Odstranění dokumentů

Práce s dokumenty prostřednictvím kódu programu

Vytváření a aktualizace dokumentů

Čtení dokumentů

Odstranění dokumentů

Váš názor