Cvičení – zřízení aplikace v Javě pomocí Mavenu

15 min

V této lekci vytvoříte základní konzolovou aplikaci, přičemž k úpravě kódu použijete integrované vývojové prostředí (IDE) podle svého výběru. Ke spuštění můžete volitelně použít terminál podle svého výběru.

Vytvoření prostředků Azure Cosmos DB

K dokončení tohoto cvičení Microsoft Learn poskytuje bezplatný sandbox Azure, ve kterém můžete vytvářet účty a prostředky. V tomto předplatném si zřídíte účet Azure Cosmos DB a následně vytvoříte databázi a kontejner.

Pomocí stejného účtu, kterým jste aktivovali sandbox, se přihlaste k webu Azure Portal.
Přes Azure Portal si vytvořte účet Azure Cosmos DB s libovolným názvem. Až budete mít příležitost k volbě skupiny prostředků pro tento účet, najděte skupinu prostředků [sandboxová skupina prostředků] a vyberte ji.
V účtu služby Azure Cosmos DB vytvořte databázi s názvem Users.
V databázi Users vytvořte kontejner s názvem WebCustomers s klíčem oddílu /userId. Pro WebCustomers zřiďte 400 RU/s.

Vytvoření pracovního adresáře

Pro tuto aplikaci v Javě vám poskytneme šablonu. Naklonujte úložiště této šablony do svého systému.
```
git clone https://github.com/MicrosoftDocs/mslearn-cosmos-java-sql.git
```
Otevřete Průzkumníka souborů Windows a přejděte do klonovaného úložiště. Přejděte do podadresáře java_lab.

Důležité

Veškerá práce související s tímto modulem se bude nacházet v podadresáři java_lab.
Šablona obsahuje soubor pom.xml pro Maven, který už stáhne požadované závislosti pro váš projekt. Otevřete tento soubor a najděte následující závislost:
```
<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-cosmos</artifactId>
    <version>LATEST</version>
</dependency>
```
Tato závislost stáhne nejnovější verzi sady Azure Cosmos DB Java SDK. Tento soubor můžete zavřít.
Následně sestavíte a spustíte Hello World. Pomocí integrovaného vývojového prostředí nebo terminálu otevřete tento projekt. V závislosti na použitém integrovaném vývojovém prostředí může být k dispozici možnost otevřít soubor pom.xml v podadresáři java jako projekt.

Po otevření projektu přejděte na src/main/java/com/azure/cosmos/examples/mslearnbasicapp a otevřete CosmosApp.java, což je šablona pro aplikaci v Javě, kterou budeme vyvíjet. Měla by vypadat přibližně takto:
```
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.");
    }
}
```
Kód aplikace implementuje jednoduchý výpis textu „Hello world“.
Pokud vaše integrované vývojové prostředí (IDE) nabízí nástroje pro sestavení a spuštění aplikace Maven: Sestavte a spusťte aplikaci pomocí integrovaného vývojového prostředí (IDE) a ověřte, že se aplikace protokoluje Hello World do terminálu.
Pokud k sestavení a spuštění aplikace Maven použijete terminál: K sestavení projektu Maven použijte následující příkaz:
```
mvn clean package
```
Pak spusťte tyto příkazy:
```
mvn exec:java -Dexec.mainClass="com.azure.cosmos.examples.mslearnbasicapp.CosmosApp"  
```
Potvrďte, že aplikace vypíše do terminálu následující výstup:
```
INFO: Hello World.
```

Připojení aplikace ke službě Azure Cosmos DB

Ve třídě CosmosApp vytvořte následující proměnné statické třídy pro podrobnosti připojení ke službě 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>";

Vraťte se na Azure Portal, přejděte do okna Klíče a zkopírujte a vložte do výše uvedených definic proměnných identifikátor URI a primární klíč koncového bodu Azure Cosmos DB.

Pokud je identifikátor URI například https://cosmosacct.documents.azure.com:443/, bude nové přiřazení proměnné vypadat takto: private static String endpointUri = "https://cosmosacct.documents.azure.com:443/";. Pokud je primární klíč například elzirrKCnXlacvh1CRAnQdYVbVLspmYHQyYrhx0PltHi8wn5lHVHFnd1Xm3ad5cn4TUcH4U0MSeHsVykkFPHpQ==, bude nové přiřazení proměnné vypadat takto: private static String primaryKey = "elzirrKCnXlacvh1CRAnQdYVbVLspmYHQyYrhx0PltHi8wn5lHVHFnd1Xm3ad5cn4TUcH4U0MSeHsVykkFPHpQ==";.

Vytvoření instance CosmosAsyncClient

Nyní je čas vytvořit instanci CosmosAsyncClient, což je reprezentace služby Azure Cosmos DB na straně klienta. Tento klient slouží ke konfiguraci a provádění požadavků na službu.

Do souboru CosmosApp.java přidejte do třídy CosmosApp následující deklarace statických proměnných:
```
/** 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;
```
Nejpravděpodobnější je, že třídy client, database a container ještě nejsou do vašeho souboru v Javě naimportované. Proto je teď vhodný čas se o to postarat. Některá integrovaná vývojová prostředí umožňují automatický import závislostí na základě zadaného kódu, což teď může být užitečné. Obecně očekávejte, že když vás požádáme o vložení nějakého bloku kódu, budete muset přidat určité příkazy import, aby to fungovalo.
Vytvořte v této třídě metodu typu private void s názvem basicOperations, a to bez argumentů.

Přidáním následujícího kódu vytvořte instanci CosmosAsyncClient v metodě basicOperations a přidejte kód, který kontroluje, jestli existuje databáze 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();

V tomto okamžiku obsahuje metoda basicOperations kód pro interakci se službou Azure Cosmos DB. Tato metoda však není volána main, takže naše aplikace stále slouží k tisku "Hello World". Jako kontrolu sestavte a spusťte CosmosApp.java v integrovaném vývojovém prostředí (IDE) nebo spusťte program v terminálu pomocí:
```
mvn clean package
mvn exec:java -Dexec.mainClass="com.azure.cosmos.examples.mslearnbasicapp.CosmosApp"  
```
Potvrďte, že aplikace stále vypíše do terminálu následující výstup:
```
INFO: Hello World.
```

Zkopírujte a vložte následující kód do main metody a přepíšete aktuální logger.info("Hello World."); řádek.

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.");
}

Tím se v naší aplikaci aktivuje kód Azure Cosmos DB.

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 pravděpodobně uvidíte velký počet zpráv protokolu, z nichž některé generuje samotná sada SDK. Pročtěte si je a potvrďte, že aplikace stále vypíše do terminálu následující výstup:
```
INFO: Database and container validation complete
```

V této lekci jste vytvořili základy pro vaši aplikaci Java využívající Azure Cosmos DB. Zřídili jste aplikaci Maven, vytvořili základní projekt „Hello World“ a rozšířili ho o připojení projektu ke koncovému bodu Azure Cosmos DB.

Pro tuto aplikaci Java vám poskytneme šablonu. Naklonujte úložiště této šablony do svého systému.
```
git clone https://github.com/MicrosoftDocs/mslearn-cosmos-java-sql.git
```
Otevřete Průzkumníka Windows a přejděte do naklonovaného úložiště. Přejděte do podadresáře spring_lab.

Důležité

Veškerá práce související s tímto modulem se bude nacházet v podadresáři spring_lab.
Šablona obsahuje soubor pom.xml pro Maven, který už stáhne požadované závislosti pro váš projekt. Otevřete tento soubor a najděte níže uvedenou závislost:
```
<dependency>
  <groupId>com.azure</groupId>
  <artifactId>azure-spring-data-cosmos</artifactId>
  <version>LATEST</version>
</dependency>
```
Tato závislost stáhne nejnovější verzi sady Spring Data Azure Cosmos DB. Tento soubor můžete zavřít.

Připojení aplikace ke službě Azure Cosmos DB

Pomocí integrovaného vývojového prostředí nebo terminálu otevřete tento projekt. V závislosti na použitém integrovaném vývojovém prostředí můžete mít možnost otevřít soubor pom.xml v podadresáři spring jako projekt. Po otevření projektu přejděte na src/main/resources/ pomocí nástroje Průzkumníka souborů. Měli byste vidět soubor s názvem application.properties.rename. Spring Data dává před pevně zakódovanými konfiguračními parametry přednost konfiguračním souborům; konfigurační soubor pro projekt Spring Data vytvoříte tak, že soubor application.properties.rename zkopírujete do souboru application.properties a pak nový soubor application.properties otevřete. Měli byste vidět toto:
```
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
```
${ACCOUNT_HOST} a ${ACCOUNT_KEY} naplníte metodou dle svého výběru – buď hodnoty zkopírujte a vložte do souboru application.properties, nebo tyto proměnné prostředí definujte ve svém integrovaném vývojovém prostředí. V dalším kroku najdete hodnoty, kterých by tyto proměnné měly nabývat.
Vraťte se na Azure Portal, přejděte do podokna Klíče a zkopírujte identifikátor URI a primární klíč koncového bodu Azure Cosmos DB. Jak bylo popsáno v předchozím kroku, k přiřazení identifikátoru URI a primárního klíče koncového bodu Azure Cosmos DB ke dříve zmíněným proměnným použijte metodu dle svého výběru.

Pokud je identifikátor URI například https://cosmosacct.documents.azure.com:443/ a rozhodnete se koncový bod a primární klíč vložit do souboru application.properties, bude tento řádek v souboru application.properties následně vypadat takto: cosmos.uri=https://cosmosacct.documents.azure.com:443/. Pokud je primární klíč například elzirrKCnXlacvh1CRAnQdYVbVLspmYHQyYrhx0PltHi8wn5lHVHFnd1Xm3ad5cn4TUcH4U0MSeHsVykkFPHpQ==, bude při použití tohoto postupu vypadat nové přiřazení proměnné takto: cosmos.key=elzirrKCnXlacvh1CRAnQdYVbVLspmYHQyYrhx0PltHi8wn5lHVHFnd1Xm3ad5cn4TUcH4U0MSeHsVykkFPHpQ==.

Konfigurace klienta Azure Cosmos DB

Spring Data Azure Cosmos DB vytvoří při spuštění automaticky instanci klienta Azure Cosmos DB. Klient Azure Cosmos DB je reprezentace služby Azure Cosmos DB na straně klienta, která se používá ke spouštění žádostí vůči této službě. Pomocí sady vytvářecích metod a vlastností získaných ze souboru application.properties může váš kód nakonfigurovat klienta Azure Cosmos DB před tím, než se vytvoří jeho instance.

Otevřete soubor CosmosProperties.java. Tento soubor jsme připravili předem, takže jen prozkoumejte jeho obsah.
```
@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;
    }
}
```
Prohlédněte si členy třídy uri, key, secondaryKey a queryMetricsEnabled. Když se znovu podíváte na soubor application.properties, zjistíte, že názvy členů CosmosProperties odpovídají názvům vlastností v souboru application.properties. Třída CosmosProperties obsahuje metody pro získání a nastavení (getter a setter), aby měl zbytek vaší aplikace přístup ke konfiguračním nastavením ze souboru application.properties. Všimněte si, že neexistuje žádný kód pro načtení konfigurace ze souboru application.properties – Spring Data rozumí struktuře tohoto souboru a automaticky nastavuje členské proměnné po parsování tohoto konfiguračního souboru.

Při konfiguraci klienta Azure Cosmos DB toho budeme využívat.
V souboru CosmosSampleConfiguration.java si prohlédněte třídu CosmosSampleConfiguration a najděte prázdnou metodu cosmosClientBuilder:
```
@Bean
public CosmosClientBuilder cosmosClientBuilder() {
    return null;
}
```
Model Spring Data při spuštění automaticky tuto metodu zavolá, získá CosmosClientBuilder vrácené touto metodou a zavolá jeho metodu build() – v tomto okamžiku se (na pozadí) vytvoří instance CosmosAsyncClient na základě konfiguračních nastavení v CosmosClientBuilder. Tuto metodu můžete použít ke konfiguraci CosmosClientBuilder pomocí vytvářecích metod.
Všimněte si, že používáme injektáž konstruktoru (místo injektáže pole pomocí @Autowired) vytvoření instance properties proměnné a naplnění jejích členských proměnných parsovanými hodnotami z konfiguračního souboru). Tím se zajistí, že při vytvoření instance této třídy budou přítomny všechny požadované závislosti a usnadníte psaní testovacího kódu v budoucnu.
```
//use constructor injection for spring dependencies 
public CosmosSampleConfiguration(CosmosProperties properties){
    this.properties = properties;
}
```
K získání identifikátoru URI a klíče účtu Azure Cosmos DB a implementaci cosmosClientBuilder můžeme použít properties, jak je znázorněno níže:
```
@Bean
public CosmosClientBuilder cosmosClientBuilder() {
    DirectConnectionConfig directConnectionConfig = DirectConnectionConfig.getDefaultConfig();
    return new CosmosClientBuilder()
        .endpoint(properties.getUri())
        .key(properties.getKey())
        .directMode(directConnectionConfig);
}
```
Tato implementace:
1. Zjistí identifikátor URI a klíč z properties.
2. Zapojí je do vytvářecích metod endpoint a key.
3. Dodatečně nakonfiguruje síťové připojení ke službě Azure Cosmos DB. (V přímém režimu komunikuje klientská aplikace přímo s back-endovými oddíly Azure Cosmos DB.)
Vraťte se k souboru CosmosSampleConfiguration.java a najděte metodu getDatabaseName:
```
@Override
protected String getDatabaseName() { return ""; }
```
Změňte výchozí návratovou hodnotu na "Users", což je název vaší databáze. Když se Spring Data při spuštění automaticky připojí k Azure Cosmos DB, připojí se k databázi *Users.
Přejděte k souboru WebCustomer.java. Všimněte si, že před třídou WebCustomer se nachází anotace @Container:
```
@Container(containerName = "", ru = "")
```
@Container přebírá dva argumenty:
- containerName: Název kontejneru Azure Cosmos DB (WebCustomers)
- ru: Zřízená propustnost vašeho kontejneru. 400 RU/s je dobrou výchozí hodnotou pro cvičení Microsoft Learn.
@Container přizpůsobte pro svůj případ, jak je znázorněno zde:
```
@Data
@NoArgsConstructor
@AllArgsConstructor
@Container(containerName = "WebCustomers", ru = "400")
public class WebCustomer {
```

V tuto chvíli je projekt Spring Data nastavený tak, aby spolupracoval s Azure Cosmos DB. Následně sestavíte a spustíte Hello World. Přejděte na src/main/java/com/azure/cosmos/examples/springexamples a otevřete CosmosSample.java, což je šablona pro aplikaci Spring Data, kterou budeme vyvíjet. 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.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.");
    }
}

Kód aplikace implementuje jednoduchý výpis textu „Hello world“.

Pokud vaše integrované vývojové prostředí (IDE) nabízí nástroje pro sestavení a spuštění aplikace Maven: Sestavte a spusťte aplikaci pomocí integrovaného vývojového prostředí (IDE) a ověřte, že se aplikace protokoluje Hello World do terminálu.
Pokud k sestavení a spuštění aplikace Maven použijete terminál: K sestavení projektu Maven použijte následující příkaz:
```
mvn clean package
```
Pak spusťte tyto příkazy:
```
mvn spring-boot:run
```
Potvrďte, že aplikace kromě jiného vypíše do terminálu následující výstup:
```
INFO: Hello World.
```

V této lekci jste vytvořili základy pro vaši aplikaci Java využívající Azure Cosmos DB. Přizpůsobili jste aplikaci Maven a rozšířili základní projekt „Hello World“ o připojení ke koncovému bodu Azure Cosmos DB.

Cvičení – zřízení aplikace v Javě pomocí Mavenu

Vytvoření prostředků Azure Cosmos DB

Vytvoření pracovního adresáře

Připojení aplikace ke službě Azure Cosmos DB

Vytvoření instance CosmosAsyncClient

Připojení aplikace ke službě Azure Cosmos DB

Konfigurace klienta Azure Cosmos DB

Váš názor