Övning – Konfigurera en Java-app med hjälp av Maven

  • 15 minuter

I den här enheten skapar du en Basic-konsolapp genom att använda valfri IDE för att redigera kod. Du kan välja att använda valfri terminal för att köra koden.

Skapa Azure Cosmos DB-resurser

För den här labbuppgiften erbjuder Microsoft Learn en kostnadsfri Azure sandbox-miljö där du kan skapa konton och resurser. Du konfigurerar ett Azure Cosmos DB-konto i den här prenumerationen och skapar sedan en databas och en container.

  1. Logga in på Azure-portalen med samma konto som du använde när du aktiverade sandbox-miljön.
  2. Med hjälp av Azure-portalen skapar du ett Azure Cosmos DB-konto med valfritt namn. När du får möjlighet att välja en resursgrupp för kontot letar du upp resursgruppen [resursgrupp för sandbox-miljö] och väljer den.
  3. I Azure Cosmos DB-kontot skapar du en databas som heter Användare.
  4. I databasen Användare skapar du en container med namnet WebCustomers med partitionsnyckeln /userId. Etablera 400 RU/s för WebCustomers.

Skapa arbetskatalogen

  1. Vi ger dig en mall för Java-programmet. Klona mallagringsplatsen till ditt system.

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

  2. Öppna Utforskaren och gå till den klonade lagringsplatsen. Ange underkatalogen java_lab.

    Viktigt!

    Allt ditt arbete för den här modulen hamnar i underkatalogen java_lab.

  3. Mallen innehåller en pom.xml-fil för Maven som redan hämtar de nödvändiga beroendena för projektet. Öppna den här filen och leta upp nedanstående beroende:

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

    Det här beroendet hämtar den senaste versionen av Java SDK för Azure Cosmos DB. Du kan stänga den här filen.

  4. Därefter kompilerar och kör du Hello World. Öppna det här projektet i din IDE eller terminal. Beroende på din IDE kan det finnas ett alternativ för att öppna pom.xml-filen i underkatalogen java som ett projekt.

    När projektet är öppet går du till src/main/java/com/azure/cosmos/examples/mslearnbasicapp och öppnar CosmosApp.java, som är en mall för Java-programmet som vi ska utveckla. Den bör se ut ungefär så här:

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

    I befintligt skick implementerar programkoden en enkel variant av Hello World.

  5. Om din IDE erbjuder verktyg för att skapa och köra ditt Maven-program: Skapa och köra ditt program med hjälp av IDE och bekräfta att programmet loggar Hello World till terminalen.

  6. Om du använder terminalen för att skapa och köra ditt Maven-program: Använd följande kommando för att skapa Maven-projektet:

    mvn clean package

    Kör sedan:

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

    Bekräfta att programmet loggar följande utdata till terminalen:

    INFO: Hello World.

Ansluta appen till Azure Cosmos DB

  1. I klassen CosmosApp skapar du följande variabler för statisk klass för din Azure Cosmos DB-anslutningsinformation:

    /** 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. Gå tillbaka till Azure-portalen, gå till panelen Nycklar och kopiera/klistra in din slutpunkts-URI och primärnyckel för Azure Cosmos DB till variabeldefinitionerna ovan.

    Om din URI till exempel är https://cosmosacct.documents.azure.com:443/ ser den nya variabeltilldelningen ut så här: private static String endpointUri = "https://cosmosacct.documents.azure.com:443/";. Om din primärnyckel är elzirrKCnXlacvh1CRAnQdYVbVLspmYHQyYrhx0PltHi8wn5lHVHFnd1Xm3ad5cn4TUcH4U0MSeHsVykkFPHpQ== ser den nya variabeltilldelningen ut så här: private static String primaryKey = "elzirrKCnXlacvh1CRAnQdYVbVLspmYHQyYrhx0PltHi8wn5lHVHFnd1Xm3ad5cn4TUcH4U0MSeHsVykkFPHpQ==";.

Skapa CosmosAsyncClient-instansen

Nu är det dags att skapa en instans av CosmosAsyncClient, som är en klientdelsrepresentation av Azure Cosmos DB-tjänsten. Den här klienten används för att konfigurera och köra förfrågningar till tjänsten.

  1. I CosmosApp.java lägger du till följande deklaration av statisk variabel i klassen 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;

    Förmodligen har klasserna client, databaseoch container inte importerats till din Java-fil än. Därför är det nu lämpligt att ta hand om det. I vissa IDE går det att automatiskt importera beroenden baserat på den kod du skriver in, vilket kan vara användbart i det här fallet. Generellt sett kan du förvänta dig att behöva lägga till några import-instruktioner för att det ska fungera när du får ett kodblock som ska klistras in.

  2. Skapa en private void-metod som heter basicOperations utan argument i klassen.

  3. Lägg till följande kod för att skapa en CosmosAsyncClient i basicOperations-metoden och inkludera kod som kontrollerar huruvida databasen Användare finns.

     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. Nu innehåller metoden basicOperations kod för interaktion med Azure Cosmos DB. Den här metoden anropas dock inte i main, så vårt program fungerar fortfarande för att skriva ut "Hello World". Som en kontroll skapar och kör du CosmosApp.java i IDE eller kör programmet i terminalen med hjälp av:

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

    Bekräfta att appen fortfarande loggar följande utdata till terminalen:

    INFO: Hello World.

  5. Kopiera och klistra in följande kod i main metoden och skriv över den aktuella logger.info("Hello World."); raden.

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

    Det här utlöser Azure Cosmos DB-koden i vårt program.

  6. Kompilera och kör CosmosApp.java i IDE eller kör programmet i terminalen med hjälp av:

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

    Det kan komma ett stort antal loggmeddelanden i terminalen, varav vissa genereras av själva SDK:n. Läs igenom och bekräfta att appen loggar följande utdata till terminalen:

    INFO: Database and container validation complete

I den här lektionen har du skapat grunden till ditt Java-program för Azure Cosmos DB. Du konfigurerade Maven-programmet, skapade ett grundläggande ”Hello World”-projekt och utökade det för att ansluta projektet till Azure Cosmos DB-slutpunkten.

  1. Vi ger dig en mall för Java-programmet. Klona mallagringsplatsen till ditt system

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

  2. Öppna Utforskaren i Windows och gå till den klonade lagringsplatsen. Ange underkatalogen spring_lab.

    Viktigt!

    Allt ditt arbete för den här modulen hamnar i underkatalogen spring_lab.

  3. Mallen innehåller en pom.xml för Maven som redan hämtar de nödvändiga beroendena för projektet. Öppna den här filen och leta upp nedanstående beroende:

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

    Det här beroendet hämtar den senaste versionen av Azure Cosmos DB för Spring Data. Du kan stänga den här filen.

Ansluta appen till Azure Cosmos DB

  1. Öppna det här projektet i din IDE eller terminal. Beroende på din IDE kan det finnas ett alternativ för att öppna pom.xml-filen i underkatalogen spring som ett projekt. När projektet är öppet navigerar du till src/main/resources/ med hjälp av ett filutforskareverktyg. Du bör se en fil med namnet application.properties.rename. Spring Data lyfter fram konfigurationsfiler framför hårdkodade konfigurationsparametrar. Om du vill skapa en konfigurationsfil för ditt Spring Data-projekt kopierar du application.properties.rename tillt application.properties och öppnar den nya application.properties-filen. Du bör se

    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

    Du ska fylla i ${ACCOUNT_HOST} och ${ACCOUNT_KEY} med valfri metod – antingen kopiera och klistra in värdena i application.properties eller definiera dessa miljövariabler i din IDE. I nästa steg hittar du värdena som de här variablerna bör ha.

  2. Gå tillbaka till Azure-portalen, gå till fönstret Nycklar och kopiera in din slutpunkts-URI och primärnyckel för Azure Cosmos DB. Som det beskrevs i föregående steg ska du använda valfri metod för att tilldela din slutpunkts-URI och primärnyckel för Azure Cosmos DB till ovannämnda variabler.

    Om din URI till exempel är https://cosmosacct.documents.azure.com:443/ och du väljer att klistra in slutpunkten och primärnyckeln i application.properties, kommer raden i application.properties följdaktligen att se ut så här: cosmos.uri=https://cosmosacct.documents.azure.com:443/. Om din primärnyckel är elzirrKCnXlacvh1CRAnQdYVbVLspmYHQyYrhx0PltHi8wn5lHVHFnd1Xm3ad5cn4TUcH4U0MSeHsVykkFPHpQ==, kommer din nya variabeltilldelning enligt samma process att se ut så här: cosmos.key=elzirrKCnXlacvh1CRAnQdYVbVLspmYHQyYrhx0PltHi8wn5lHVHFnd1Xm3ad5cn4TUcH4U0MSeHsVykkFPHpQ==.

Konfigurera Azure Cosmos DB-klienten

Azure Cosmos DB för Spring Data skapar automatiskt en instans för Azure Cosmos DB-klienten vid starten. Azure Cosmos DB-klienten är klientsidans representation av Azure Cosmos DB-tjänsten och används för att köra begäranden mot tjänsten. Din kod kan konfigurera Azure Cosmos DB-klienten innan den instansieras med hjälp av en uppsättning byggarmetoder tillsammans med egenskaper som hämtas från application.properties.

  1. Öppna CosmosProperties.java. Vi tillhandahåller den här filen i ett slutfört format, så du behöver bara undersöka innehållet.

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

    Observera klassmedlemmarna uri, key, secondaryKey, queryMetricsEnabled. Gå tillbaka till application.propertiesoch notera att medlemsnamnen CosmosProperties är mycket lika egenskapsnamnen för application.properties. Klassen CosmosProperties visar set- och get-metoderna för resten av programmet för att få åtkomst till konfigurationsinställningar från application.properties. Observera att det inte finns någon kod här för att hämta konfigurationen från application.properties. Spring Data förstår den här filens struktur och konfigurerar medlemsvariablerna automatiskt efter parsning av konfigurationsfilen.

    Vi kommer att använda den här konfigurationen när vi konfigurerar Azure Cosmos DB-klienten.

  2. I CosmosSampleConfiguration. java kontrollerar du CosmosSampleConfiguration-klassen och hittar efter den tomma cosmosClientBuilder-metoden:

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

    Vid starten anropar Spring Data automatiskt den här metoden, hämtar CosmosClientBuilder som den här metoden returnerar och anropar dess build()-metod. Då skapas en CosmosAsyncClient-instans (bakom kulisserna) baserat på konfigurationsinställningarna i CosmosClientBuilder. Du kan använda den här metoden för att konfigurera CosmosClientBuilder med hjälp av byggarmetoder.

  3. Observera att vi använder konstruktorinmatning (i stället för fältinmatning med hjälp av @Autowired) för att instansiera variabeln propertiesoch fylla i dess medlemsvariabler med parsade värden från konfigurationsfilen. Detta säkerställer att alla nödvändiga beroenden finns när instansen av den här klassen skapas och underlättar skrivning av testkod i framtiden.

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

    Vi kan använda properties för att hämta urin och nyckeln för vårt Azure Cosmos DB-konto och implementera cosmosClientBuilder enligt nedan:

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

    Denna implementering

    1. Hämtar urin och nyckeln från properties
    2. Kopplar dem till byggarmetoderna endpoint och key
    3. Konfigurerar dessutom nätverksanslutningen till Azure Cosmos DB-tjänsten. (I direkt läge pratar ditt klientprogram direkt till serverdelen av Azure Cosmos DB-partitionerna.)

  4. Gå tillbaka till CosmosSampleConfiguration. java och hitta getDatabaseName-metoden:

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

    Ändra standardreturvärdet till "Users", namnet på din databas. På så sätt ansluter Spring Data till databasen *Användare den ansluter automatiskt till Azure Cosmos DB vid starten.

  5. Navigera till WebCustomer. java. Du ser att WebCustomer-klassen föregås av en @Container-kommentar:

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

    @Container tar två argument:

    • containerName: Namnet på Azure Cosmos DB-containern (WebCustomers)
    • ru: Det etablerade dataflödet i containern. 400 RU/s är en bra standard för en Microsoft Learn-övning.

    Anpassa @Container för ditt användningsfall som du ser här:

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

  6. I det här läget konfigureras ditt Spring Data-projekt för att interagera med Azure Cosmos DB. Därefter kompilerar och kör du Hello World. Gå till src/main/java/com/azure/cosmos/examples/springexamples och öppna CosmosSample.java, som är en mall för Spring Data-programmet som vi ska utveckla. Den bör se ut ungefär så här:

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

    I befintligt skick implementerar programkoden en enkel variant av Hello World.

  7. Om din IDE erbjuder verktyg för att skapa och köra ditt Maven-program: Skapa och köra ditt program med hjälp av IDE och bekräfta att programmet loggar Hello World till terminalen.

  8. Om du använder terminalen för att skapa och köra ditt Maven-program: Använd följande kommando för att skapa Maven-projektet:

    mvn clean package

    Kör sedan:

    mvn spring-boot:run

    Bekräfta att programmet loggar följande utdata till terminalen, bland all annan utdata:

    INFO: Hello World.

I den här lektionen har du skapat grunden till ditt Java-program för Azure Cosmos DB. Du har anpassat Maven-programmet och utökat ett grundläggande ”Hello World”-projekt för att ansluta till en Azure Cosmos DB-slutpunkt.