Gyakorlat – A Java-alkalmazás beállítása a Maven használatával

  • 15 perc

Ebben az egységben egy tetszőleges integrált fejlesztőkörnyezettel szerkeszt kódot, így létrehoz egy alapszintű konzolalkalmazást. A kódot egy tetszőleges terminállal futtathatja is.

Azure Cosmos DB-erőforrások létrehozása

Ennek a labornak az elvégzéséhez a Microsoft Learn ingyenes Azure-tesztkörnyezetet biztosít, amelyben fiókokat és erőforrásokat hozhat létre. Ebben az előfizetésben fog beállítani egy Azure Cosmos DB-fiókot, majd létrehozni egy adatbázist és egy tárolót.

  1. Jelentkezzen be az Azure Portalra ugyanazzal a fiókkal, amellyel aktiválta a tesztkörnyezetet.
  2. Az Azure Portal használatával hozzon létre egy tetszőleges nevű Azure Cosmos DB-fiókot. Amikor megjelenik a lehetőség, hogy erőforráscsoportot válasszon a fiókhoz, keresse meg a [Tesztkörnyezeti erőforráscsoport] erőforráscsoportot, és válassza azt.
  3. Hozzon létre egy Users (Felhasználók) nevű adatbázist az Azure Cosmos DB-fiókjában.
  4. A Felhasználók adatbázisban hozzon létre egy WebCustomers nevű tárolót a /userId partíciókulcsával. Foglaljon le 400 RU/s átviteli sebességet a Webcustomers számára.

A munkakönyvtár létrehozása

  1. A Java-alkalmazáshoz egy sablont bocsátunk a rendelkezésére. Klónozza a sablon-adattárat a saját rendszerére.

    git clone https://github.com/MicrosoftDocs/mslearn-cosmos-java-sql.git

  2. Nyissa meg a Windows Fájlkezelőt, majd a klónozott adattárat. Lépjen a java_lab alkönyvtárra.

    Fontos

    Az ebben a modulban végzett teljes munkája a java_lab alkönyvtár alatt lesz elhelyezve.

  3. A sablon tartalmaz egy pom.xml Maven-fájlt, amely már behívja a projekthez szükséges függőségeket. Nyissa meg ezt a fájlt, és keresse meg benne az alábbi függőséget:

    <dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-cosmos</artifactId>
    <version>4.8.0</version>
</dependency>

    Ez a függőség az Azure Cosmos DB Java SDK legújabb verzióját hívja be. Bezárhatja ezt a fájlt.

  4. Most egy Hello World alkalmazást fog elkészíteni és futtatni. Nyissa meg ezt a projektet az integrált fejlesztőkörnyezet vagy a terminál használatával. A fejlesztőkörnyezettől függően lehetősége lehet arra, hogy projektként nyissa meg a java alkönyvtárban lévő pom.xml fájlt.

    A projekt megnyitása után nyissa meg az src/main/java/com/azure/cosmos/examples/mslearnbasicapp webhelyet, és nyissa meg a CosmosApp.java-t, amely a fejlesztendő Java-alkalmazás sablonja. Ennek az alábbihoz hasonlónak kell lennie:

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

    Az alkalmazás ebben a formában egy egyszerű „Hello World” üzenetet implementál.

  5. Ha az IDE eszközöket kínál a Maven-alkalmazás létrehozásához és futtatásához: Az alkalmazás létrehozása és futtatása az IDE használatával, és ellenőrizze, hogy az alkalmazás naplózva van-e Hello World a terminálon.

  6. Ha a terminált fogja használni a Maven-alkalmazás létrehozásához és futtatásához: A Maven-projekt létrehozásához használja az alábbi parancsot:

    mvn clean package

    Majd futtassa:

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

    Győződjön meg arról, hogy az alkalmazás a következő kimenetet naplózza a terminálon:

    INFO: Hello World.

Alkalmazás csatlakoztatása az Azure Cosmos DB-hez

  1. Hozza létre az alábbi statikus változókat a CosmosApp osztályon belül az Azure Cosmos DB-kapcsolat adataihoz:

    /** 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>";

  2. Lépjen vissza az Azure Portalra, nyissa meg a Kulcsok panelt, és másolja be az Azure Cosmos DB-végpont URI-ját és elsődleges kulcsát a fenti változó-definíciókba.

    Ha az URI például https://cosmosacct.documents.azure.com:443/, akkor az új változó értékét a következőképpen kell megadnia: private static String endpointUri = "https://cosmosacct.documents.azure.com:443/";. Ha az elsődleges kulcs elzirrKCnXlacvh1CRAnQdYVbVLspmYHQyYrhx0PltHi8wn5lHVHFnd1Xm3ad5cn4TUcH4U0MSeHsVykkFPHpQ==, akkor az új változó értékét a következőképpen kell megadnia: private static String primaryKey = "elzirrKCnXlacvh1CRAnQdYVbVLspmYHQyYrhx0PltHi8wn5lHVHFnd1Xm3ad5cn4TUcH4U0MSeHsVykkFPHpQ==";.

A CosmosAsyncClient-példány létrehozása

Most már létrehozhatjuk a CosmosAsyncClient-példányt, amely az Azure Cosmos DB-szolgáltatás ügyféloldali reprezentációja. Ezzel az ügyféllel a szolgáltatásra irányuló kérések konfigurálhatók és hajthatók végre.

  1. A CosmosApp.java fájlban szúrja be az alábbi statikus változódeklarációt a CosmosApp osztályba:

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

    A client, database, és container osztály még valószínűleg nincs importálva a Java-fájlba. Ideje ezt megtenni. Egyes integrált fejlesztőkörnyezetek lehetővé teszik függőségek automatikus importálását a begépelt kód alapján, ami most hasznos lehet. Általánosságban arra kell felkészülni, hogy amikor kap egy beillesztendő kódblokkot, annak működéséhez esetleg be kell szúrnia néhány import utasítást.

  2. Hozzon létre egy basicOperations nevű, argumentumok nélküli private void metódust az osztályban.

  3. Illessze be az alábbi kódot a basicOperations metódusba egy CosmosAsyncClient-példány létrehozásához, és a Users adatbázis létezését ellenőrző kódot.

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

  4. Ezen a ponton a basicOperations metódus tartalmazza az Azure Cosmos DB kezeléséhez szükséges kódot. Ez a metódus azonban nincs meghívvamain, így az alkalmazás továbbra is a ""Helló világ!" alkalmazás" nyomtatására szolgál. Ellenőrzésként hozza létre és futtassa a CosmosApp.java-t az IDE-ben, vagy futtassa a programot a terminálon a következő használatával:

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

    Győződjön meg arról, hogy az alkalmazás továbbra is a következő kimenetet naplózza a terminálon:

    INFO: Hello World.

  5. Másolja és illessze be a következő kódot a main metódusba, felülírva az aktuális logger.info("Hello World."); sort.

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

    Ez aktiválja az Azure Cosmos DB-kódot az alkalmazásban.

  6. Fordítsa le és futtassa a CosmosApp.java alkalmazást a fejlesztőkörnyezetben, vagy hajtsa végre a programot a terminálban a következő módon:

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

    A terminálban nagy számú naplóüzenet jelenhet meg, amelyek közül néhányat maga az SDK generál. Olvassa át ezeket, és ellenőrizze, hogy az alkalmazás kiírta a terminálra a következőt:

    INFO: Database and container validation complete

Ebben a leckében lefektette az Azure Cosmos DB Java-alkalmazás alapjait. Beállította a Maven-alkalmazást, létrehozott egy egyszerű „Hello World” projektet, majd kiterjesztette azt, hogy csatlakozzon az Azure Cosmos DB-végponthoz.

  1. A Java-alkalmazáshoz egy sablont bocsátunk a rendelkezésére. Klónozza a sablon-adattárat a saját rendszerére

    git clone https://github.com/MicrosoftDocs/mslearn-cosmos-java-sql.git

  2. Nyissa meg a Windows Intézőt, és navigáljon a klónozott adattárhoz. Lépjen a spring_lab alkönyvtárra.

    Fontos

    Az ebben a modulban végzett teljes munkája a spring_lab alkönyvtár alatt lesz elhelyezve.

  3. A sablon tartalmaz egy pom.xml Maven-fájlt, amely már behívja a projekthez szükséges függőségeket. Nyissa meg ezt a fájlt, és keresse meg benne az alábbi függőséget:

    <dependency>
  <groupId>com.azure</groupId>
  <artifactId>azure-spring-data-cosmos</artifactId>
  <version>3.24.0</version>
</dependency>

    Ez a függőség a Spring Data Azure Cosmos DB legújabb verzióját hívja be. Bezárhatja ezt a fájlt.

Alkalmazás csatlakoztatása az Azure Cosmos DB-hez

  1. Nyissa meg ezt a projektet az integrált fejlesztőkörnyezet vagy a terminál használatával. A fejlesztőkörnyezettől függően lehetősége lehet arra, hogy projektként nyissa meg a spring alkönyvtárban lévő pom.xml fájlt. A projekt megnyitása után lépjen az src/main/resources/ fájlkezelő eszközre. Itt találnia kell egy application.properties.rename nevű fájlt. A Spring Data a kódba beírt konfigurációs paraméterek helyett a konfigurációs fájlok használatát részesíti előnyben. A Spring Data-projekt konfigurációs fájljának létrehozásához másolja az application.properties.rename fájlt az application.properties fájlba, majd nyissa meg az új application.properties fájlt. A következőnek kell megjelennie:

    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

    Az ${ACCOUNT_HOST} és az ${ACCOUNT_KEY} értékét az Ön által választott módszerrel töltheti ki – bemásolhatja az értékeket az application.properties fájlba, vagy definiálhatja ezeket a környezeti változókat az integrált fejlesztőkörnyezetben. A következő lépésben megállapíthatja az értékeket, amelyekkel ezeknek a változóknak rendelkezniük kell.

  2. Lépjen vissza az Azure Portalra, nyissa meg a Kulcsok panelt, és másolja ki az Azure Cosmos DB-végpont URI-ját és elsődleges kulcsát. Az előző lépésben leírtak szerint, a választott módszerrel rendelje hozzá az Azure Cosmos DB-végpont URI-ját és elsődleges kulcsát az említett változókhoz.

    Ha az URI például https://cosmosacct.documents.azure.com:443/, és úgy döntött, hogy a végpontot és az elsődleges kulcsot az application.properties fájlba illeszti be, az application.properties ez után a cosmos.uri=https://cosmosacct.documents.azure.com:443/ alakot ölti. Ha az elsődleges kulcs elzirrKCnXlacvh1CRAnQdYVbVLspmYHQyYrhx0PltHi8wn5lHVHFnd1Xm3ad5cn4TUcH4U0MSeHsVykkFPHpQ==, akkor az új változó értékének ugyanezzel a módszerrel végzett hozzárendelése a következőt eredményezi: cosmos.key=elzirrKCnXlacvh1CRAnQdYVbVLspmYHQyYrhx0PltHi8wn5lHVHFnd1Xm3ad5cn4TUcH4U0MSeHsVykkFPHpQ==.

Az Azure Cosmos DB-ügyfél konfigurálása

A Spring Data Azure Cosmos DB indításkor automatikusan példányosítja az Azure Cosmos DB-ügyfelet. Az Azure Cosmos DB-ügyfél az Azure Cosmos DB szolgáltatás ügyféloldali megfelelője, amely a szolgáltatáshoz intézett kérések végrehajtására használatos. A kód a buildelő metódusok és az application.properties fájlból lekért tulajdonságok használatával konfigurálhatja az Azure Cosmos DB-ügyfelet annak példányosítása előtt.

  1. Nyissa meg a CosmosProperties.java fájlt. Ezt a fájlt a teljes formájában adtuk meg, ezért elég, ha megvizsgálja annak tartalmát.

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

    Figyelje meg az osztály uri, key, secondaryKey és queryMetricsEnabled tagját. Az application.properties fájlhoz visszatérve figyelje meg, hogy a CosmosProperties tagjainak neve szorosan összefügg az application.properties fájlban szereplő tulajdonságnevekkel. A CosmosProperties osztály az alkalmazás többi részének beállításokat végző elemei számára teszi elérhetővé az application.properties fájlban található beállításokat. Megfigyelheti, hogy itt nincs a konfigurációt az application.properties fájlból lekérő kód – a Spring Data megérti ennek a fájlnak a struktúráját, és a konfigurációs fájl feldolgozása után automatikusan beállítja tagváltozókat.

    Ezt a működést használjuk ki a továbblépéshez, az Azure Cosmos DB-ügyfél konfigurálásakor.

  2. Vizsgálja meg a CosmosSampleConfiguration.java fájlban a CosmosSampleConfiguration osztályt, és keresse meg az üres cosmosClientBuilder metódust:

    @Bean
public CosmosClientBuilder cosmosClientBuilder() {
    return null;
}

    A Spring Data indításkor automatikusan meghívja ezt a metódust, megkapja a metódus által visszaadott CosmosClientBuilder értéket, majd meghívja a build() metódusát – ezen a ponton (a háttérben) a CosmosAsyncClient egy példánya lesz létrehozva a CosmosClientBuilder által tartalmazott konfigurációs beállítások alapján. Ezt a metódust felhasználhatja a CosmosClientBuilder konfigurálására buildelő metódusokkal.

  3. Figyelje meg, hogy konstruktorinjektálást használunk (a mezőinjektálás @Autowired) helyett a properties változó példányosítására és tagváltozóinak feltöltésére a konfigurációs fájlból származó elemzési értékekkel. Ez biztosítja, hogy az osztály példányának létrehozásakor minden szükséges függőség jelen legyen, és a jövőben megkönnyítse a tesztkód írását.

    //use constructor injection for spring dependencies 
public CosmosSampleConfiguration(CosmosProperties properties){
    this.properties = properties;
}

    A properties használatával megkaphatjuk az Azure Cosmos DB-fiók uri és key értékét, és az alábbi módon implementálhatjuk a cosmosClientBuilder metódust:

    @Bean
public CosmosClientBuilder cosmosClientBuilder() {
    DirectConnectionConfig directConnectionConfig = DirectConnectionConfig.getDefaultConfig();
    return new CosmosClientBuilder()
        .endpoint(properties.getUri())
        .key(properties.getKey())
        .directMode(directConnectionConfig);
}

    Az implementáció

    1. Lekéri az uri és a key a properties változóból
    2. Ezeket átadja az endpoint és a key buildelő metódusnak
    3. Ezeken felül konfigurálja a hálózati kapcsolatot az Azure Cosmos DB szolgáltatás felé. (Direkt módban az ügyfélalkalmazás közvetlenül a háttérbeli Azure Cosmos DB-partíciókkal kommunikál.)

  4. Lépjen vissza a CosmosSampleConfiguration.java fájlhoz, és keresse meg a getDatabaseName metódust:

    @Override
protected String getDatabaseName() { return ""; }

    Módosítsa az alapértelmezett visszatérési értéket a "Users" értékre, az adatbázis nevére. Így amikor a Spring Data induláskor automatikusan kapcsolódik az Azure Cosmos DB-hez, a *Users adatbázishoz fog kapcsolódni.

  5. Lépjen a WebCustomer.java fájlhoz. Megfigyelheti, hogy a WebCustomer osztály előtt egy @Container bejegyzés áll:

    @Container(containerName = "", ru = "")

    A @Container két argumentummal rendelkezik:

    • containerName: Az Azure Cosmos DB-tároló neve (WebCustomers)
    • ru: A tároló kiosztott átviteli sebessége. Egy Microsoft Learn-gyakorlathoz megfelel az alapértelmezett 400 RU/s érték.

    Szabja testre a @Container értékét az alábbiak szerint:

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

  6. Ezen a ponton a Spring Data-projekt már be van állítva az Azure Cosmos DB használatára. Most egy Hello World alkalmazást fog elkészíteni és futtatni. Nyissa meg az src/main/java/com/azure/cosmos/examples/springexamples webhelyet, és nyissa meg a CosmosSample.java-t, amely a fejlesztendő Spring Data-alkalmazás sablonja. Ennek az alábbihoz hasonlónak kell lennie:

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

    Az alkalmazás ebben a formában egy egyszerű „Hello World” üzenetet implementál.

  7. Ha az IDE eszközöket kínál a Maven-alkalmazás létrehozásához és futtatásához: Az alkalmazás létrehozása és futtatása az IDE használatával, és ellenőrizze, hogy az alkalmazás naplózva van-e Hello World a terminálon.

  8. Ha a terminált fogja használni a Maven-alkalmazás létrehozásához és futtatásához: A Maven-projekt létrehozásához használja az alábbi parancsot:

    mvn clean package

    Majd futtassa:

    mvn spring-boot:run

    Győződjön meg arról, hogy az alkalmazás a következő kimenetet naplózza a terminálon a többi kimenet között:

    INFO: Hello World.

Ebben a leckében lefektette az Azure Cosmos DB Java-alkalmazás alapjait. Testreszabta a Maven-alkalmazást, és kibővített egy egyszerű „Hello World” projektet, hogy az csatlakozzon egy Azure Cosmos DB-végponthoz.