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 az egyéni alkalmazásához. 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 használhatja Spring Initializr egy egyéni Spring Boot-alkalmazás létrehozásához, amelyet a Spring Boot Starter használatával használhat.

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 ingyen.
Java Development Kit (JDK), 8-os vagy újabb verzió.
Apache Maven.
Azure parancssori felület (CLI).

Azure Cosmos DB létrehozása az Azure Portal használatával

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

Keresse meg az Azure Portal, és válassza Erőforrás létrehozásalehetőséget.
Válassza a Adatbázisoklehetőséget, majd válassza az Azure Cosmos DBlehetőséget.
Az Azure Cosmos DB-fiók létrehozása képernyőn válassza Azure Cosmos DB for NoSQLlehetőséget.
Az Azure Cosmos DB lapján adja meg a következő adatokat:
- Válassza ki a előfizetési, amelyet az adatbázisához használni szeretne.
- Megadhatja, hogy létrehoz-e új erőforráscsoportot az adatbázishoz, vagy válasszon egy meglévő erőforráscsoportot.
- 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 a többi alapértelmezett opciót és beállítást változatlanul.
Válassza a Áttekintés + létrehozáslehetőséget, tekintse át a specifikációkat, és válassza a létrehozása lehetőséget.
Az adatbázis létrehozásakor megjelenik az Azure Irányítópult, valamint az Minden erőforrás és Azure Cosmos DB lapon. Ha adatbázist és tárolót szeretne létrehozni egy újonnan létrehozott Azure Cosmos DB-hez, olvassa el az gyorsútmutató Adatbázis és tároló hozzáadása szakaszát: Azure Cosmos DB-fiók, adatbázis, tároló és elemek létrehozása az Azure Portal. Bármelyik helyhez kiválaszthatja az adatbázist a gyorsítótár tulajdonságok lapjának megnyitásához.
Amikor megjelenik az adatbázis tulajdonságok lapja, válassza Kulcsok lehetőséget, és másolja ki az adatbázis URI- é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 az Azure Portalhasználatával.

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

Az alábbi lépésekkel hozzon létre egy új Spring Boot-alkalmazásprojektet az Azure támogatásával. 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 ugorhat az alkalmazás összeállításához és teszteléséhez.

Keressen a https://start.spring.io/-ra.
Adja meg a következő beállításokat:
- Maven-projekt létrehozása Java-.
- Adja meg a Spring Boot verzióját a 2.7.11.
- Adja meg az alkalmazás Csoport és Artifakt nevét.
- A Java-verzióhoz válassza 17.
- Adjon hozzá Azure-támogatást a függőségekhez.
Jegyzet

A Spring Initializr a Csoport és Összetevő nevét 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 Spring-Versions-Mappingtalál.
Ha megadta a korábban felsorolt beállításokat, válassza a GENERATElehetőséget.
Amikor a rendszer kéri, töltse le a projektet a helyi számítógépen található elérési útra, és bontsa ki a fájlokat.

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

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

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

C:\SpringBoot\wingtiptoysdata\pom.xml

-vagy-

/users/example/home/wingtiptoysdata/pom.xml
Nyissa meg a pom.xml fájlt egy szövegszerkesztőben, és adja hozzá a következőket a <dependencies> elemhez:
```
<dependency>
  <groupId>com.azure.spring</groupId>
  <artifactId>spring-cloud-azure-starter-data-cosmos</artifactId>
</dependency>
```
Jegyzet

A Spring Cloud Azure-kódtár verzióinak anyagjegyzék (BOM) használatával történő kezeléséről a Spring Cloud Azure fejlesztői útmutatójának Első lépésekcímű szakaszában olvashat.
Mentse és zárja be a pom.xml fájlt.

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

Keresse meg az application.properties fájlt az alkalmazás erőforrásainak könyvtárában; például:

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

-vagy-

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

Nyissa meg a application.properties fájlt egy szövegszerkesztőben, és adja hozzá a következő sorokat a fájlhoz, és cserélje le 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

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

Mintakód hozzáadása az alapszintű adatbázis-funkciók implementálá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ítsa a fő alkalmazásosztályt úgy, hogy létrehozza a 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

Hozzon létre egy User.java nevű új fájlt a fő alkalmazás Java-fájljának könyvtárában.

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 kéri le 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);
    }
}

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

Adatadattár-felület definiálása

Hozzon létre egy UserRepository.java nevű új fájlt ugyanabban a könyvtárban, mint a fő alkalmazás Java-fájlja.
Nyissa meg a UserRepository.java fájlt egy szövegszerkesztőben, és adja hozzá a következő sorokat a fájlhoz egy felhasználói adattár felületének meghatározásához, amely kibővíti az alapértelmezett ReactiveCosmosRepository felületet:
```
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 felület lecseréli a DocumentDbRepository felületet az indítás előző verziójáról. Az új felület szinkron és reaktív API-kat biztosít az alapvető mentési, törlési és keresési műveletekhez.
Mentse és zárja be a UserRepository.java fájlt.

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

Keresse meg a fő alkalmazás Java-fájlját az alkalmazás csomagkönyvtárában, például:

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

-vagy-

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

Nyissa meg a fő alkalmazás Java-fájlát egy szövegszerkesztőben, és adja hozzá a következő sorokat a fájlhoz:

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

Mentse és zárja be a fő alkalmazás Java-fájlját.

Az alkalmazás létrehozása és tesztelése

Nyisson meg egy parancssort, és lépjen arra a mappára, amelyben a pom.xml fájl található; például:

cd C:\SpringBoot\wingtiptoysdata

-vagy-

cd /users/example/home/wingtiptoysdata
Az alkalmazás létrehozásához és futtatásához használja a következő parancsot:
```
./mvnw clean
```
Ez a parancs automatikusan futtatja az alkalmazást a tesztelési fázis részeként. A következőket is használhatja:
```
./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.

Erőforrások törlése

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 többet szeretne megtudni a Springről és az Azure-ról, lépjen tovább a Spring on Azure dokumentációs központjába.

Tavasz az Azure-on

További erőforrások

Az Azure Cosmos DB és a Java használatával kapcsolatos további információkért tekintse meg az alábbi cikkeket:

A Spring Boot-alkalmazások Azure-beli használatáról az alábbi cikkekben talál további információt:

A "Spring Cloud Azure kezdőcsomag a Spring Data Azure Cosmos DB-hez"
Spring Boot-alkalmazás üzembe helyezése Linuxon az Azure App Service
Spring Boot-alkalmazás futtatása Kubernetes-fürtön az Azure Container Service-ben

Az Azure és Java integrációjáról további információkért tekintse meg az "Azure for Java Fejlesztőknek" () és a "Munka az Azure DevOps-szal és Javával" () című cikkeket.

A Spring Framework egy nyílt forráskódú megoldás, amely segít a Java-fejlesztőknek nagyvállalati szintű alkalmazások létrehozásában. A platformra épülő egyik népszerűbb projekt a Spring Boot, amely leegyszerűsíti a különálló Java-alkalmazások létrehozását. A fejlesztőknek a Spring Boot használatának megkezdéséhez számos minta Spring Boot-csomag érhető el a https://github.com/spring-guides/. Az alapszintű Spring Boot-projektek listájának kiválasztása mellett a Spring Initializr segít a fejlesztőknek az egyéni Spring Boot-alkalmazások létrehozásának megkezdésében.

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2025-08-19