Ćwiczenie — konfigurowanie aplikacji języka Java za pomocą programu Maven

15 min

W tej lekcji utworzysz prostą aplikację konsolową przy użyciu wybranego środowiska IDE do edytowania kodu. Możesz też uruchomić swój kod za pomocą wybranego terminalu.

Tworzenie zasobów usługi Azure Cosmos DB

W celu ukończenia tego laboratorium witryna Microsoft Learn udostępnia bezpłatną piaskownicę platformy Azure, w której można tworzyć konta i zasoby. W ramach tej subskrypcji skonfigurujesz konto usługi Azure Cosmos DB, a następnie utworzysz bazę danych i kontener.

Zaloguj się w witrynie Azure Portal przy użyciu tego samego konta, za pomocą którego aktywowano piaskownicę.
Przy użyciu witryny Azure Portal utwórz konto usługi Azure Cosmos DB o wybranej nazwie. Gdy nadejdzie okazja, aby wybrać grupę zasobów dla konta, znajdź grupę zasobów [Grupa zasobów piaskownicy] i wybierz ją.
Na koncie usługi Azure Cosmos DB utwórz bazę danych o nazwie Users.
W bazie danych Users utwórz kontener o nazwie WebCustomers z kluczem partycji /userId. Aprowizuj 400 RU/s przepływności na potrzeby kontenera WebCustomers.

Tworzenie katalogu roboczego

Udostępniamy szablon na potrzeby Twojej aplikacji języka Java. Sklonuj repozytorium szablonu do systemu.
```
git clone https://github.com/MicrosoftDocs/mslearn-cosmos-java-sql.git
```
Otwórz Eksplorator plików Windows i przejdź do sklonowanego repozytorium. Przejdź do podkatalogu java_lab.

Ważne

Cała praca w ramach tego modułu będzie wykonywana w podkatalogu java_lab.
Szablon zawiera plik pom.xml programu Maven, który już ściąga wymagane zależności na potrzeby projektu. Otwórz ten plik i znajdź w nim poniższą zależność:
```
<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-cosmos</artifactId>
    <version>LATEST</version>
</dependency>
```
Ta zależność ściąga najnowszą wersję zestawu Java SDK usługi Azure Cosmos DB. Możesz zamknąć ten plik.
Następnie utworzysz i uruchomisz program Hello world. Korzystając ze środowiska IDE lub terminalu, otwórz ten projekt. W zależności od środowiska IDE może pojawić się możliwość otwarcia pliku pom.xml w podkatalogu java jako projektu.

Po otwarciu projektu przejdź do strony src/main/java/com/azure/cosmos/examples/mslearnbasicapp i otwórz CosmosApp.java, która jest szablonem opracowywanej aplikacji Java. Powinna to wyglądać następująco:
```
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public final class CosmosApp {

    /** For application to log INFO and ERROR. */
    private static Logger logger = LoggerFactory.getLogger(CosmosApp.class.getSimpleName());

    private CosmosApp() {
        // not called
    }

    /**
    * Main.
    * @param args Command line arguments
    */
    public static void main(final String[] args) {
        logger.info("Hello World.");
    }
}
```
W obecnej postaci kod aplikacji implementuje prosty program „Hello world”.
Jeśli środowisko IDE oferuje narzędzia do kompilowania i uruchamiania aplikacji Maven: skompiluj i uruchom aplikację przy użyciu środowiska IDE i upewnij się, że aplikacja rejestruje się Hello World w terminalu.
Jeśli użyjesz terminalu do skompilowania i uruchomienia aplikacji Maven: użyj następującego polecenia, aby skompilować projekt Maven:
```
mvn clean package
```
Następnie uruchom polecenie:
```
mvn exec:java -Dexec.mainClass="com.azure.cosmos.examples.mslearnbasicapp.CosmosApp"  
```
Sprawdź, czy aplikacja wyświetla w terminalu następujący komunikat:
```
INFO: Hello World.
```

Łączenie aplikacji z usługą Azure Cosmos DB

W klasie CosmosApp utwórz następujące zmienne klasy statycznej na potrzeby szczegółów połączenia usługi Azure Cosmos DB:

/** Azure Cosmos DB endpoint URI. */
private static String endpointUri = "<your-cosmosdb-hostname>";

/** Azure Cosmos DB primary key. */
private static String primaryKey = "<your-cosmosdb-master-key>";

Wróć do witryny Azure Portal, przejdź do okienka Klucze i skopiuj, a następnie wklej identyfikator URI punktu końcowego usługi Azure Cosmos DB oraz klucz podstawowy do powyższych definicji zmiennych.

Na przykład jeśli identyfikator URI to https://cosmosacct.documents.azure.com:443/, nowe przypisanie zmiennej będzie wyglądać następująco: private static String endpointUri = "https://cosmosacct.documents.azure.com:443/";. Jeśli klucz podstawowy to elzirrKCnXlacvh1CRAnQdYVbVLspmYHQyYrhx0PltHi8wn5lHVHFnd1Xm3ad5cn4TUcH4U0MSeHsVykkFPHpQ==, nowe przypisanie zmiennej będzie wyglądać następująco: private static String primaryKey = "elzirrKCnXlacvh1CRAnQdYVbVLspmYHQyYrhx0PltHi8wn5lHVHFnd1Xm3ad5cn4TUcH4U0MSeHsVykkFPHpQ==";.

Tworzenie wystąpienia CosmosAsyncClient

Nadszedł czas na utworzenie wystąpienia klasy CosmosAsyncClient, czyli reprezentacji usługi Azure Cosmos DB po stronie klienta. Ten klient jest używany do konfigurowania i wykonywania żądań dotyczących usługi.

W pliku CosmosApp.java dodaj następującą deklarację zmiennej statycznej do klasy CosmosApp:
```
/** Azure Cosmos DB client instance. */
private static CosmosAsyncClient client;

/** Azure Cosmos DB database instance. */
private static CosmosAsyncDatabase database;

/** Azure Cosmos DB container instance. */
private static CosmosAsyncContainer container;
```
Najprawdopodobniej klasy client, database i container nie zostały jeszcze zaimportowane do pliku Java. Warto zrobić to teraz. Niektóre środowiska IDE umożliwiają automatyczne importowanie zależności w oparciu o wpisany kod. Taka funkcja może Ci się teraz przydać. Ogólnie rzecz biorąc, pamiętaj, że oprócz wklejenia podanych przez nas bloków kodu konieczne może dodanie pewnych instrukcji import, aby kod zadziałał.
Utwórz metodę private void o nazwie basicOperations bez argumentów w klasie.

Dodaj następujący kod, aby utworzyć wystąpienie klasy CosmosAsyncClient w metodzie basicOperations i dołącz kod sprawdzający, czy istnieje baza danych Users.

 client = new CosmosClientBuilder()
     .endpoint(endpointUri)
     .key(primaryKey)
     .consistencyLevel(ConsistencyLevel.EVENTUAL)
     .directMode()
     .contentResponseOnWriteEnabled(true)
     .buildAsyncClient();

 database = client.getDatabase("Users");
 container = database.getContainer("WebCustomers");            

 logger.info("Database and container validation complete");

 client.close();

W tym momencie metoda basicOperations zawiera kod służący do interakcji z usługą Azure Cosmos DB. Jednak ta metoda nie jest wywoływana w mainpliku , więc nasza aplikacja nadal służy do drukowania "Hello World". Aby sprawdzić, skompiluj i uruchom CosmosApp.java w środowisku IDE lub uruchom program w terminalu przy użyciu polecenia:
```
mvn clean package
mvn exec:java -Dexec.mainClass="com.azure.cosmos.examples.mslearnbasicapp.CosmosApp"  
```
Sprawdź, czy aplikacja nadal wyświetla w terminalu następujący komunikat:
```
INFO: Hello World.
```

Skopiuj i wklej następujący kod do main metody, zastępując bieżący logger.info("Hello World."); wiersz.

try {
    CosmosApp p = new CosmosApp();
    p.basicOperations();
} catch (CosmosException e) {
    logger.error("Failed while executing app.", e);
} finally {
    logger.info("End of demo, press any key to exit.");
}

Spowoduje to wyzwolenie kodu usługi Azure Cosmos DB w naszej aplikacji.

Skompiluj i uruchom plik CosmosApp.java w środowisku IDE lub uruchom program w terminalu przy użyciu polecenia:
```
mvn clean package
mvn exec:java -Dexec.mainClass="com.azure.cosmos.examples.mslearnbasicapp.CosmosApp"  
```
W terminalu może pojawić się duża liczba komunikatów dziennika, z których część jest generowana przez sam zestaw SDK. Zapoznaj się z nimi i upewnij się, że aplikacja wyświetla w terminalu ten komunikat:
```
INFO: Database and container validation complete
```

W tej lekcji skonfigurowano podstawy aplikacji języka Java usługi Azure Cosmos DB. Została skonfigurowana aplikacja Maven, utworzony podstawowy projekt „Hello world”, którego rozszerzono, aby połączyć ten projekt z punktem końcowym usługi Azure Cosmos DB.

Udostępniamy szablon na potrzeby Twojej aplikacji języka Java. Sklonuj repozytorium szablonu do systemu
```
git clone https://github.com/MicrosoftDocs/mslearn-cosmos-java-sql.git
```
Otwórz Eksploratora Windows i przejdź do sklonowanego repozytorium. Przejdź do podkatalogu spring_lab.

Ważne

Cała praca w ramach tego modułu będzie wykonywana w podkatalogu spring_lab.
Szablon zawiera plik pom.xml programu Maven, który już ściąga wymagane zależności na potrzeby projektu. Otwórz ten plik i zbadaj go, aby znaleźć poniższą zależność:
```
<dependency>
  <groupId>com.azure</groupId>
  <artifactId>azure-spring-data-cosmos</artifactId>
  <version>LATEST</version>
</dependency>
```
Ta zależność ściąga najnowszą wersję danych Spring Data usługi Azure Cosmos DB. Możesz zamknąć ten plik.

Łączenie aplikacji z usługą Azure Cosmos DB

Korzystając ze środowiska IDE lub terminalu, otwórz ten projekt. W zależności od środowiska IDE może pojawić się opcja otwarcia pliku pom.xml w podkatalogu spring jako projektu. Po otwarciu projektu przejdź do folderu src/main/resources/ przy użyciu narzędzia eksploratora plików. Powinien być widoczny plik o nazwie application.properties.rename. Projekt Spring Data koncentruje się na użyciu plików konfiguracji względem zakodowanych parametrów konfiguracji. Aby utworzyć plik konfiguracji dla projektu Spring Data, skopiuj plik application.properties.rename do application.properties i otwórz nowy plik application.properties. Powinien zostać wyświetlony następujący ekran
```
cosmos.uri=${ACCOUNT_HOST}
cosmos.key=${ACCOUNT_KEY}
cosmos.secondaryKey=${SECONDARY_ACCOUNT_KEY}

dynamic.collection.name=spel-property-collection
# Populate query metrics
cosmos.queryMetricsEnabled=true
```
Wypełnij elementy ${ACCOUNT_HOST} i ${ACCOUNT_KEY} przy użyciu wybranej metody — skopiuj i wklej wartości do pliku application.properties lub zdefiniuj te zmienne środowiskowe w środowisku IDE. W następnym kroku znajdziesz wartości, które powinny mieć te zmienne.
Wróć do witryny Azure Portal, przejdź do okienka Klucze i skopiuj klucz podstawowy oraz identyfikator URI punktu końcowego usługi Azure Cosmos DB. Zgodnie z opisem w poprzednim kroku użyj wybranej metody, aby przypisać identyfikator URI punktu końcowego usługi Azure Cosmos DB i klucz podstawowy do wymienionych wyżej zmiennych.

Jeśli identyfikator URI to https://cosmosacct.documents.azure.com:443/ i zdecydujesz się wkleić punkt końcowy i klucz podstawowy do pliku application.properties, wiersz w pliku application.properties będzie wyglądać następująco: cosmos.uri=https://cosmosacct.documents.azure.com:443/. Jeśli klucz podstawowy to elzirrKCnXlacvh1CRAnQdYVbVLspmYHQyYrhx0PltHi8wn5lHVHFnd1Xm3ad5cn4TUcH4U0MSeHsVykkFPHpQ==, wykonaj kroku tego samego procesu. Nowe przypisanie zmiennej będzie wyglądać następująco: cosmos.key=elzirrKCnXlacvh1CRAnQdYVbVLspmYHQyYrhx0PltHi8wn5lHVHFnd1Xm3ad5cn4TUcH4U0MSeHsVykkFPHpQ==.

Konfigurowanie klienta usługi Azure Cosmos DB

Dane Spring Data w usłudze Azure Cosmos DB automatycznie tworzą wystąpienia klienta usługi Azure Cosmos DB podczas uruchamiania. Klient usługi Azure Cosmos DB to reprezentacja usługi Azure Cosmos DB po stronie klienta używana do wykonywania żądań dotyczących usługi. Kod może skonfigurować klienta usługi Azure Cosmos DB przed utworzeniem jej wystąpienia, używając zestawu metod konstruktora z właściwościami pobranymi z pliku application.properties.

Otwórz plik CosmosProperties.java. Ten plik został dostarczony w gotowym formularzu, więc po prostu sprawdź jego zawartość.
```
@ConfigurationProperties(prefix = "cosmos")
public class CosmosProperties {

    private String uri;

    private String key;

    private String secondaryKey;

    private boolean queryMetricsEnabled;

    public String getUri() {
        return uri;
    }

    public void setUri(String uri) {
        this.uri = uri;
    }

    public String getKey() {
        return key;
    }

    public void setKey(String key) {
        this.key = key;
    }

    public String getSecondaryKey() {
        return secondaryKey;
    }

    public void setSecondaryKey(String secondaryKey) {
        this.secondaryKey = secondaryKey;
    }

    public boolean isQueryMetricsEnabled() {
        return queryMetricsEnabled;
    }

    public void setQueryMetricsEnabled(boolean enableQueryMetrics) {
        this.queryMetricsEnabled = enableQueryMetrics;
    }
}
```
Obserwuj elementy członkowskie klasy uri, key, secondaryKey queryMetricsEnabled. W pliku application.properties zwróć uwagę na to, że nazwy elementów członkowskich klasy CosmosProperties są blisko powiązane z nazwami właściwości w pliku application.properties. Klasa CosmosProperties przedstawia metody pobierające i metody ustawiające dla pozostałej części aplikacji w celu uzyskania dostępu do ustawień konfiguracji z pliku application.properties. Zauważ, że w tym miejscu nie ma żadnego kodu umożliwiającego ściągnięcie konfiguracji z pliku z application.properties — rozwiązanie Spring Data poprawnie interpretuje strukturę tego pliku i automatycznie ustawia zmienne składowe po przeanalizowaniu pliku konfiguracji.

Z tej konfiguracji będziemy korzystać w przyszłości podczas konfigurowania klienta usługi Azure Cosmos DB.
W pliku CosmosSampleConfiguration.java zbadaj klasę CosmosSampleConfiguration i znajdź pustą metodę cosmosClientBuilder:
```
@Bean
public CosmosClientBuilder cosmosClientBuilder() {
    return null;
}
```
Podczas uruchamiania projekt Spring Data będzie automatycznie wywoływać tę metodę, uzyskiwać element CosmosClientBuilder zwracany przez tę metodę i wywoływać metodę build() — w tym momencie (w tle) zostanie utworzone wystąpienie CosmosAsyncClient na podstawie ustawień konfiguracji zawartych w elemencie CosmosClientBuilder. Za pomocą tej metody można skonfigurować element CosmosClientBuilder, używając metod konstruktora.
Zwróć uwagę, że używamy iniekcji konstruktora (a nie iniekcji pola za pomocą polecenia @Autowired) , aby utworzyć wystąpienie zmiennej properties i wypełnić jej zmienne składowe parsed wartości z pliku konfiguracji. Dzięki temu wszystkie wymagane zależności są obecne podczas tworzenia wystąpienia tej klasy i ułatwiają pisanie kodu testowego w przyszłości.
```
//use constructor injection for spring dependencies 
public CosmosSampleConfiguration(CosmosProperties properties){
    this.properties = properties;
}
```
Możemy użyć properties, aby uzyskać identyfikator URI i klucz dla naszego konta usługi Azure Cosmos DB i zaimplementować element cosmosClientBuilder, jak pokazano poniżej:
```
@Bean
public CosmosClientBuilder cosmosClientBuilder() {
    DirectConnectionConfig directConnectionConfig = DirectConnectionConfig.getDefaultConfig();
    return new CosmosClientBuilder()
        .endpoint(properties.getUri())
        .key(properties.getKey())
        .directMode(directConnectionConfig);
}
```
Ta implementacja
1. Ściąga identyfikator URI i klucz z elementu properties
2. Umieszcza te elementy w obrębie metod konstruktora endpoint i key
3. Ponadto konfiguruje połączenie sieciowe z usługą Azure Cosmos DB. (W trybie bezpośrednim aplikacja kliencka komunikuje się bezpośrednio z partycjami zaplecza w usłudze Azure Cosmos DB).
Wróć do pliku CosmosSampleConfiguration.java i znajdź metodę getDatabaseName:
```
@Override
protected String getDatabaseName() { return ""; }
```
Zmień domyślną wartość zwracaną na "Users", czyli nazwę bazy danych. Dzięki temu, gdy projekt Spring Data automatycznie połączy się z usługą Azure Cosmos DB podczas uruchamiania, nawiąże równocześnie połączenie z bazą danych *użytkowników.
Przejdź do pliku WebCustomer.java. Zauważysz, że klasa WebCustomer jest poprzedzona adnotacją @Container:
```
@Container(containerName = "", ru = "")
```
Element @Container przyjmuje dwa argumenty:
- containerName: nazwa kontenera usługi Azure Cosmos DB (WebCustomers)
- ru: aprowizowana przepływność w kontenerze. 400 RU/s to odpowiednia wartość domyślna dla ćwiczenia wykonywanego w witrynie Microsoft Learn.
Dostosuj element @Container do swojego przypadku użycia, jak pokazano poniżej:
```
@Data
@NoArgsConstructor
@AllArgsConstructor
@Container(containerName = "WebCustomers", ru = "400")
public class WebCustomer {
```

W tym momencie projekt Spring Data jest skonfigurowany do współpracy z usługą Azure Cosmos DB. Następnie utworzysz i uruchomisz program Hello world. Przejdź do strony src/main/java/com/azure/cosmos/examples/springexamples i otwórz CosmosSample.java, który jest szablonem aplikacji Spring Data, którą utworzymy. Powinna to wyglądać następująco:

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

import com.azure.cosmos.CosmosException;
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.cosmos.models.CosmosItemResponse;
import com.azure.cosmos.models.PartitionKey;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

@SpringBootApplication
public class CosmosSample implements CommandLineRunner {

    private final Logger logger = LoggerFactory.getLogger(CosmosSample.class);

    private ReactiveWebCustomerRepository reactiveWebCustomerRepository;

    //constructor dependency injection
    public CosmosSample(ReactiveWebCustomerRepository reactiveWebCustomerRepository){
        this.reactiveWebCustomerRepository = reactiveWebCustomerRepository;
    }

    public void run(String... var1) {
        logger.info("Hello world.");
    }
}

W obecnej postaci kod aplikacji implementuje prosty program „Hello world”.

Jeśli środowisko IDE oferuje narzędzia do kompilowania i uruchamiania aplikacji Maven: skompiluj i uruchom aplikację przy użyciu środowiska IDE i upewnij się, że aplikacja rejestruje się Hello World w terminalu.
Jeśli użyjesz terminalu do skompilowania i uruchomienia aplikacji Maven: użyj następującego polecenia, aby skompilować projekt Maven:
```
mvn clean package
```
Następnie uruchom polecenie:
```
mvn spring-boot:run
```
Sprawdź, czy aplikacja wyświetla w terminalu następujący komunikat, oprócz innych danych wyjściowych:
```
INFO: Hello World.
```

W tej lekcji skonfigurowano podstawy aplikacji języka Java usługi Azure Cosmos DB. Dostosowano aplikację Maven i rozszerzono podstawowy projekt „Hello world” w celu połączenia go z punktem końcowym usługi Azure Cosmos DB.

Ćwiczenie — konfigurowanie aplikacji języka Java za pomocą programu Maven

Tworzenie zasobów usługi Azure Cosmos DB

Tworzenie katalogu roboczego

Łączenie aplikacji z usługą Azure Cosmos DB

Tworzenie wystąpienia CosmosAsyncClient

Łączenie aplikacji z usługą Azure Cosmos DB

Konfigurowanie klienta usługi Azure Cosmos DB

Opinia