練習 - 以程式設計方式建立、讀取、更新及刪除 NoSQL 資料

  • 10 分鐘

您已建立與 Azure Cosmos DB 的連線。 在本單元中，您將在您的 WebCustomers 集合中建立使用者文件。 然後，您將依識別碼擷取這些文件、加以取代，然後加以刪除。

以程式設計方式使用文件

資料會儲存在 Azure Cosmos DB 的 JSON 文件中。 可在入口網站中或以程式設計方式來建立、擷取、取代或刪除文件。 此實驗室專注於程式設計作業。 Azure Cosmos DB 提供了適用於 .NET、.NET Core、Java, Node.js 及 Python 的用戶端 SDK，均可支援這類操作。 在本課程模組中，我們將使用 Java SDK 來對儲存在 Azure Cosmos DB 中的 NoSQL 資料執行 CRUD (Create (建立)、Retrieve (擷取)、Update (更新) 及 Delete (刪除)) 作業。

Azure Cosmos DB 文件的主要作業是 DocumentClient 類別的一部分：

Upsert 會視文件是否已存在，執行建立或取代作業。

若要執行上述任何一個作業，您將需要協助程式類別 (Java POJO 類別) 來代表儲存在資料庫中的物件。 因為我們處理的是使用者資料庫，您應該要有代表使用者實體的 User 類別。 此類別將會儲存主要資料，例如其名字、姓氏與使用者識別碼。 (需要識別碼的原因，是因為其為進行水平調整所需的分割區索引鍵。)

每個使用者都會有一些相關聯的運送喜好和優待券，因此您應該讓 ShippingPreference 與 CouponsUsed 資料類型來代表那些實體。 最後，每個使用者都可能會有一些潛在未繫結的訂購記錄，因此您應該要有具有相對應 Java POJO 類別的個別 OrderHistory 實體。

請移至 src/main/java/com/azure/azure-cosmos-java-sql-app-mslearn，並查看 [datatypes] 資料夾。 您將會看到數個 POJO：User、ShippingPreference、OrderHistory 與 CouponsUsed。 這代表我們已提供所有實體 POJO 與其協助程式類別！

接下來，我們將建立一些實體，並在 Azure Cosmos DB 容器與其包含的文件上執行一些基本的 CRUD 作業。 您可以向 Azure Cosmos DB 傳遞直接指定 JSON 文件的 Jackson ObjectNode 執行個體。 但是 Azure Cosmos DB 也能夠將 Java POJO 序列化為 JSON，而我們建議使用此方法，因為其為最簡單的選項 (在其他條件不變的情況下)。

建立文件

  1. 開啟 User.java 並檢查其內容。 其外觀應該如下所示：

    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;
}

    觀察到 id、userId，以及其他欄位的存取機制皆為「隱含的」(未在程式碼中定義)。 此行為之所以可能，是因為我們使用 Project Lombok @Data 註釋來自動加以建立。

    @NoArgsConstructor 註釋將會產生不具引數的建構函式，其能設定預設的欄位值。 @AllArgsConstructor 註釋將會產生具有完整引數集的另一個建構函式，以直接指定所有欄位值。

    請注意，User 具有 id 屬性。 所有 Azure Cosmos DB 文件都需要 id 屬性，因此我們想要序列化為 JSON 文件的所有 POJO 都必須具有 id 欄位。

  2. 將下列方法新增至 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();
}

  3. 返回 basicOperations 方法，並在該方法的 client.close() 呼叫「之前」，將下列內容新增至該方法的結尾。

    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)));

  4. 在 IDE 中建置並執行 CosmosApp.java，或是使用下列指令碼在終端機中執行該程式：

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

    終端機會在應用程式建立每個新的使用者文件時顯示輸出。

    INFO: Database and container validation complete
INFO: Creating User 1
INFO: Creating User 2

    您可能會看到由記錄器發出的一些額外文字，例如時間戳記。

恭喜！ 您已從 Java 應用程式在 Azure Cosmos DB 中建立您的第一筆資料。 讓我們暫停並評估您在此進行的動作。

在 basicOperations 中，有三個新的動作：

  1. 建立 maxaxam User 執行個體。
  2. 建立 nelapin User 執行個體。
  3. 呼叫 createUserDocumentsIfNotExist，在清單中傳遞 maxaxam 與 nelapin。

在 Azure Cosmos DB 中，呼叫 createUserDocumentsIfNotExist 會將 User 執行個體插入作為項目/文件。 在將 User 執行個體作為清單傳遞時，我們想要使用最少的計算資源來將效能方法模型化以快速將 POJO 內嵌至 Azure Cosmos DB。 createUserDocumentsIfNotExist 會實作有效率的 POJO 清單非同步處理插入。

假設目標為最大化每個執行緒每秒的要求數。 作為比較，寫入 createUserDocumentsIfNotExist 的同步方法 (讓我們暫時忽略 readItem 檢查) 將會是逐一查看 users 中的每一個 User 執行個體。 針對每個 User u，我們會針對 createItem 做出「封鎖」呼叫：

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

此同步樣式會實作直覺的程序：「發出要求」，「等候回應」，「發出下一個要求」。 然而，createUserDocumentsIfNotExist 並不會使用此方法，因為封鎖呼叫基本上會在要求回應時間期間浪費 CPU 週期，因而導致較低的每秒要求數。

您可能可以透過繁衍多個執行緒來進行平行封鎖要求呼叫，以因應這個每秒要求數問題。 多個執行緒將能帶來執行時間上的改善。 但如果您的目標是節省執行緒資源，此作法仍然會造成浪費。 與其讓執行緒針對其他作業進行多工，每個執行緒都會在要求回應時間期間重複，導致每個執行緒都具有較低的每秒要求數。

針對這個理由，以及為了示範 Java POJO 執行緒有效率插入的目的，我們改為提供文件插入的非同步範例。 Azure Cosmos DB Java SDK v4 非同步支援是來自 Project Reactor，這個 Java 應用程式架構可針對非同步處理事件驅動的程式設計，提供以串流為基礎的「宣告式資料流程」程式設計模型。 createDocumentsIfNotExist 會實作 Project Reactor 非同步程式設計。

在 createUserDocumentsIfNotExist 中，Flux.fromIterable(users) 為 Project Reactor Factory 方法。 其會建立做為非同步事件來源的 Flux 執行個體。 在此情況下，每個非同步「事件」都會包含 User 執行個體引數。 Flux 執行個體包含兩個這種事件，一個適用於 maxaxam，另一個則適用於 nelapin。 .flatMap( ... ).blockLast(); 內的程式碼會定義循序作業的「管線」，其會針對由 Flux 執行個體所發出的事件執行。

其中一個作業是 createItem。 其概念是讓此管線與同步實作近乎相同，不同之處在於我們不會針對 createItem 呼叫進行封鎖。 具體而言，對 blockLast() 的呼叫會「訂閱」組合的管線，導致 Flux「非同步地」發出其兩個事件。 接著，.flatMap( ... ).blockLast(); 內的管線會以虛擬平行的方式處理那些事件。 當發出一個要求並等待回應時，Project Reactor 會在背景處理其他要求，這是將每個執行緒每秒要求數最大化的關鍵因素。

現在我們已經使用 Project Reactor 示範有效率的非同步資料庫要求，基於簡化目的，此實驗室的其餘部分將會使用封鎖 (同步) 呼叫。 若要深入了解 Project Reactor，請參閱 Azure Cosmos DB Reactor 模式指南。

讀取文件

  1. 若要從資料庫讀取文件，請將下列方法新增至 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;
}

  2. 請在文件建立程式碼之後，將下列程式碼複製並貼到 basicOperations 方法的結尾：

    readUserDocument(maxaxam);

  3. 在 IDE 中建置並執行 CosmosApp.java，或是使用下列指令碼在終端機中執行該程式：

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

    終端機會顯示下列輸出，其中 "Read user 1" 表示已擷取文件。

    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

    您也可能會看到由記錄器發出的一些額外文字。

取代文件

Azure Cosmos DB 支援取代 JSON 文件。 在此情況下，我們要更新使用者記錄來變更其姓氏。

  1. 在 CosmosApp.java 檔案中的 readUserDocument 方法之後新增 replaceUserDocument 方法。

    /**
 * 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());
    }
}

  2. 將下列程式碼複製並貼上 basicOperations 方法的結尾，在文件讀取程式碼之後。

    maxaxam.setLastName("Suh");
replaceUserDocument(maxaxam);

  3. 在 IDE 中建置並執行 CosmosApp.java，或是使用下列指令碼在終端機中執行該程式：

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

    終端機會顯示下列輸出，其中 "Replaced last name for Suh" 表示已取代文件。

    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

刪除文件

  1. 將 deleteUserDocument 方法複製並貼到您的 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());
    }
}

  2. 將下列程式碼複製並貼到 basicOperations 方法的結尾。

    deleteUserDocument(maxaxam);

  3. 在 IDE 中建置並執行 CosmosApp.java，或是使用下列指令碼在終端機中執行該程式：

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

    終端機會顯示下列輸出，其中 "Deleted user 1" 表示已刪除文件。

    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

以程式設計方式使用文件

資料會儲存在 Azure Cosmos DB 的 JSON 文件中。 可在入口網站中或以程式設計方式來建立、擷取、取代或刪除文件。 此實驗室專注於程式設計作業。 所有這些作業都會在 Azure Cosmos DB Java SDK 中提供，而且也可以透過 Spring Data 程式設計模型存取。 在本課程模組中，我們將使用 Spring Data Azure Cosmos DB 來對儲存在 Azure Cosmos DB 中的 NoSQL 資料執行 CRUD (Create (建立)、Retrieve (擷取)、Update (更新) 及 Delete (刪除)) 作業。

Spring Data Azure Cosmos DB 文件的主要作業是 Spring Data 程式設計模型中的基本作業：

  • save - 根據文件是否已經存在，對文件進行點寫入或更新。
  • view - 對文件進行點讀取
  • delete - 對文件進行點刪除

若要執行上述任何一個作業，您將需要協助程式類別 (Java POJO 類別) 來代表儲存在資料庫中的物件。 因為我們處理的是線上客戶的資料庫，建議您使用 WebCustomer 類別來代表使用者實體。 此類別將會儲存主要資料，例如其名字、姓氏與使用者識別碼。 (需要識別碼的原因，是因為其為進行水平調整所需的分割區索引鍵。)

每個 Web 客戶都會有一些相關聯的運送喜好與優待券，因此建議您使用 ShippingPreference 與 CouponsUsed 資料類型來代表那些實體。 最後，每個 Web 客戶都可能會有一些潛在未繫結的訂購記錄，因此建議您使用具有相對應 Java POJO 類別的個別 OrderHistory 實體。

移至 src/main/java/com/azure/cosmos/examples/springexamples。 您將會看見 WebCustomer POJO。 現在請查看 [common] 資料夾。 您將會看到數個 POJO：ShippingPreference、OrderHistory 與 CouponsUsed。 這代表我們已提供所有實體 POJO 與其協助程式類別！

接下來，我們將建立一些實體，並在 Azure Cosmos DB 容器與其包含的文件上執行一些基本的 CRUD 作業。 您可以向 Azure Cosmos DB 傳遞直接指定 JSON 文件的 Jackson ObjectNode 執行個體。 但是 Azure Cosmos DB 也能夠將 Java POJO 序列化為 JSON，而我們建議使用此方法，因為其為最簡單的選項 (在其他條件不變的情況下)。

建立及更新文件

  1. 開啟 WebCustomer.java 並檢查其內容。 其外觀應該如下所示：

    // 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;
}

    觀察到 id、userId，以及其他欄位的存取機制皆為「隱含的」(未在程式碼中定義)。 此行為之所以可能，是因為我們使用 Project Lombok @Data 註釋來自動加以建立。

    @NoArgsConstructor 註釋將會產生不具引數的建構函式，其能設定預設的欄位值。 @AllArgsConstructor 註釋將會產生具有完整引數集的另一個建構函式，以直接指定所有欄位值。

    請注意，WebCustomer 具有 id 屬性。 所有 Azure Cosmos DB 文件都需要 id 屬性，因此我們想要序列化為 JSON 文件的所有 POJO 都必須具有 id 欄位。

  2. 將下列方法新增至 CosmosSample.java：

    /**
 * 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();
}

  3. 尋找 run 方法，並將下列程式碼新增至該方法的結尾。

    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)));

  4. 在 IDE 中建置並執行 CosmosSample.java，或是使用下列指令碼在終端中執行該程式：

    mvn clean package
mvn spring-boot:run

    在終端輸出中，您應該會看見

    INFO: Creating WebCustomer 1
INFO: Creating WebCustomer 2

恭喜！ 您已從 Java 應用程式在 Azure Cosmos DB 中建立和/或更新您的第一筆資料。 讓我們暫停並評估您在此進行的動作。

在 run 中，有三個新的動作：

  1. 建立/更新 maxaxam WebCustomer 執行個體。
  2. 建立/更新 nelapin WebCustomer 執行個體。
  3. 呼叫 createWebCustomerDocumentsIfNotExist，在清單中傳遞 maxaxam 與 nelapin。

在 Azure Cosmos DB 中，呼叫 createWebCustomerDocumentsIfNotExist 會將 WebCustomer 執行個體插入作為項目/文件。 在將 WebCustomer 執行個體作為清單傳遞時，我們想要使用最少的計算資源來將效能方法模型化以快速將 POJO 內嵌至 Azure Cosmos DB。 createWebCustomerDocumentsIfNotExist 會實作有效率的 POJO 清單非同步處理插入。 如果其中任何一份文件已經存在，save 將會完成更新而非建立文件。

假設目標為最大化每個執行緒每秒的要求數。 作為比較，寫入 createWebCustomerDocumentsIfNotExist 的同步方法將會是逐一查看 webCustomers 中的每一個 WebCustomer 執行個體。 針對每個 WebCustomer webCustomer，我們會針對 save 做出「封鎖」呼叫：

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

此同步樣式會實作直覺的程序：「發出要求」，「等候回應」，「發出下一個要求」。 然而，createWebCustomerDocumentsIfNotExist 並不會使用此方法，因為封鎖呼叫基本上會在要求回應時間期間浪費 CPU 週期，因而導致較低的每秒要求數。

您可能可以透過繁衍多個執行緒來進行平行封鎖要求呼叫，以因應這個每秒要求數問題。 多個執行緒將能帶來執行時間上的改善。 但如果您的目標是節省執行緒資源，此作法仍然會造成浪費。 與其讓執行緒針對其他作業進行多工，每個執行緒都會在要求回應時間期間重複，導致每個執行緒都具有較低的每秒要求數。

針對這個理由，以及為了示範 Java POJO 執行緒有效率插入的目的，我們改為提供文件插入的非同步範例。 Spring Data 非同步支援是來自 Project Reactor，這個 Java 應用程式架構可針對非同步處理事件驅動的程式設計，提供以串流為基礎的「宣告式資料流程」程式設計模型。 createWebCustomerDocumentsIfNotExist 會實作 Project Reactor 非同步程式設計。

在 createWebCustomerDocumentsIfNotExist 中，Flux.fromIterable(webCustomers) 為 Project Reactor Factory 方法。 其會建立做為非同步事件來源的 Flux 執行個體。 在此情況下，每個非同步「事件」都會包含 WebCustomer 執行個體引數。 Flux 執行個體包含兩個這種事件，一個適用於 maxaxam，另一個則適用於 nelapin。 .flatMap( ... ).blockLast(); 內的程式碼會定義循序作業的「管線」，其會針對由 Flux 執行個體所發出的事件執行。

在此情況下，管線中的兩個作業都是 save 呼叫。 其概念是讓此管線與同步實作近乎相同，不同之處在於我們不會針對 save 呼叫進行封鎖。 具體而言，對 blockLast() 的呼叫會「訂閱」組合的管線，導致 Flux「非同步地」發出其兩個事件。 接著，.flatMap( ... ).blockLast(); 內的管線會以虛擬平行的方式處理那些事件。 當發出一個要求並等待回應時，Project Reactor 會在背景處理其他要求，這是將每個執行緒每秒要求數最大化的關鍵因素。

我們已經使用 Project Reactor 示範有效率的非同步資料庫要求，基於簡化目的，此實驗室的其餘部分都會使用封鎖非同步呼叫 (基本上就是同步呼叫)。 若要深入了解 Project Reactor，請參閱 Azure Cosmos DB Reactor 模式指南。

讀取文件

  1. 若要從資料庫讀取文件，請將下列方法新增至 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;
}

  2. 請在文件建立程式碼之後，將下列程式碼複製並貼到 run 方法的結尾：

    readWebCustomerDocument(maxaxam);

  3. 在 IDE 中建置並執行 CosmosSample.java，或是使用下列指令碼在終端中執行該程式：

    mvn clean package
mvn spring-boot:run

    在終端輸出中，您應該會看見下列內容。 "Read user 1" (已讀取使用者 1) 指出已擷取文件。

    INFO: Read webCustomer 1

刪除文件

  1. 將 deleteWebCustomerDocument 方法複製並貼到您的 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());
    }
}

  2. 將下列程式碼複製並貼到 run 方法的結尾。

    deleteWebCustomerDocument(maxaxam);

  3. 在 IDE 中建置並執行 CosmosSample.java，或是使用下列指令碼在終端中執行該程式：

    mvn clean package
mvn spring-boot:run

    在終端輸出中，您應該會看見下列內容。 "Deleted user 1" (已刪除使用者 1) 指出已刪除文件。

    INFO: Deleted webCustomer 1

在本單元中，您已建立、更新、讀取及刪除您 Azure Cosmos DB 資料庫中的文件。