Teilen über

Zugreifen auf Daten mit der Azure Cosmos DB NoSQL-API

  • Artikel

In diesem Artikel erfahren Sie, wie Sie der Spring Cloud Azure Starter für Spring Data für Azure Cosmos DB zu einer benutzerdefinierten Anwendung hinzufügen. Mit diesem Start können Sie Daten in Ihrer Azure Cosmos DB-Datenbank mithilfe von Spring Data und Azure Cosmos DB für NoSQL speichern und abrufen. Der Artikel zeigt Ihnen zunächst, wie Sie über die Azure-Portal eine Azure Cosmos DB erstellen. Anschließend wird in dem Artikel gezeigt, wie Sie spring Initializr verwenden, um eine benutzerdefinierte Spring Boot-Anwendung zu erstellen, die Sie mit dem Spring Boot Starter verwenden können.

Azure Cosmos DB ist ein global verteilter Datenbankdienst, der Entwicklern durch eine Vielzahl von Standard-APIs wie der SQL-, MongoDB-, Graph- und Tabellen-API die Arbeit mit Daten ermöglicht. Der Spring Boot Starter von Microsoft ermöglicht Entwicklern die Verwendung von Spring Boot-Anwendungen, die problemlos in Azure Cosmos DB für NoSQL integriert werden können.

Voraussetzungen

Erstellen einer Azure Cosmos DB-Instanz mithilfe des Azure-Portals

Führen Sie die folgenden Schritte aus, um eine Azure Cosmos DB-Instanz zu erstellen:

  1. Navigieren Sie zum Azure-Portal, und wählen Sie "Ressource erstellen" aus.

  2. Wählen Sie Datenbanken und anschließend Azure Cosmos DB aus.

  3. Wählen Sie auf dem Bildschirm "Azure Cosmos DB-Konto erstellen" Azure Cosmos DB für NoSQL aus.

    Screenshot der Azure-Portal, auf der die Seite

  4. Geben Sie auf der Seite Azure Cosmos DB die folgenden Informationen ein:

    • Wählen Sie das Abonnement, das Sie für Ihre Datenbank verwenden möchten.
    • Legen Sie fest, ob eine neue Ressourcengruppe für Ihre Datenbank erstellt werden soll, oder wählen Sie eine vorhandene Ressourcengruppe aus.
    • Geben Sie einen eindeutigen Kontonamen ein, den Sie als URI für Ihre Datenbank verwenden. Beispiel: contosoaccounttest.
    • Geben Sie den Speicherort für Ihre Datenbank an.
    • Wählen Sie "Kostenloser Preisnachlass anwenden" aus, wenn Sie nur ein Konto für Demonstrationszwecke erstellen möchten.
    • Lassen Sie die restlichen Standardoptionen und -einstellungen wie folgt übrig.

  5. Wählen Sie "Überprüfen" und "Erstellen" aus, überprüfen Sie Ihre Spezifikationen, und wählen Sie "Erstellen" aus.

    Screenshot der Azure-Portal, die die Seite

  6. Wenn Ihre Datenbank erstellt wurde, wird sie auf Ihrem Azure-Dashboard und auf den Seiten "Alle Ressourcen" und "Azure Cosmos DB" aufgeführt. Informationen zum Erstellen einer Datenbank und eines Containers für eine neu erstellte Azure Cosmos DB finden Sie im Abschnitt "Hinzufügen einer Datenbank und eines Containers" der Schnellstartanleitung: Erstellen eines Azure Cosmos DB-Kontos, einer Datenbank, eines Containers und von Elementen aus dem Azure-Portal. Sie können Ihre Datenbank für all diese Orte auswählen, um die Eigenschaftenseite für Ihren Cache zu öffnen.

  7. Wenn die Eigenschaftenseite für Ihre Datenbank angezeigt wird, wählen Sie "Schlüssel " aus, und kopieren Sie Ihren URI und Die Zugriffstasten für Ihre Datenbank. Sie verwenden diese Werte in Ihrer Spring Boot-Anwendung.

    Screenshot der Azure-Portal, die das Azure Cosmos DB-Konto mit der Seite

Wichtig

Weisen Sie in Ihrer neu erstellten Azure Cosmos DB die Owner Rolle dem Azure-Konto zu, das Sie derzeit verwenden. Weitere Informationen finden Sie unter Hinzufügen oder Entfernen von Azure-Rollenzuweisungen über das Azure-Portal.

Erstellen einer Spring Boot-Anwendung mit Spring Initializr

Führen Sie die folgenden Schritte aus, um ein neues Spring Boot-Anwendungsprojekt mit Azure-Unterstützung zu erstellen. Alternativ können Sie das Beispiel "spring-cloud-azure-data-cosmos-sample " im Repository "azure-spring-boot-samples " verwenden. Anschließend können Sie direkt mit dem Erstellen und Testen der App fortfahren.

  1. Navigieren Sie zu https://start.spring.io/.

  2. Verwenden Sie die folgenden Optionen:

    • Generieren Sie ein Maven-Projekt mit Java.
    • Geben Sie Ihre Spring Boot-Version auf 2.7.11 an.
    • Geben Sie Namen für die Gruppe und das Artefakt für Ihre Anwendung an.
    • Wählen Sie 17 für die Java-Version aus.
    • Fügen Sie Azure-Support in den Abhängigkeiten hinzu.

    Hinweis

    Spring Initializr verwendet zur Erstellung des Paketnamens die Namen für Gruppe und Artefakt (also beispielsweise com.example.wintiptoysdata).

    Die Spring Boot-Version ist möglicherweise höher als die vom Azure-Support unterstützte Version. Nachdem das Projekt automatisch generiert wurde, können Sie die Spring Boot-Version manuell auf die höchste version ändern, die von Azure unterstützt wird, die Sie in Spring-Versions-Mapping finden können.

  3. Wenn Sie die zuvor aufgeführten Optionen angegeben haben, wählen Sie "GENERIEREN" aus.

  4. Laden Sie das Projekt nach entsprechender Aufforderung in einen Pfad auf dem lokalen Computer herunter, und extrahieren Sie die Dateien.

Ihre einfache Spring Boot-Anwendung ist nun bereit für die Bearbeitung.

Konfigurieren der Spring Boot-Anwendung für die Verwendung von Azure Spring Boot Starter

  1. Suchen Sie die Datei pom.xml im Verzeichnis Ihrer App. Beispiel:

    C:\SpringBoot\wingtiptoysdata\pom.xml

    Oder

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

  2. Öffnen Sie die Datei pom.xml in einem Text-Editor, und fügen Sie Folgendes zum Element <dependencies> hinzu:

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

    Hinweis

    Weitere Informationen zum Verwalten von Spring Cloud Azure-Bibliotheksversionen mithilfe einer Stückliste (BoM) finden Sie im Abschnitt "Erste Schritte " des Azure-Entwicklerhandbuchs für Spring Cloud.

  3. Speichern und schließen Sie die Datei pom.xml.

Konfigurieren der Spring Boot-Anwendung für die Verwendung von Azure Cosmos DB

  1. Suchen Sie die Datei application.properties im Ressourcen-Verzeichnis Ihrer App. Beispiel:

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

    Oder

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

  2. Öffnen Sie die Datei application.properties in einem Text-Editor, und fügen Sie die folgenden Zeilen zur Datei hinzu. Ersetzen Sie dabei die Beispielwerte durch die entsprechenden Eigenschaften für Ihre Datenbank:

    # 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. Speichern und schließen Sie die Datei application.properties.

Hinzufügen eines Beispielcodes zur Implementierung von grundlegenden Datenbankfunktionen

In diesem Abschnitt erstellen Sie zwei Java-Klassen zum Speichern von Benutzerdaten. Anschließend ändern Sie ihre Standard Anwendungsklasse, um eine Instanz der User Klasse zu erstellen und in Ihrer Datenbank zu speichern.

Definieren einer Basisklasse zum Speichern von Benutzerdaten

  1. Erstellen Sie im selben Verzeichnis wie die Java-Hauptanwendungsdatei eine neue Datei mit dem Namen User.java.

  2. Öffnen Sie in einem Text-Editor die Datei User.java, und fügen Sie die folgenden Zeilen zur Datei hinzu, um eine generische Benutzerklasse zu definieren, die Werte speichert und diese von Ihrer Datenbank abruft:

    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. Speichern und schließen Sie die Datei User.java.

Definieren einer Datenrepositoryschnittstelle

  1. Erstellen Sie im selben Verzeichnis wie die Java-Hauptanwendungsdatei eine neue Datei mit dem Namen UserRepository.java.

  2. Öffnen Sie in einem Text-Editor die Datei UserRepository.java, und fügen Sie die folgenden Zeilen zur Datei hinzu, um zur Erweiterung der standardmäßigen ReactiveCosmosRepository-Schnittstelle eine Benutzerrepositoryschnittstelle zu definieren:

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

    Die ReactiveCosmosRepository-Schnittstelle ersetzt die DocumentDbRepository-Schnittstelle aus der vorherigen Starter-Version. Die neue Schnittstelle stellt synchrone und reaktive APIs für grundlegende Speicher-, Lösch- und Suchvorgänge bereit.

  3. Speichern und schließen Sie die Datei UserRepository.java.

Ändern der Hauptanwendungsklasse

  1. Suchen Sie die Java-Hauptanwendungsdatei im Paketverzeichnis Ihrer Anwendung. Beispiel:

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

    Oder

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

  2. Öffnen Sie die Java-Hauptanwendungsdatei in einem Text-Editor, und fügen Sie die folgenden Zeilen zur Datei hinzu:

    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. Speichern und schließen Sie die Java-Hauptanwendungsdatei.

Erstellen und Testen der App

  1. Öffnen Sie eine Eingabeaufforderung, und navigieren Sie zu dem Ordner, in dem sich die Datei pom.xml befindet. Beispiel:

    cd C:\SpringBoot\wingtiptoysdata

    Oder

    cd /users/example/home/wingtiptoysdata

  2. Verwenden Sie den folgenden Befehl, um Ihre Anwendung zu erstellen und auszuführen:

    ./mvnw clean

    Dieser Befehl führt die Anwendung automatisch im Rahmen der Testphase aus. Sie können auch Folgendes verwenden:

    ./mvnw spring-boot:run

    Nach einem Build- und Testausgabe wird im Konsolenfenster eine Meldung wie im folgenden Beispiel angezeigt:

    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

    Diese Ausgabemeldungen deuten darauf hin, dass die Daten erfolgreich in Azure Cosmos DB gespeichert und dann erneut abgerufen wurden.

Bereinigen von Ressourcen

Wenn Sie diese Anwendung nicht weiterhin verwenden werden, müssen Sie die Ressourcengruppe löschen, die die zuvor erstellte Azure Cosmos DB enthält. Sie können die Ressourcengruppe aus dem Azure-Portal löschen.

Nächste Schritte

Weitere Informationen zu Spring und Azure finden Sie im Dokumentationscenter zu Spring in Azure.

Spring Framework in Azure

Weitere Ressourcen

Weitere Informationen zur Verwendung von Azure Cosmos DB und Java finden Sie in den folgenden Artikeln:

Weitere Informationen zur Verwendung von Spring Boot-Anwendungen in Azure finden Sie in den folgenden Artikeln:

Weitere Informationen zur Verwendung von Azure mit Java finden Sie unter Azure für Java-Entwickler und Working with Azure DevOps and Java (Arbeiten mit Azure DevOps und Java).

Spring Framework ist eine Open Source-Lösung, die Java-Entwickler bei der Erstellung professioneller Anwendungen unterstützt. Eines der gängigsten Projekte, das auf dieser Plattform aufbaut, ist Spring Boot. Es bietet einen vereinfachten Ansatz für das Erstellen eigenständiger Java-Anwendungen. Um Entwicklern den Einstieg in Spring Boot zu vereinfachen, werden unter https://github.com/spring-guides/ mehrere Spring Boot-Beispielpakete bereitgestellt. Neben der Auswahl einer Liste grundlegender Spring Boot-Projekte ermöglicht Spring Initializr Entwicklern einen einfacheren Einstieg bei der Erstellung von benutzerdefinierten Spring Boot-Anwendungen.