Adatok elérése az Azure Cosmos DB NoSQL API-val

Ez a cikk bemutatja, hogyan adhatja hozzá a Spring Cloud Azure Starter for Spring Data for Azure Cosmos DB-t egy egyéni alkalmazáshoz. Ezzel az indítással adatokat tárolhat és lekérhet az Azure Cosmos DB-adatbázisból a Spring Data és az Azure Cosmos DB for NoSQL használatával. A cikk első lépéseként bemutatja, hogyan hozhat létre Azure Cosmos DB-t az Azure Portalon keresztül. Ezután a cikk bemutatja, hogyan hozhat létre egyéni Spring Boot-alkalmazást a Spring Boot Starter használatával.

Az Azure Cosmos DB egy globálisan elosztott adatbázis-szolgáltatás, amely lehetővé teszi a fejlesztők számára, hogy különböző szabványos API-k, például SQL, MongoDB, Graph és Table API-k használatával dolgozzanak az adatokkal. A Microsoft Spring Boot Starter lehetővé teszi a fejlesztők számára, hogy olyan Spring Boot-alkalmazásokat használjanak, amelyek könnyen integrálhatók az Azure Cosmos DB for NoSQL-hez.

Előfeltételek

• Azure-előfizetés – hozzon létre egyet ingyenesen.

• Java Development Kit (JDK), 8-es vagy újabb verzió.

• Apache Maven.

• Azure parancssori felület (CLI).

Azure Cosmos DB-adatbázis létrehozása az Azure Portalon

Azure Cosmos DB-példány létrehozásához kövesse az alábbi lépéseket:

1. Keresse meg az Azure Portalt, és válassza az Erőforrás létrehozása lehetőséget.

2. Válassza az Adatbázisok, majd az Azure Cosmos DB elemet.

3. Az Azure Cosmos DB-fiók létrehozása képernyőn válassza az Azure Cosmos DB for NoSQL lehetőséget.

   

4. Az Azure Cosmos DB lapon adja meg a következő információkat:

   • Válassza ki az adatbázishoz használni kívánt Előfizetést.
   • Adja meg, hogy egy új Erőforráscsoportot szeretne létrehozni az adatbázishoz, vagy inkább egy meglévőt választ.
   • Adjon meg egy egyedi fióknevet, amelyet az adatbázis URI-jaként használ. Például: contosoaccounttest.
   • Adja meg az adatbázis Helyét.
   • Válassza az Ingyenes szint kedvezmény alkalmazása lehetőséget, ha csak bemutató célú fiókot szeretne létrehozni.
   • Hagyja meg az alapértelmezett beállításokat és beállításokat.

5. Válassza a Véleményezés + létrehozás lehetőséget, tekintse át a specifikációkat, és válassza a Létrehozás lehetőséget.

   

6. Az adatbázis létrehozásakor megjelenik az Azure Irányítópulton, valamint a Minden erőforrás és az Azure Cosmos DB lapon. Ha egy újonnan létrehozott Azure Cosmos DB-hez szeretne adatbázist és tárolót létrehozni, olvassa el az Azure Cosmos DB-fiók, -adatbázis, -tároló és -elemek Azure Portalról való létrehozását ismertető rövid útmutató adatbázis és tároló szakaszát. Bármelyik helyhez kiválaszthatja az adatbázist a gyorsítótár tulajdonságok lapjának megnyitásához.

7. Amikor megjelenik az adatbázis tulajdonságok lapja, válassza a Kulcsok lehetőséget, majd másolja ki az adatbázis URI-ját és hozzáférési kulcsait. Ezeket az értékeket a Spring Boot-alkalmazásban használja.

   

Fontos

Az újonnan létrehozott Azure Cosmos DB-ben rendelje hozzá a Owner szerepkört a jelenleg használt Azure-fiókhoz. További információ: Azure-szerepkörök hozzárendelése a Azure Portal.

Spring Boot-alkalmazás létrehozása a Spring Initializrrel

A következő lépésekkel hozhat létre egy új Spring Boot-alkalmazásprojektet az Azure-támogatással. Alternatív megoldásként használhatja a spring-cloud-azure-data-cosmos-sample mintát az azure-spring-boot-samples adattárban. Ezután közvetlenül Az alkalmazás összeállítása és tesztelése szakaszra ugorhat.

1. Nyissa meg a következő címet: https://start.spring.io/.

2. Adja meg a következő beállításokat:

   • Hozzon létre egy Maven projektet Javával.
   • Adja meg a Spring Boot-verziót a 2.7.11-es verzióra.
   • Adja meg az alkalmazáshoz tartozó Group (Csoport) és Artifact (Összetevő) neveket.
   • A Java-verzióhoz válassza a 17-es lehetőséget.
   • Vegye fel az Azure-támogatást a függőségekbe.

   Feljegyzés

   A Spring Initializr a Csoport és az Összetevő neveket használja a csomagnév létrehozásához, például: com.example.wingtiptoysdata.

   A Spring Boot verziója magasabb lehet, mint az Azure-támogatás által támogatott verzió. A projekt automatikus létrehozása után manuálisan módosíthatja a Spring Boot-verziót az Azure által támogatott legmagasabb verzióra, amelyet a Spring-Versions-Mappingben talál.

3. Ha megadta a korábban felsorolt beállításokat, válassza a GENERATE lehetőséget.

4. Ha a rendszer kéri, töltse le a projektet a helyi számítógépre, és bontsa ki a fájlokat.

Az egyszerű Spring Boot-alkalmazás most már készen áll a szerkesztésre.

A Spring Boot-alkalmazás konfigurálása az Azure Spring Boot Starter használatára

1. Keresse meg a pom.xml fájlt az alkalmazás könyvtárában; példa:

   C:\SpringBoot\wingtiptoysdata\pom.xml

   -vagy-

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

2. Nyissa meg a pom.xml fájlt egy szövegszerkesztőben, és adja hozzá a következő kódot a <dependencies> elemhez:

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

   Feljegyzés

   A Spring Cloud Azure-kódtár verzióinak anyagjegyzék (BOM) használatával történő kezelésével kapcsolatos további információkért tekintse meg a Spring Cloud Azure fejlesztői útmutatójának Első lépések szakaszát.

3. Mentse és zárja be a pom.xml fájlt.

A Spring Boot-alkalmazás konfigurálása az Azure Cosmos DB-adatbázis használatára

1. Keresse meg az application.properties fájlt az alkalmazás resources könyvtárában; példa:

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

   -vagy-

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

2. Nyissa meg az application.properties fájlt egy szövegszerkesztőben, adja hozzá a következő sorokat, majd cserélje a mintaértékeket az adatbázis megfelelő tulajdonságaira:

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

3. Mentse és zárja be az application.properties fájlt.

Mintakód hozzáadása az alapszintű adatbázis-funkciók megvalósításához

Ebben a szakaszban két Java-osztályt hoz létre a felhasználói adatok tárolásához. Ezután módosíthatja a fő alkalmazásosztályt, hogy létrehozza az User osztály egy példányát, és mentse az adatbázisba.

Alaposztály definiálása a felhasználói adatok tárolásához

1. Hozzon létre egy User.java nevű új fájlt ugyanabban a könyvtárban, amelyben a fő Java-alkalmazásfájl is található.

2. Nyissa meg a User.java fájlt egy szövegszerkesztőben, és adja hozzá a következő sorokat a fájlhoz egy általános felhasználói osztály definiálásához, amely az adatbázisban tárolja és lekéri abból az értékeket:

   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. Mentse és zárja be a User.java fájlt.

Adattárinterfész definiálása

1. Hozzon létre egy UserRepository.java nevű új fájlt ugyanabban a könyvtárban, amelyben a fő Java-alkalmazásfájl is található.

2. Nyissa meg a UserRepository.java fájlt egy szövegszerkesztőben, és adja hozzá a következő sorokat a fájlhoz a felhasználói adattár interfészének definiálásához, amely az alapértelmezett ReactiveCosmosRepository interfészt bővíti ki:

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

   A ReactiveCosmosRepository interfész az indító előző verziójában szereplő DocumentDbRepository interfészt váltja fel. Az új interfész az alapszintű mentési, törlési és keresési műveletekhez biztosít szinkron és reaktív típusú API-kat.

3. Mentse és zárja be a UserRepository.java fájlt.

A fő alkalmazásosztály módosítása

1. Keresse meg a fő Java-alkalmazásfájlt az alkalmazás csomagkönyvtárában. Példa:

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

   -vagy-

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

2. Nyissa meg a fő Java-alkalmazásfájlt egy szövegszerkesztőben, és adja hozzá a következő sorokat:

   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. Mentse és zárja be a fő Java-alkalmazásfájlt.

Az alkalmazás összeállítása és tesztelése

1. Nyisson meg egy parancssort, és lépjen a címtár azon mappájába, amelyben a pom.xml fájl található. Példa:

   cd C:\SpringBoot\wingtiptoysdata

   -vagy-

   cd /users/example/home/wingtiptoysdata

2. Az alábbi paranccsal állíthatja össze és futtathatja az alkalmazást:

   ./mvnw clean
   

   Ez a parancs automatikusan futtatja az alkalmazást a tesztelési fázis részeként. Használhatja a következőt is:

   ./mvnw spring-boot:run
   

   Néhány buildelési és tesztelési kimenet után a konzolablak az alábbi példához hasonló üzenetet jelenít meg:

   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
   

   Ezek a kimeneti üzenetek azt jelzik, hogy az adatokat sikeresen mentették az Azure Cosmos DB-be, majd ismét lekérték.

Az erőforrások eltávolítása

Ha nem fogja tovább használni ezt az alkalmazást, mindenképpen törölje a korábban létrehozott Azure Cosmos DB-t tartalmazó erőforráscsoportot. Az erőforráscsoportot törölheti az Azure Portalról.

Következő lépések

Ha szeretne többet megtudni a Spring és az Azure szolgáltatásról, lépjen tovább a Spring on Azure dokumentációs központra.

A Spring használata az Azure-ban

További erőforrások

További információ az Azure Cosmos DB és a Java használatával kapcsolatban:

• Azure Cosmos DB-dokumentáció.

• Azure Cosmos DB: Dokumentum-adatbázis létrehozása a Java és az Azure Portal használatával

• Azure Cosmos DB-hez készült Spring Data

A Spring Boot-alkalmazások Azure-beli használatával kapcsolatban további információt az alábbi cikkben olvashat:

• [Spring Cloud Azure Starter for Spring Data Azure Cosmos DB]

• Spring Boot-alkalmazás üzembe helyezése Linuxon Azure-alkalmazás szolgáltatáson

• Spring Boot-alkalmazás futtatása Kubernetes-fürtön az Azure Container Service-ben

Az Azure a Javával való együttes használatáról további információt az Azure Java-fejlesztőknek és Az Azure DevOps és a Java használata című cikkben találhat.

A Spring Framework egy nyílt forráskódú megoldás, amellyel Java-fejlesztők nagyvállalati szintű alkalmazásokat hozhatnak létre. A platformra épülő népszerűbb projektek egyike a Spring Boot, amely egyszerűbbé teszi a különálló Java-alkalmazások létrehozását. A Spring Boot használatának megkezdéséhez a fejlesztők segítségére lehetnek a mintául szolgáló Spring Boot-csomagok, amelyek itt érhetők el: https://github.com/spring-guides/. Az alapszintű Spring Boot-projektek kiválasztásán kívül a Spring Initializr is segíti a fejlesztőket egyéni Spring Boot-alkalmazások létrehozásában.