Komma åt data med Azure Cosmos DB NoSQL API

Den här artikeln visar hur du lägger till Spring Cloud Azure Starter för Spring Data för Azure Cosmos DB i ett anpassat program. Med den här startprogrammet kan du lagra data i och hämta data från din Azure Cosmos DB-databas med hjälp av Spring Data och Azure Cosmos DB för NoSQL. Artikeln börjar med att visa hur du skapar en Azure Cosmos DB via Azure-portalen. Sedan visar artikeln hur du använder Spring Initializr för att skapa ett anpassat Spring Boot-program som du kan använda med Spring Boot Starter.

Azure Cosmos DB är en globalt distribuerad databastjänst som gör att utvecklare kan arbeta med data med hjälp av olika standard-API:er, till exempel SQL, MongoDB, Graph och Tabell-API:er. Med Microsofts Spring Boot Starter kan utvecklare använda Spring Boot-program som enkelt kan integreras med Azure Cosmos DB för NoSQL.

Förutsättningar

• En Azure-prenumeration – skapa en kostnadsfritt.

• Java Development Kit (JDK), version 8 eller senare.

• Apache Maven.

• Azure CLI.

Skapa en Azure Cosmos DB med hjälp av Azure Portal

Använd följande steg för att skapa en Azure Cosmos DB-instans:

1. Bläddra till Azure-portalen och välj Skapa en resurs.

2. Välj Databaser och sedan Azure Cosmos DB.

3. På skärmen Skapa ett Azure Cosmos DB-konto väljer du Azure Cosmos DB för NoSQL.

   

4. På sidan Azure Cosmos DB anger du följande information:

   • Välj den Prenumeration som du vill använda för din databas.
   • Ange om du vill skapa en ny Resursgrupp för din databas, eller använda en befintlig resursgrupp.
   • Ange ett unikt kontonamn som du använder som URI för databasen. Exempel: contosoaccounttest.
   • Ange Plats för databasen.
   • Välj Tillämpa rabatt på den kostnadsfria nivån om du bara vill skapa ett konto i demonstrationssyfte.
   • Låt resten av standardalternativen och inställningarna vara kvar.

5. Välj Granska + skapa, granska dina specifikationer och välj Skapa.

   

6. När databasen har skapats visas den på Din Azure-instrumentpanel och under sidorna Alla resurser och Azure Cosmos DB. Information om hur du skapar en databas och en container för en nyligen skapad Azure Cosmos DB finns i avsnittet Lägg till en databas och en container i Snabbstart: Skapa ett Azure Cosmos DB-konto, en databas, en container och objekt från Azure-portalen. Du kan välja din databas för någon av dessa platser för att öppna egenskapssidan för cachen.

7. När egenskapssidan för databasen visas väljer du Nycklar och kopierar din URI och åtkomstnycklar för databasen. Du använder dessa värden i ditt Spring Boot-program.

   

Viktigt!

I din nyligen skapade Azure Cosmos DB tilldelar du Owner rollen till det Azure-konto som du använder för närvarande. Mer information finns i Tilldela Azure-roller med Azure-portalen.

Skapa ett Spring Boot-program med Spring Initializr

Följ dessa steg för att skapa ett nytt projekt för Spring Boot-programprojektet med Azure-support. Alternativt kan du använda spring-cloud-azure-data-cosmos-sample-sample på lagringsplatsen azure-spring-boot-samples . Sedan kan du gå direkt till Bygga och testa din app.

1. Bläddra till https://start.spring.io/.

2. Ange följande alternativ:

   • Generera ett Maven-projekt med Java.
   • Ange din Spring Boot-version till 2.7.11.
   • Ange namnen för Group (Grupp) och Artifact (Artefakt) för ditt program.
   • Välj 17 för Java-versionen.
   • Lägg till Azure-support i beroendena.

   Kommentar

   Spring Initializr använder namnen Grupp och Artefakt för att skapa paketnamnet, till exempel: com.example.wingtiptoysdata.

   Versionen av Spring Boot kan vara högre än den version som stöds av Azure Support. När projektet har genererats automatiskt kan du manuellt ändra Spring Boot-versionen till den högsta version som stöds av Azure, som du hittar i Spring-Versions-Mapping.

3. När du har angett alternativen som angavs tidigare väljer du GENERERA.

4. När du uppmanas laddar du ned projektet till en sökväg på den lokala datorn och extraherar filerna.

Ditt vanliga Spring Boot-program är nu klart för redigering.

Konfigurera ditt Spring Boot-program för att använda Azure Spring Boot Starter

1. Leta upp filen pom.xml i appens katalog, till exempel:

   C:\SpringBoot\wingtiptoysdata\pom.xml

   -eller-

   /users/example/home/wingtiptoysdata/pom.xml

2. Öppna pom.xml-filen i en textredigerare och lägg till följande till <dependencies>-elementet:

   <dependency>
     <groupId>com.azure.spring</groupId>
     <artifactId>spring-cloud-azure-starter-data-cosmos</artifactId>
   </dependency>
   

   Kommentar

   Mer information om hur du hanterar Spring Cloud Azure-biblioteksversioner med hjälp av en strukturliste (BOM) finns i avsnittet Komma igång i utvecklarguiden för Spring Cloud Azure.

3. Spara och stäng filen pom.xml.

Konfigurera ditt Spring Boot-program för att använda din Azure Cosmos DB

1. Leta upp filen application.properties i katalogen Resurser i appen, till exempel:

   C:\SpringBoot\wingtiptoysdata\src\main\resources\application.properties

   -eller-

   /users/example/home/wingtiptoysdata/src/main/resources/application.properties

2. Öppna filen application.properties i en textredigerare och lägg till följande rader i filen och ersätt exempelvärden med lämpliga värden från tidigare egenskaper för din databas:

   # Specify the DNS URI of your Azure Cosmos DB.
   spring.cloud.azure.cosmos.endpoint=https://contosoaccounttest.documents.azure.com:443/
   
   # Specify the name of your database.
   spring.cloud.azure.cosmos.database=contosoaccounttest
   spring.cloud.azure.cosmos.populate-query-metrics=true
   

3. Spara och stäng filen application.properties.

Lägg till exempelkod för att implementera grundläggande databasfunktioner

I det här avsnittet skapar du två Java-klasser för att lagra användardata. Sedan ändrar du huvudprogramklassen för att skapa en instans av User klassen och spara den i databasen.

Definiera en basklass för lagring av användardata

1. Skapa en ny fil med namnet User.java i samma katalog som din huvudprogram-java-fil.

2. Öppna User.java-filen i ett redigeringsprogram och lägg till följande rader i filen för att definiera en generisk användarklass som lagrar och hämtar värden i databasen:

   package com.example.wingtiptoysdata;
   
   import com.azure.spring.data.cosmos.core.mapping.Container;
   import com.azure.spring.data.cosmos.core.mapping.PartitionKey;
   import org.springframework.data.annotation.Id;
   
   @Container(containerName = "mycollection")
   public class User {
       @Id
       private String id;
       private String firstName;
       @PartitionKey
       private String lastName;
       private String address;
   
       public User() {
   
       }
   
       public User(String id, String firstName, String lastName, String address) {
           this.id = id;
           this.firstName = firstName;
           this.lastName = lastName;
           this.address = address;
       }
   
       public String getId() {
           return id;
       }
   
       public void setId(String id) {
           this.id = id;
       }
   
       public String getFirstName() {
           return firstName;
       }
   
       public void setFirstName(String firstName) {
           this.firstName = firstName;
       }
   
       public String getLastName() {
           return lastName;
       }
   
       public void setLastName(String lastName) {
           this.lastName = lastName;
       }
   
       public String getAddress() {
           return address;
       }
   
       public void setAddress(String address) {
           this.address = address;
       }
   
       @Override
       public String toString() {
           return String.format("%s %s, %s", firstName, lastName, address);
       }
   }
   

3. Spara och stäng User.java-filen.

Definiera ett datalagringsgränssnitt

1. Skapa en ny fil med namnet UserRepository.java i samma katalog som din huvudprogram-java-fil.

2. Öppna UserRepository. java-filen i ett redigeringsprogram och lägg till följande rader i filen för att definiera ett användarlagringsgränssnitt som utökar standardgränssnittet för ReactiveCosmosRepository:

   package com.example.wingtiptoysdata;
   
   import com.azure.spring.data.cosmos.repository.ReactiveCosmosRepository;
   import org.springframework.stereotype.Repository;
   import reactor.core.publisher.Flux;
   
   @Repository
   public interface UserRepository extends ReactiveCosmosRepository<User, String> {
       Flux<User> findByFirstName(String firstName);
   }
   

   ReactiveCosmosRepository-gränssnittet ersätter DocumentDbRepository-gränssnittet från den tidigare versionen av startprogrammet. Det nya gränssnittet innehåller synkrona och återaktiverade API:er för grundläggande åtgärder för att spara, ta bort och hitta.

3. Spara och stäng UserRepository.java-filen.

Modifiera programmets huvudklass

1. Leta upp huvudprogrammets Java-fil i paketkatalogen i programmet, till exempel:

   C:\SpringBoot\wingtiptoysdata\src\main\java\com\example\wingtiptoysdata\WingtiptoysdataApplication.java

   -eller-

   /users/example/home/wingtiptoysdata/src/main/java/com/example/wingtiptoysdata/WingtiptoysdataApplication.java

2. Öppna huvudprogrammets Java-fil i ett redigeringsprogram och lägg till följande rader i filen:

   package com.example.wingtiptoysdata;
   
   import org.springframework.boot.SpringApplication;
   import org.springframework.boot.autoconfigure.SpringBootApplication;
   
   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.boot.CommandLineRunner;
   import org.springframework.util.Assert;
   import reactor.core.publisher.Flux;
   import reactor.core.publisher.Mono;
   
   import java.util.Optional;
   
   @SpringBootApplication
   public class WingtiptoysdataApplication implements CommandLineRunner {
   
       private static final Logger LOGGER = LoggerFactory.getLogger(WingtiptoysdataApplication.class);
   
       @Autowired
       private UserRepository repository;
   
       public static void main(String[] args) {
           SpringApplication.run(WingtiptoysdataApplication.class, args);
       }
   
       public void run(String... var1) {
           this.repository.deleteAll().block();
           LOGGER.info("Deleted all data in container.");
   
           final User testUser = new User("testId", "testFirstName", "testLastName", "test address line one");
   
           // Save the User class to Azure Cosmos DB database.
           final Mono<User> saveUserMono = repository.save(testUser);
   
           final Flux<User> firstNameUserFlux = repository.findByFirstName("testFirstName");
   
           //  Nothing happens until we subscribe to these Monos.
           //  findById won't return the user as user isn't present.
           final Mono<User> findByIdMono = repository.findById(testUser.getId());
           final User findByIdUser = findByIdMono.block();
           Assert.isNull(findByIdUser, "User must be null");
   
           final User savedUser = saveUserMono.block();
           Assert.state(savedUser != null, "Saved user must not be null");
           Assert.state(savedUser.getFirstName().equals(testUser.getFirstName()), "Saved user first name doesn't match");
   
           firstNameUserFlux.collectList().block();
   
           final Optional<User> optionalUserResult = repository.findById(testUser.getId()).blockOptional();
           Assert.isTrue(optionalUserResult.isPresent(), "Cannot find user.");
   
           final User result = optionalUserResult.get();
           Assert.state(result.getFirstName().equals(testUser.getFirstName()), "query result firstName doesn't match!");
           Assert.state(result.getLastName().equals(testUser.getLastName()), "query result lastName doesn't match!");
   
           LOGGER.info("findOne in User collection get result: {}", result.toString());
       }
   }
   

3. Spara och stäng programmets Java-huvudfil.

Kompilera och testa din app

1. Öppna en kommandotolk och navigera till mappen där pom.xml-filen finns, till exempel:

   cd C:\SpringBoot\wingtiptoysdata

   -eller-

   cd /users/example/home/wingtiptoysdata

2. Använd följande kommando för att skapa och köra ditt program:

   ./mvnw clean
   

   Det här kommandot kör programmet automatiskt som en del av testfasen. Du kan även använda:

   ./mvnw spring-boot:run
   

   Efter några bygg- och testutdata visar konsolfönstret ett meddelande som liknar följande exempel:

   INFO 1365 --- [           main] c.e.w.WingtiptoysdataApplication         : Deleted all data in container.
   
   ... (omitting connection and diagnostics output) ...
   
   INFO 1365 --- [           main] c.e.w.WingtiptoysdataApplication         : findOne in User collection get result: testFirstName testLastName, test address line one
   

   Dessa utdatameddelanden anger att data har sparats till Azure Cosmos DB och sedan hämtats igen.

Rensa resurser

Om du inte kommer att fortsätta att använda det här programmet måste du ta bort resursgruppen som innehåller Azure Cosmos DB som du skapade tidigare. Du kan ta bort resursgruppen från Azure-portalen.

Nästa steg

Om du vill veta mer om Spring och Azure kan du fortsätta till dokumentationscentret för Spring i Azure.

Spring på Azure

Fler resurser

Mer information om hur du använder Azure Cosmos DB och Java finns i följande artiklar:

• Dokumentation om Azure Cosmos DB.

• Azure Cosmos DB: Skapa en dokumentdatabas med Java och Azure-portalen

• Spring Data för Azure Cosmos DB

Mer information om hur du använder Spring Boot-program på Azure finns i följande artiklar:

• [Spring Cloud Azure Starter för Spring Data Azure Cosmos DB]

• Distribuera ett Spring Boot-program till Linux i Azure App Service

• Köra ett Spring Boot-program i ett Kubernetes-kluster i Azure Container Service

Mer information om hur du använder Azure med Java finns i Azure för Java-utvecklare och Arbeta med Azure DevOps och Java.

Spring Framework är en lösning med öppen källkod som hjälper Java-utvecklare att skapa appar på företagsnivå. Ett av de mer populära projekten som bygger på plattformen är Spring Boot, som är ett enkelt sätt att skapa fristående Java-program. Det finns flera exempel på Spring Boot-paket på https://github.com/spring-guides/ som hjälper utvecklare att komma igång med Spring Boot. Förutom att välja från en lista med grundläggande Spring Boot-projekt hjälper Spring Initializr utvecklare att komma igång med att skapa anpassade Spring Boot-program.