Freigeben über

Azure Spring Data Cosmos-Clientbibliothek für Java– Version 5.6.0

  • Artikel

Azure Spring Data Cosmos bietet Spring Data-Unterstützung für Azure Cosmos DB unter Verwendung der SQL-API auf der Grundlage des Spring Data-Frameworks. Azure Cosmos DB ist ein global verteilter Datenbankdienst, der Entwicklern durch eine Vielzahl von Standard-APIs wie SQL, MongoDB, Cassandra, Graph und Tabellen die Arbeit mit Daten ermöglicht.

Spring Boot-Supportrichtlinie

Dieses Projekt unterstützt mehrere Spring Boot-Versionen. Eine vollständige Liste der derzeit unterstützten Versionen finden Sie in der Spring-Versionszuordnung.

Spring Boot-Releases werden mit „Ende der Lebensdauer“ gekennzeichnet, wenn sie nicht mehr unterstützt oder in irgendeiner Form veröffentlicht werden. Wenn Sie eine EOL-Version ausführen, sollten Sie schnellstmöglich ein Upgrade durchführen.

Bitte beachten Sie, dass eine Version nicht mehr unterstützt werden kann, bevor sie als "Ende der Lebensdauer" gekennzeichnet wird. Während dieser Zeit sollten Sie nur Releases für kritische Fehler oder Sicherheitsprobleme erwarten.

Weitere Informationen zu unterstützten Spring Boot-Versionen finden Sie unter Unterstützte Spring Boot-Versionen.

Versionsunterstützung für Spring Boot

Maven-Benutzer können mittels Vererbung aus dem Projekt spring-boot-starter-parent einen Abschnitt zur Abhängigkeitsverwaltung beziehen, um Spring die Versionsverwaltung für Abhängigkeiten zu überlassen.

<!-- Inherit defaults from Spring Boot -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>${spring.boot.version}</version>
</parent>

Bei diesem Setup können Sie auch einzelne Abhängigkeiten überschreiben, indem Sie eine Eigenschaft in Ihrem eigenen Projekt überschreiben. Wenn Sie beispielsweise ein Upgrade auf einen anderen Spring Data-Releasetrain durchführen möchten, können Sie der Datei „pom.xml“ Folgendes hinzufügen:

<properties>
    <spring-data-releasetrain.version>${spring.data.version}</spring-data-releasetrain.version>
</properties>

Wenn Sie spring-boot-starter-parent nicht verwenden möchten, können Sie auch von der Abhängigkeitsverwaltung profitieren, indem Sie eine Abhängigkeit vom Typ scope=import nutzen:

<dependencyManagement>
     <dependencies>
        <dependency>
            <!-- Import dependency management from Spring Boot -->
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>${spring.boot.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

Welche Version von Azure Spring Data Cosmos sollte ich verwenden?

Zuordnung von Spring Boot / Spring Cloud-Version zu Azure Spring Data Cosmos-Versionen

Spring Boot-Version Spring Cloud-Version Azure Spring Data Cosmos-Versionen
3.0.x 2022.0.x 5.3.0 und höher
2.7.x 2021.0.x 3.23.0 und höher
2.6.x 2021.0.x 3.15.0 - 3.22.0
2.5.x 2020.0.x 3.8.0 - 3.14.0
2.4.x 2020.0.x 3.5.0 - 3.7.0

Ich verwende Spring Boot Version X

Wenn Sie Spring Boot in Ihrem Projekt verwenden, finden Sie die zugehörigen Azure Spring Data Cosmos-Versionen aus der obigen Tabelle. Beispiel: Wenn Sie Spring Boot 3.0.x verwenden, sollten Sie Die Azure Spring Data Cosmos-Versionen 5.3.0 und höher verwenden.

Ich verwende Spring Cloud Version Y

Wenn Sie Spring Cloud in Ihrem Projekt verwenden, finden Sie auch verwandte Azure Spring Data Cosmos-Versionen aus der obigen Tabelle. Wenn Sie beispielsweise Spring Cloud 2022.0.x verwenden, sollten Sie Die Azure Spring Data Cosmos-Versionen 5.3.0 und höher verwenden.

Versionsunterstützung für Spring Data

Dieses Projekt unterstützt spring-data-commons 3.0.x Versionen.

Das obige Setup ermöglicht es Ihnen nicht, einzelne Abhängigkeiten mit einer -Eigenschaft wie oben erläutert zu überschreiben. Um das gleiche Ergebnis zu erzielen, müssen Sie vor dem Eintrag spring-boot-dependencies einen Eintrag in der Abhängigkeitsverwaltung (dependencyManagement) Ihres Projekts hinzufügen. Wenn Sie beispielsweise ein Upgrade auf einen anderen Spring Data-Releasetrain durchführen möchten, können Sie der Datei „pom.xml“ Folgendes hinzufügen:

<dependencyManagement>
    <dependencies>
        <!-- Override Spring Data release train provided by Spring Boot -->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-releasetrain</artifactId>
            <version>${spring.data.version}</version>
            <scope>import</scope>
            <type>pom</type>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>${spring.boot.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

Hinweis: Ersetzen Sie ${spring.boot.version} und ${spring.data.version} durch die Versionen von Spring Boot und Spring Data, die Sie in Ihrem Projekt verwenden möchten.

Erste Schritte

Einschließen des Pakets

Falls Sie bei Verwendung von Maven die folgende Abhängigkeit hinzu:

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

Voraussetzungen

  • Java Development Kit (JDK), Version 8 oder höher
  • Ein aktives Azure-Konto. Wenn Sie keines besitzen, können Sie sich für ein kostenloses Kontoregistrieren. Zu Entwicklungs- und Testzwecken können Sie alternativ den Azure Cosmos DB-Emulator verwenden. Da das Https-Zertifikat des Emulators selbstsigniert ist, müssen Sie das Zertifikat in den vertrauenswürdigen Java-Zertifikatspeicher importieren, wie hier erläutert.
  • (Optional) SLF4J ist eine Protokollierungsfassade.
  • (Optional) Die SLF4J-Bindung wird verwendet, um SLF4J ein bestimmtes Protokollierungsframework zuzuordnen.
  • (Optional) Maven

SLF4J ist nur erforderlich, wenn Sie die Protokollierung verwenden möchten. Laden Sie außerdem eine SLF4J-Bindung herunter, um die SLF4J-API mit der Protokollierungsimplementierung Ihrer Wahl zu verknüpfen. Weitere Informationen finden Sie im SLF4J-Benutzerhandbuch.

Einrichten der Konfigurationsklasse

  • Um die Konfigurationsklasse einzurichten, müssen Sie AbstractCosmosConfiguration erweitern.

  • Azure-spring-data-cosmos unterstützt Response Diagnostics Stringauch , Query Metrics und Max Degree of Parallelism. Legen Sie das Flag queryMetricsEnabled in „application.properties“ auf „true“ fest, um Abfragemetriken zu aktivieren. Implementieren Sie außerdem ResponseDiagnosticsProcessor, um Diagnoseinformationen zu protokollieren. Legen Sie maxDegreeOfParallelism das Flag in application.properties auf eine ganze Zahl fest, um die parallele Verarbeitung zu ermöglichen. Wenn Sie den Wert auf -1 festlegen, entscheidet das SDK über den optimalen Wert. Legen Sie maxBufferedItemCount das Flag in application.properties auf eine ganze Zahl fest, damit der Benutzer die maximale Anzahl von Elementen festlegen kann, die während der parallelen Abfrageausführung gepuffert werden können. Wenn dieser Wert auf kleiner als 0 festgelegt ist, entscheidet das System automatisch über die Anzahl der zu puffernden Elemente. HINWEIS: Wenn Sie diesen Wert auf einen sehr hohen Wert festlegen, kann dies zu einem hohen Speicherverbrauch führen. Legen Sie responseContinuationTokenLimitInKb das Flag in application.properties auf eine ganze Zahl fest, damit der Benutzer die Länge des Fortsetzungstokens in der Abfrageantwort einschränken kann. Das Fortsetzungstoken enthält sowohl erforderliche als auch optionale Felder. Die erforderlichen Felder sind erforderlich, um die Ausführung dort fortzusetzen, wo sie beendet wurde. Die optionalen Felder können serialisierte Indexsuchevorgänge enthalten, die abgeschlossen, aber noch nicht verwendet wurden. Dadurch wird vermieden, dass die Arbeit in nachfolgenden Fortsetzungen erneut ausgeführt wird und somit die Abfrageleistung verbessert wird. Wenn Sie die maximale Fortsetzungsgröße auf 1 KB festlegen, serialisiert der Azure Cosmos DB-Dienst nur erforderliche Felder. Ab 2 KB würde der Azure Cosmos DB-Dienst so viel serialisieren, wie er passen könnte, bis er die maximale angegebene Größe erreicht. Legen Sie pointOperationLatencyThresholdInMS, requestChargeThresholdInRUnonPointOperationLatencyThresholdInMSund payloadSizeThresholdInBytes fest, um Diagnose auf Clientebene zu aktivieren, wenn diese Schwellenwerte überschritten werden.

@Configuration
@EnableCosmosRepositories
public class AppConfiguration extends AbstractCosmosConfiguration {

    private static final Logger LOGGER = LoggerFactory.getLogger(AppConfiguration.class);

    @Value("${azure.cosmos.uri}")
    private String uri;

    @Value("${azure.cosmos.key}")
    private String key;

    @Value("${azure.cosmos.secondaryKey}")
    private String secondaryKey;

    @Value("${azure.cosmos.database}")
    private String dbName;

    @Value("${azure.cosmos.queryMetricsEnabled}")
    private boolean queryMetricsEnabled;

    @Value("${azure.cosmos.maxDegreeOfParallelism}")
    private int maxDegreeOfParallelism;

    @Value("${azure.cosmos.maxBufferedItemCount}")
    private int maxBufferedItemCount;

    @Value("${azure.cosmos.responseContinuationTokenLimitInKb}")
    private int responseContinuationTokenLimitInKb;

    @Value("${azure.cosmos.diagnosticsThresholds.pointOperationLatencyThresholdInMS}")
    private int pointOperationLatencyThresholdInMS;

    @Value("${azure.cosmos.diagnosticsThresholds.nonPointOperationLatencyThresholdInMS}")
    private int nonPointOperationLatencyThresholdInMS;

    @Value("${azure.cosmos.diagnosticsThresholds.requestChargeThresholdInRU}")
    private int requestChargeThresholdInRU;

    @Value("${azure.cosmos.diagnosticsThresholds.payloadSizeThresholdInBytes}")
    private int payloadSizeThresholdInBytes;


    private AzureKeyCredential azureKeyCredential;

    @Bean
    public CosmosClientBuilder getCosmosClientBuilder() {
        this.azureKeyCredential = new AzureKeyCredential(key);
        DirectConnectionConfig directConnectionConfig = new DirectConnectionConfig();
        GatewayConnectionConfig gatewayConnectionConfig = new GatewayConnectionConfig();
        return new CosmosClientBuilder()
            .endpoint(uri)
            .credential(azureKeyCredential)
            .directMode(directConnectionConfig, gatewayConnectionConfig)
            .clientTelemetryConfig(
                new CosmosClientTelemetryConfig()
                    .diagnosticsThresholds(
                        new CosmosDiagnosticsThresholds()
                            .setNonPointOperationLatencyThreshold(Duration.ofMillis(nonPointOperationLatencyThresholdInMS))
                            .setPointOperationLatencyThreshold(Duration.ofMillis(pointOperationLatencyThresholdInMS))
                            .setPayloadSizeThreshold(payloadSizeThresholdInBytes)
                            .setRequestChargeThreshold(requestChargeThresholdInRU)
                    )
                    .diagnosticsHandler(CosmosDiagnosticsHandler.DEFAULT_LOGGING_HANDLER));
    }

    @Override
    public CosmosConfig cosmosConfig() {
        return CosmosConfig.builder()
                           .enableQueryMetrics(queryMetricsEnabled)
                           .maxDegreeOfParallelism(maxDegreeOfParallelism)
                           .maxBufferedItemCount(maxBufferedItemCount)
                           .responseContinuationTokenLimitInKb(responseContinuationTokenLimitInKb)
                           .responseDiagnosticsProcessor(new ResponseDiagnosticsProcessorImplementation())
                           .build();
    }

    public void switchToSecondaryKey() {
        this.azureKeyCredential.update(secondaryKey);
    }

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

    private static class ResponseDiagnosticsProcessorImplementation implements ResponseDiagnosticsProcessor {

        @Override
        public void processResponseDiagnostics(@Nullable ResponseDiagnostics responseDiagnostics) {
            LOGGER.info("Response Diagnostics {}", responseDiagnostics);
        }
    }

}

Anpassen der Konfiguration

Sie können oder GatewayConnectionConfig oder beide anpassen DirectConnectionConfig und bereitstellen, um CosmosAsyncClient sie anzupassenCosmosClientBuilder. Sie können pointOperationLatencyThresholdInMS, nonPointOperationLatencyThresholdInMSrequestChargeThresholdInRU und payloadSizeThresholdInBytes die Schwellenwerte für die Diagnoseprotokollierung anpassen, wenn sie mit CosmosDiagnosticsHandler kombiniert werden, wodurch die Diagnoseprotokollierung mit den Standardschwellenwerten aktiviert wird, wenn sie CosmosClientBuilderdem hinzugefügt werden.

@Bean
public CosmosClientBuilder getCosmosClientBuilder() {

    DirectConnectionConfig directConnectionConfig = new DirectConnectionConfig();
    GatewayConnectionConfig gatewayConnectionConfig = new GatewayConnectionConfig();
    return new CosmosClientBuilder()
        .endpoint(uri)
        .directMode(directConnectionConfig, gatewayConnectionConfig)
        .clientTelemetryConfig(
            new CosmosClientTelemetryConfig()
                .diagnosticsThresholds(
                    new CosmosDiagnosticsThresholds()
                        .setNonPointOperationLatencyThreshold(Duration.ofMillis(nonPointOperationLatencyThresholdInMS))
                        .setPointOperationLatencyThreshold(Duration.ofMillis(pointOperationLatencyThresholdInMS))
                        .setPayloadSizeThreshold(payloadSizeThresholdInBytes)
                        .setRequestChargeThreshold(requestChargeThresholdInRU)
                )
                .diagnosticsHandler(CosmosDiagnosticsHandler.DEFAULT_LOGGING_HANDLER));
}

@Override
public CosmosConfig cosmosConfig() {
    return CosmosConfig.builder()
                       .enableQueryMetrics(queryMetricsEnabled)
                       .maxDegreeOfParallelism(maxDegreeOfParallelism)
                       .maxBufferedItemCount(maxBufferedItemCount)
                       .responseContinuationTokenLimitInKb(responseContinuationTokenLimitInKb)
                       .responseDiagnosticsProcessor(new ResponseDiagnosticsProcessorImplementation())
                       .build();
}

Standardmäßig wird durch @EnableCosmosRepositories das aktuelle Paket auf Schnittstellen überprüft, die eine der Repositoryschnittstellen von Spring Data erweitern. Kommentieren Sie damit Ihre Configuration-Klasse, um ein anderes Stammpaket mittels @EnableCosmosRepositories(basePackageClass=UserRepository.class) zu überprüfen, wenn Ihr Projektlayout mehrere Projekte umfasst.

Aktivieren von Protokollierungs-Diagnose für Azure-Anwendung Insights mit JavaAgent

Die Diagnose kann aktiviert werden, indem Sie den JavaAgent wie folgt an Ihre Anwendung übergeben. Dadurch wird die Protokollierung mit den Standardschwellenwerten aktiviert. Der "-javaagent" muss vor dem "-jar" übergeben werden.

java -javaagent:"<path-to-applicationinsights-agent-jar>" -jar <myapp.jar>

Verwenden des bereitgestellten Datenbankdurchsatzes

Cosmos unterstützt sowohl container - als auch datenbankseitig bereitgestellten Durchsatz. Standardmäßig stellt spring-data-cosmos den Durchsatz für jeden erstellten Container bereit. Wenn Sie den Durchsatz zwischen Containern gemeinsam nutzen möchten, können Sie den von der Datenbank bereitgestellten Durchsatz über CosmosConfig aktivieren.

@Override
public CosmosConfig cosmosConfig() {
    int autoscale = false; 
    int initialRequestUnits = 400;
    return CosmosConfig.builder()
                       .enableDatabaseThroughput(autoscale, initialRequestUnits) 
                       .build();
}

Definieren einer Entität

  • Definieren Sie eine einfache Entität als Element in Azure Cosmos DB.

  • Sie können Entitäten definieren, indem Sie die Anmerkung @Container hinzufügen und Eigenschaften im Zusammenhang mit dem Container angeben, etwa den Containernamen, Anforderungseinheiten (Request Units, RUs), die Gültigkeitsdauer und die automatische Containererstellung.

  • Container werden standardmäßig automatisch erstellt. Wenn Sie die automatische Containererstellung deaktivieren möchten, legen Sie autoCreateContainer in der Anmerkung @Container auf „false“ fest.

  • Hinweis: Neu erstellten Containern werden standardmäßig 400 Anforderungseinheiten zugewiesen. Geben Sie einen anderen RU-Wert an, um Anforderungseinheiten für den vom SDK erstellten Container anzupassen. (Der Mindestwert für RUs ist 400.)

@Container(containerName = "myContainer", ru = "400")
public class User {
    private String id;
    private String firstName;


    @PartitionKey
    private String lastName;

    public User() {
        // If you do not want to create a default constructor,
        // use annotation @JsonCreator and @JsonProperty in the full args constructor
    }

    public User(String id, String firstName, String lastName) {
        this.id = id;
        this.firstName = firstName;
        this.lastName = lastName;
    }

    @Override
    public String toString() {
        return String.format("User: %s %s, %s", firstName, lastName, id);
    }

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

  • id feld wird als Element-ID in Azure Cosmos DB verwendet. Wenn Sie ein anderes Feld wie als firstName Element idverwenden möchten, kommentieren Sie dieses Feld einfach mit @Id Anmerkungen.

  • Die Anmerkung @Container(containerName="myContainer") gibt den Containernamen in Azure Cosmos DB an.

  • Die Anmerkung @PartitionKey für das Feld lastName macht dieses Feld zum Partitionsschlüssel in Azure Cosmos DB.

Erstellen von Containern mit automatisch skaliertem Durchsatz

  • Die Anmerkung autoScale für das Feld gibt an, dass der Container mit automatisch skaliertem Durchsatz erstellt werden soll, wenn die Option auf „true“ festgelegt wird. Der Standardwert ist „false“. In diesem Fall werden Container mit manuellem Durchsatz erstellt.
  • Weitere Informationen zum automatisch skalierten Durchsatz finden Sie hier.
@Container(containerName = "myContainer", autoScale = true, ru = "4000")
public class UserSample {
    @Id
    private String emailAddress;

}

Unterstützung geschachtelter Partitionsschlüssel

  • Azure Spring Data Cosmos unterstützt geschachtelten Partitionsschlüssel. Verwenden Sie zum Hinzufügen eines geschachtelten Partitionsschlüssels das Feld partitionKeyPath in der Anmerkung @Container.
  • partitionKeyPath sollte nur zur Unterstützung des Pfads für geschachtelte Partitionsschlüssel verwendet werden. Verwenden Sie zur allgemeinen Unterstützung von Partitionsschlüsseln die Anmerkung @PartitionKey.
  • Die Anmerkung @PartitionKey hat standardmäßig Vorrang, sofern angegeben.
  • Das folgende Beispiel zeigt die ordnungsgemäße Verwendung des Features für geschachtelte Partitionsschlüssel:
@Container(containerName = "nested-partition-key", partitionKeyPath = "/nestedEntitySample/nestedPartitionKey")
public class NestedPartitionKeyEntitySample {

    private NestedEntitySample nestedEntitySample;
}

public class NestedEntitySample {
    private String nestedPartitionKey;
}

Erstellen von Repositorys

Erweitert die CosmosRepository-Schnittstelle zur Unterstützung von Spring Data-Repositorys.

@Repository
public interface UserRepository extends CosmosRepository<User, String> {
    Iterable<User> findByFirstName(String firstName);
    long countByFirstName(String firstName);
    User findOne(String id, String lastName);
}
  • Die Methode findByFirstName ist eine benutzerdefinierte Abfragemethode, die Elemente anhand des Vornamens (firstName) sucht.

Zwischenspeichern von Abfrageplänen

Spring-Repository-Abfrage-APIs wie findByFirstName(String firstName) die firstName Partition oder kommentierte Abfragen mit Partitionsschlüssel führen aufgrund der Zwischenspeicherung des Abfrageplans zu einer geringeren Ausführungszeit der Abfrage. Derzeit wird das Zwischenspeichern von Abfrageplänen nur für Abfragemethoden unterstützt, die auf eine einzelne Partition abzielen.

QueryAnnotation: Verwenden von Abfragen mit Anmerkungen in Repositorys

Azure Spring Data Cosmos unterstützt das Angeben von Abfragen mit Anmerkungen in den Repositorys mithilfe von @Query.

  • Beispiele für Abfragen mit Anmerkungen in „CosmosRepository“ (synchron):
public interface AnnotatedQueriesUserRepositoryCodeSnippet extends CosmosRepository<User, String> {
    @Query("select * from c where c.firstName = @firstName and c.lastName = @lastName")
    List<User> getUsersByFirstNameAndLastName(@Param("firstName") String firstName, @Param("lastName") String lastName);

    @Query("select * from c offset @offset limit @limit")
    List<User> getUsersWithOffsetLimit(@Param("offset") int offset, @Param("limit") int limit);

    @Query("select value count(1) from c where c.firstName = @firstName")
    long getNumberOfUsersWithFirstName(@Param("firstName") String firstName);
}
  • Beispiele für Abfragen mit Anmerkungen in „ReactiveCosmosRepository“:
public interface AnnotatedQueriesUserReactiveRepositoryCodeSnippet extends ReactiveCosmosRepository<User, String> {
    @Query("select * from c where c.firstName = @firstName and c.lastName = @lastName")
    Flux<User> getUsersByTitleAndValue(@Param("firstName") int firstName, @Param("lastName") String lastName);

    @Query("select * from c offset @offset limit @limit")
    Flux<User> getUsersWithOffsetLimit(@Param("offset") int offset, @Param("limit") int limit);

    @Query("select count(c.id) as num_ids, c.lastName from c group by c.lastName")
    Flux<ObjectNode> getCoursesGroupByDepartment();

    @Query("select value count(1) from c where c.lastName = @lastName")
    Mono<Long> getNumberOfUsersWithLastName(@Param("lastName") String lastName);
}

Die in der Anmerkung angegebenen Abfragen sind identisch mit den Cosmos-Abfragen. Weitere Informationen zu SQL-Abfragen in Cosmos finden Sie in den folgenden Artikeln:

Erstellen einer Anwendungsklasse

Hier wird eine Anwendungsklasse mit allen Komponenten erstellt:

@SpringBootApplication
public class SampleApplication implements CommandLineRunner {

    @Autowired
    private UserRepository repository;

    @Autowired
    private ApplicationContext applicationContext;

    public static void main(String[] args) {
        SpringApplication.run(SampleApplication.class, args);
    }

    public void run(String... var1) {

        final User testUser = new User("testId", "testFirstName", "testLastName");

        repository.deleteAll();
        repository.save(testUser);

        // to find by Id, please specify partition key value if collection is partitioned
        final User result = repository.findOne(testUser.getId(), testUser.getLastName());

        //  Switch to secondary key
        UserRepositoryConfiguration bean =
            applicationContext.getBean(UserRepositoryConfiguration.class);
        bean.switchToSecondaryKey();

        //  Now repository will use secondary key
        repository.save(testUser);

    }
}
  • Verwenden Sie Autowiring für die UserRepository-Schnittstelle, um Vorgänge wie Speichern, Löschen, Suchen usw. auszuführen.
  • Von Spring Data Azure Cosmos DB werden CosmosTemplate und ReactiveCosmosTemplate verwendet, um die Abfragen hinter Methoden vom Typ find und save auszuführen. Die Vorlage kann von Ihnen auch für komplexere Abfragen verwendet werden.

Wichtige Begriffe

„CrudRepository“ und „ReactiveCrudRepository“

  • Von Azure Spring Data Cosmos werden „ReactiveCrudRepository“ und „CrudRepository“ unterstützt, um grundlegende CRUD-Funktionen bereitzustellen.
    • save
    • findAll
    • findOne nach ID
    • deleteAll
    • löschen nach ID
    • delete (Entität)

Spring Data-Anmerkungen

Spring Data @Id Anmerkung

Es gibt zwei Möglichkeiten, ein Feld in der Domänenklasse dem Feld id eines Azure Cosmos DB-Elements zuzuordnen.

  • Sie können ein Feld in der Domänenklasse mit der Anmerkung @Id versehen, um dieses Feld dem Element id in Cosmos DB zuzuordnen.
  • Sie können den Namen des Felds auf id festlegen, um dieses Feld dem Element id in Azure Cosmos DB zuzuordnen.

Automatische ID-Generierung

  • Unterstützt die automatische Generierung von Zeichenfolgentyp-UUIDs mithilfe der Anmerkung @GeneratedValue. Das ID-Feld einer Entität mit einer Zeichenfolgentyp-ID kann mit @GeneratedValue versehen werden, um vor dem Einfügen automatisch eine zufällige UUID zu generieren.
public class GeneratedIdEntity {

    @Id
    @GeneratedValue
    private String id;

}

SpEL-Ausdruck und benutzerdefinierter Containername.

  • Standardmäßig ist der Containername der Klassenname der Benutzerdomänenklasse. Fügen Sie zum Anpassen der Domänenklasse die Anmerkung @Container(containerName="myCustomContainerName") hinzu. Das Containerfeld unterstützt auch SpEL-Ausdrücke (z. B. container = "${dynamic.container.name}" oder container = "#{@someBean.getContainerName()}"), um Containernamen programmgesteuert/über Konfigurationseigenschaften bereitzustellen.
  • Damit SpEL-Ausdrücke ordnungsgemäß funktionieren, muss neben der Spring-Anwendungsklasse auch @DependsOn("expressionResolver") hinzugefügt werden.
@SpringBootApplication
@DependsOn("expressionResolver")
public class SampleApplication {
    
}

Indizierungsrichtlinien

  • IndexingPolicy wird standardmäßig vom Azure-Portaldienst festgelegt. Fügen Sie zum Anpassen die Anmerkung @CosmosIndexingPolicy zur Domänenklasse hinzu. Diese Anmerkung hat 5 Attribute, die angepasst werden müssen. Weitere Informationen finden Sie unter:
// Indicate if indexing policy use automatic or not
// Default value is true
boolean automatic() default Constants.DEFAULT_INDEXING_POLICY_AUTOMATIC;

// Indexing policy mode, option Consistent.
IndexingMode mode() default IndexingMode.CONSISTENT;

// Included paths for indexing
String[] includePaths() default {};

// Excluded paths for indexing
String[] excludePaths() default {};

Eindeutige Schlüsselrichtlinie

  • Azure Spring Data Cosmos unterstützt das Festlegen UniqueKeyPolicy für container, indem die Anmerkung @CosmosUniqueKeyPolicy zur Domänenklasse hinzugefügt wird. Diese Anmerkung weist die folgenden Attribute auf:
@Container
@CosmosUniqueKeyPolicy(uniqueKeys = {
    @CosmosUniqueKey(paths = {"/lastName", "/zipCode"}),
    @CosmosUniqueKey(paths = {"/city"})
})
public class CosmosUniqueKeyPolicyCodeSnippet {

    @Id
    String id;

    @PartitionKey
    String firstName;

    String lastName;
    String zipCode;
    String city;
}

Azure Cosmos DB-Partition

  • Von „Azure-spring-data-cosmos“ wird die Azure Cosmos DB-Partition unterstützt.
  • Wenn Sie ein Feld der Domänenklasse als Partitionsschlüsselfeld angeben möchten, versehen Sie es einfach mit der Anmerkung @PartitionKey.
  • Geben Sie beim Ausführen eines CRUD-Vorgangs Ihren Partitionswert an.
  • Weitere Beispiele zu CRUD-Vorgängen für Partitionen finden Sie hier.

Optimistische Sperre

  • Von „Azure-spring-data-cosmos“ wird die optimistische Sperre für bestimmte Container unterstützt. Das bedeutet, dass bei elementspezifischen Upsert-/Löschvorgängen ein Ausnahmefehler auftritt, wenn das Element inzwischen durch einen anderen Prozess geändert wird.
  • Um die optimistische Sperre für einen Container zu aktivieren, erstellen Sie einfach ein Zeichenfolgenfeld vom Typ _etag, und versehen Sie es mit der Anmerkung @Version. Weitere Informationen finden Sie in den folgenden Themen:
@Container(containerName = "myContainer")
public class MyItem {
    String id;
    String data;
    @Version
    String _etag;
}

Benutzerdefinierte Spring Data-Abfrage, Paginierung und Sortierung

  • Von „Azure-spring-data-cosmos“ werden benutzerdefinierte Spring Data-Abfragen unterstützt.
  • Beispiel für Suchvorgang: findByAFieldAndBField
  • Unterstützt „Pageable“, „Slice“ und „Sort“ von Spring Data.
    • Basierend auf den verfügbaren RUs für das Datenbankkonto kann Cosmos DB Elemente zurückgeben, die kleiner als die angeforderte Größe sind oder der angeforderten Größe entsprechen.
    • Aufgrund dieser in jeder Iteration variablen Anzahl zurückgegebener Elemente sollte sich der Benutzer nicht auf „totalPageSize“ verlassen, sondern stattdessen Iterationen auf der Grundlage von „pageable“ verwenden.
private List<T> findAllWithPageSize(int pageSize) {

    final CosmosPageRequest pageRequest = new CosmosPageRequest(0, pageSize, null);
    Page<T> page = repository.findAll(pageRequest);
    List<T> pageContent = page.getContent();
    while (page.hasNext()) {
        Pageable nextPageable = page.nextPageable();
        page = repository.findAll(nextPageable);
        pageContent = page.getContent();
    }
    return pageContent;
}

public interface SliceQueriesUserRepository extends CosmosRepository<User, String> {
    @Query("select * from c where c.lastName = @lastName")
    Slice<User> getUsersByLastName(@Param("lastName") String lastName, Pageable pageable);
}

private List<User> getUsersByLastName(String lastName, int pageSize) {

    final CosmosPageRequest pageRequest = new CosmosPageRequest(0, pageSize, null);
    Slice<User> slice = repository.getUsersByLastName(lastName, pageRequest);
    List<User> content = slice.getContent();
    while (slice.hasNext()) {
        Pageable nextPageable = slice.nextPageable();
        slice = repository.getUsersByLastName(lastName, nextPageable);
        content.addAll(slice.getContent());
    }
    return content;
}

Spring Boot Starter-Daten: REST

  • Von „Azure-spring-data-cosmos“ wird spring-boot-starter-data-rest unterstützt.
  • Unterstützt Auflistung und geschachtelten Typ in der Domänenklasse.
  • Konfigurierbare ObjectMapper-Beane mit eindeutigem Namen cosmosObjectMapper, konfigurieren Sie benutzerdefiniertes ObjectMapper nur, wenn Sie dies wirklich benötigen.
@Bean(name = "cosmosObjectMapper")
public ObjectMapper objectMapper() {
    return new ObjectMapper(); // Do configuration to the ObjectMapper if required
}

Überwachung

  • Von „Azure-spring-data-cosmos“ wird die Überwachung von Feldern in Datenbankentitäten mithilfe standardmäßiger Spring Data-Anmerkungen unterstützt.
  • Zum Aktivieren dieses Features können Sie Ihrer Anwendungskonfiguration eine Anmerkung vom Typ @EnableCosmosAuditing hinzufügen.
  • Entitäten können @CreatedBy, @CreatedDate, @LastModifiedBy und @LastModifiedDate verwenden, um Felder mit Anmerkungen zu versehen. Diese Felder werden automatisch aktualisiert.
@Container(containerName = "myContainer")
public class AuditableUser {
    private String id;
    private String firstName;
    @CreatedBy
    private String createdBy;
    @CreatedDate
    private OffsetDateTime createdDate;
    @LastModifiedBy
    private String lastModifiedBy;
    @LastModifiedDate
    private OffsetDateTime lastModifiedByDate;
}

Konfiguration mit mehreren Datenbanken

  • Von „Azure-spring-data-cosmos“ werden Konfigurationen mit mehreren Datenbanken unterstützt. Das gilt sowohl für mehrere Datenbankkonten als auch für ein einzelnes Konto mit mehreren Datenbanken.

Konten mit mehreren Datenbanken

Im Beispiel wird die Datei application.properties verwendet.

# primary account cosmos config
azure.cosmos.primary.uri=your-primary-cosmosDb-uri
azure.cosmos.primary.key=your-primary-cosmosDb-key
azure.cosmos.primary.secondaryKey=your-primary-cosmosDb-secondary-key
azure.cosmos.primary.database=your-primary-cosmosDb-dbName
azure.cosmos.primary.populateQueryMetrics=if-populate-query-metrics

# secondary account cosmos config
azure.cosmos.secondary.uri=your-secondary-cosmosDb-uri
azure.cosmos.secondary.key=your-secondary-cosmosDb-key
azure.cosmos.secondary.secondaryKey=your-secondary-cosmosDb-secondary-key
azure.cosmos.secondary.database=your-secondary-cosmosDb-dbName
azure.cosmos.secondary.populateQueryMetrics=if-populate-query-metrics

  • Die Definition von Entität und Repository ist ähnlich wie oben. Sie können verschiedene Datenbankentitäten in verschiedenen Paketen platzieren.

  • Durch @EnableReactiveCosmosRepositories oder @EnableCosmosRepositories werden benutzerdefinierte Cosmos-Vorlagen unterstützt. Verwenden Sie reactiveCosmosTemplateRef oder cosmosTemplateRef, um den Namen des Beans ReactiveCosmosTemplate oder CosmosTemplate zu definieren, das mit den erkannten Repositorys verwendet werden soll.

  • Wenn Sie über mehrere Cosmos-Datenbankkonten verfügen, können Sie mehrere Elemente vom Typ CosmosAsyncClient definieren. Verfügt das einzelne Cosmos-Konto über mehrere Datenbanken, können Sie das gleiche Element vom Typ CosmosAsyncClient verwenden, um die Cosmos-Vorlage zu initialisieren.

@Configuration
@EnableReactiveCosmosRepositories(basePackages = "com.azure.spring.sample.cosmos.multi.database.multiple.account.repository",
    reactiveCosmosTemplateRef = "primaryDatabaseTemplate")
public class PrimaryDatasourceConfiguration extends AbstractCosmosConfiguration{

    private static final String PRIMARY_DATABASE = "primary_database";

    @Bean
    @ConfigurationProperties(prefix = "azure.cosmos.primary")
    public CosmosProperties primary() {
        return new CosmosProperties();
    }

    @Bean
    public CosmosClientBuilder primaryClientBuilder(@Qualifier("primary") CosmosProperties primaryProperties) {
        return new CosmosClientBuilder()
            .key(primaryProperties.getKey())
            .endpoint(primaryProperties.getUri());
    }

    @Bean
    public ReactiveCosmosTemplate primaryDatabaseTemplate(CosmosAsyncClient cosmosAsyncClient,
                                                          CosmosConfig cosmosConfig,
                                                          MappingCosmosConverter mappingCosmosConverter) {
        return new ReactiveCosmosTemplate(cosmosAsyncClient, PRIMARY_DATABASE, cosmosConfig, mappingCosmosConverter);
    }

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

@Configuration
@EnableCosmosRepositories(cosmosTemplateRef  = "secondaryDatabaseTemplate")
public class SecondaryDatasourceConfiguration {

    private static final Logger LOGGER = LoggerFactory.getLogger(SecondaryDatasourceConfiguration.class);
    public static final String SECONDARY_DATABASE = "secondary_database";

    @Bean
    @ConfigurationProperties(prefix = "azure.cosmos.secondary")
    public CosmosProperties secondary() {
        return new CosmosProperties();
    }

    @Bean("secondaryCosmosClient")
    public CosmosAsyncClient getCosmosAsyncClient(@Qualifier("secondary") CosmosProperties secondaryProperties) {
        return CosmosFactory.createCosmosAsyncClient(new CosmosClientBuilder()
            .key(secondaryProperties.getKey())
            .endpoint(secondaryProperties.getUri()));
    }

    @Bean("secondaryCosmosConfig")
    public CosmosConfig getCosmosConfig() {
        return CosmosConfig.builder()
            .enableQueryMetrics(true)
            .maxDegreeOfParallelism(0)
            .maxBufferedItemCount(0)
            .responseContinuationTokenLimitInKb(0)
            .responseDiagnosticsProcessor(new ResponseDiagnosticsProcessorImplementation())
            .build();
    }

    @Bean
    public CosmosTemplate secondaryDatabaseTemplate(@Qualifier("secondaryCosmosClient") CosmosAsyncClient client,
                                                    @Qualifier("secondaryCosmosConfig") CosmosConfig cosmosConfig,
                                                    MappingCosmosConverter mappingCosmosConverter) {
        return new CosmosTemplate(client, SECONDARY_DATABASE, cosmosConfig, mappingCosmosConverter);
    }

    private static class ResponseDiagnosticsProcessorImplementation implements ResponseDiagnosticsProcessor {

        @Override
        public void processResponseDiagnostics(@Nullable ResponseDiagnostics responseDiagnostics) {
            LOGGER.info("Response Diagnostics {}", responseDiagnostics);
        }
    }
}
  • Im obigen Beispiel sind zwei Cosmos-Konten vorhanden. CosmosAsyncClient kann wie folgt erstellt werden:
@Bean("secondaryCosmosClient")
public CosmosAsyncClient getCosmosAsyncClient(@Qualifier("secondary") CosmosProperties secondaryProperties) {
    return CosmosFactory.createCosmosAsyncClient(new CosmosClientBuilder()
        .key(secondaryProperties.getKey())
        .endpoint(secondaryProperties.getUri()));
}

@Bean("secondaryCosmosConfig")
public CosmosConfig getCosmosConfig() {
    return CosmosConfig.builder()
        .enableQueryMetrics(true)
        .maxDegreeOfParallelism(0)
        .maxBufferedItemCount(0)
        .responseContinuationTokenLimitInKb(0)
        .responseDiagnosticsProcessor(new ResponseDiagnosticsProcessorImplementation())
        .build();
}
  • Wenn Sie außerdem , , ResponseDiagnosticsProcessormaxDegreeOfParallelismoder maxBufferedItemCountresponseContinuationTokenLimitInKb definieren queryMetricsEnabledmöchten, können Sie die CosmosConfig Vorlage für Ihre Cosmos erstellen.
@Bean("secondaryCosmosConfig")
public CosmosConfig getCosmosConfig() {
    return CosmosConfig.builder()
        .enableQueryMetrics(true)
        .maxDegreeOfParallelism(0)
        .maxBufferedItemCount(0)
        .responseContinuationTokenLimitInKb(0)
        .responseDiagnosticsProcessor(new ResponseDiagnosticsProcessorImplementation())
        .build();
}
  • Erstellen einer Anwendungsklasse
@SpringBootApplication
public class MultiDatabaseApplication implements CommandLineRunner {

    @Autowired
    private CosmosUserRepository cosmosUserRepository;

    @Autowired
    private MysqlUserRepository mysqlUserRepository;

    @Autowired
    @Qualifier("secondaryDatabaseTemplate")
    private CosmosTemplate secondaryDatabaseTemplate;

    @Autowired
    @Qualifier("primaryDatabaseTemplate")
    private ReactiveCosmosTemplate primaryDatabaseTemplate;

    private final CosmosUser cosmosUser = new CosmosUser("1024", "1024@geek.com", "1k", "Mars");
    private static CosmosEntityInformation<CosmosUser, String> userInfo = new CosmosEntityInformation<>(CosmosUser.class);

    public static void main(String[] args) {
        SpringApplication.run(MultiDatabaseApplication.class, args);
    }

    public void run(String... var1) throws Exception {

        CosmosUser cosmosUserGet = primaryDatabaseTemplate.findById(cosmosUser.getId(), cosmosUser.getClass()).block();
        // Same to this.cosmosUserRepository.findById(cosmosUser.getId()).block();
        MysqlUser mysqlUser = new MysqlUser(cosmosUserGet.getId(), cosmosUserGet.getEmail(), cosmosUserGet.getName(), cosmosUserGet.getAddress());
        mysqlUserRepository.save(mysqlUser);
        mysqlUserRepository.findAll().forEach(System.out::println);
        CosmosUser secondaryCosmosUserGet = secondaryDatabaseTemplate.findById(CosmosUser.class.getSimpleName(), cosmosUser.getId(), CosmosUser.class);
        System.out.println(secondaryCosmosUserGet);
    }


    @PostConstruct
    public void setup() {
        primaryDatabaseTemplate.createContainerIfNotExists(userInfo).block();
        primaryDatabaseTemplate.insert(CosmosUser.class.getSimpleName(), cosmosUser, new PartitionKey(cosmosUser.getName())).block();
        // Same to this.cosmosUserRepository.save(user).block();
        secondaryDatabaseTemplate.createContainerIfNotExists(userInfo);
        secondaryDatabaseTemplate.insert(CosmosUser.class.getSimpleName(), cosmosUser, new PartitionKey(cosmosUser.getName()));
   }

    @PreDestroy
    public void cleanup() {
        primaryDatabaseTemplate.deleteAll(CosmosUser.class.getSimpleName(), CosmosUser.class).block();
        // Same to this.cosmosUserRepository.deleteAll().block();
        secondaryDatabaseTemplate.deleteAll(CosmosUser.class.getSimpleName() , CosmosUser.class);
        mysqlUserRepository.deleteAll();
    }
}

Einzelnes Konto mit mehreren Datenbanken

Im Beispiel wird die Datei application.properties verwendet.

azure.cosmos.uri=your-cosmosDb-uri
azure.cosmos.key=your-cosmosDb-key
azure.cosmos.secondary-key=your-cosmosDb-secondary-key
azure.cosmos.database=your-cosmosDb-dbName
azure.cosmos.populate-query-metrics=if-populate-query-metrics
  • Die Definition von Entität und Repository ist ähnlich wie oben. Sie können verschiedene Datenbankentitäten in verschiedenen Paketen platzieren.
  • Sie können EnableReactiveCosmosRepositories mit unterschiedlichen Elementen vom Typ reactiveCosmosTemplateRef verwenden, um mehrere Datenbanken in einem einzelnen Cosmos-Konto zu definieren.
@Configuration
public class DatasourceConfiguration {

    private static final String DATABASE1 = "database1";
    private static final String DATABASE2 = "database2";

    @Bean
    public CosmosProperties cosmosProperties() {
        return new CosmosProperties();
    }

    @Bean
    public CosmosClientBuilder primaryClientBuilder(CosmosProperties cosmosProperties) {
        return new CosmosClientBuilder()
            .key(cosmosProperties.getKey())
            .endpoint(cosmosProperties.getUri());
    }

    @EnableReactiveCosmosRepositories(basePackages = "com.azure.spring.sample.cosmos.multi.database.repository1",
        reactiveCosmosTemplateRef = "database1Template")
    public class Database1Configuration extends AbstractCosmosConfiguration {

        @Bean
        public ReactiveCosmosTemplate database1Template(CosmosAsyncClient cosmosAsyncClient,
                                                              CosmosConfig cosmosConfig,
                                                              MappingCosmosConverter mappingCosmosConverter) {
            return new ReactiveCosmosTemplate(cosmosAsyncClient, DATABASE1, cosmosConfig, mappingCosmosConverter);
        }

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

    @EnableReactiveCosmosRepositories(basePackages = "com.azure.spring.sample.cosmos.multi.database.repository2",
        reactiveCosmosTemplateRef = "database2Template")
    public class Database2Configuration {

        @Bean
        public ReactiveCosmosTemplate database2Template(CosmosAsyncClient cosmosAsyncClient,
                                                              CosmosConfig cosmosConfig,
                                                              MappingCosmosConverter mappingCosmosConverter) {
            return new ReactiveCosmosTemplate(cosmosAsyncClient, DATABASE2, cosmosConfig, mappingCosmosConverter);
        }

    }
}
  • Erstellen einer Anwendungsklasse
@SpringBootApplication
public class MultiDatabaseApplication implements CommandLineRunner {

    @Autowired
    private User1Repository user1Repository;

    @Autowired
    @Qualifier("database1Template")
    private ReactiveCosmosTemplate database1Template;

    @Autowired
    @Qualifier("database2Template")
    private ReactiveCosmosTemplate database2Template;

    private final User1 user1 = new User1("1024", "1024@geek.com", "1k", "Mars");
    private static CosmosEntityInformation<User1, String> user1Info = new CosmosEntityInformation<>(User1.class);

    private final User2 user2 = new User2("2048", "2048@geek.com", "2k", "Mars");
    private static CosmosEntityInformation<User2, String> user2Info = new CosmosEntityInformation<>(User2.class);


    public static void main(String[] args) {
        SpringApplication.run(MultiDatabaseApplication.class, args);
    }

    public void run(String... var1) throws Exception {

        User1 database1UserGet = database1Template.findById(User1.class.getSimpleName(), user1.getId(), User1.class).block();
        // Same to userRepository1.findById(user.getId()).block()
        System.out.println(database1UserGet);
        User2 database2UserGet = database2Template.findById(User2.class.getSimpleName(), user2.getId(), User2.class).block();
        System.out.println(database2UserGet);
    }

    @PostConstruct
    public void setup() {
        database1Template.createContainerIfNotExists(user1Info).block();
        database1Template.insert(User1.class.getSimpleName(), user1, new PartitionKey(user1.getName())).block();
        // Same to this.userRepository1.save(user).block();
        database2Template.createContainerIfNotExists(user2Info).block();
        database2Template.insert(User2.class.getSimpleName(), user2, new PartitionKey(user2.getName())).block();
    }

    @PreDestroy
    public void cleanup() {
        database1Template.deleteAll(User1.class.getSimpleName(), User1.class).block();
        // Same to this.userRepository1.deleteAll().block();
        database2Template.deleteAll(User2.class.getSimpleName(), User2.class).block();
    }
}

Mehrinstanzenfähigkeit auf Datenbankebene

  • Azure-spring-data-cosmos unterstützt die Mehrinstanzenfähigkeit auf Datenbankebene, indem die GetDatabaseName()-Funktion erweitert CosmosFactory und überschrieben wird.
public class MultiTenantDBCosmosFactory extends CosmosFactory {

    private String tenantId;

    /**
     * Validate config and initialization
     *
     * @param cosmosAsyncClient cosmosAsyncClient
     * @param databaseName      databaseName
     */
    public MultiTenantDBCosmosFactory(CosmosAsyncClient cosmosAsyncClient, String databaseName) {
        super(cosmosAsyncClient, databaseName);

        this.tenantId = databaseName;
    }

    @Override
    public String getDatabaseName() {
        return this.getCosmosAsyncClient().getDatabase(this.tenantId).toString();
    }
}

Betaversionspaket

Eine auf der Grundlage des Branchs main erstellte Betaversion ist verfügbar. Informationen zur Verwendung von Betaversionspaketen finden Sie in dieser Anleitung.

Problembehandlung

Allgemein

Wenn ein Fehler auftreten sollte, melden Sie hier ein Problem.

Wenn Sie ein neues Feature oder Änderungen vorschlagen möchten, die vorgenommen werden könnten, melden Sie ein Problem auf die gleiche Weise wie bei einem Fehler.

Aktivieren der Clientprotokollierung

  • Von „Azure-spring-data-cosmos“ wird SLF4j als Protokollierungsfassade verwendet, die die Protokollierung in gängigen Protokollierungsframeworks wie log4j und logback unterstützt. Wenn Sie beispielsweise logback in Spring als Protokollierungsframework verwenden möchten, fügen Sie dem Ressourcenordner den folgenden XML-Code hinzu:
<configuration>
  <include resource="/org/springframework/boot/logging/logback/base.xml"/>
  <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
    <encoder>
      <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
      </pattern>
    </encoder>
  </appender>
  <root level="info">
    <appender-ref ref="STDOUT"/>
  </root>
  <logger name="com.azure.cosmos" level="error"/>
  <logger name="org.springframework" level="error"/>
  <logger name="io.netty" level="error"/>
  <!-- This will enable query logging, to include query parameter logging, set this logger to TRACE -->  
  <logger name="com.azure.cosmos.implementation.SqlQuerySpecLogger" level="DEBUG"/>  
</configuration>

Beispiele

  • Ein Beispielprojekt finden Sie hier.

Konten mit mehreren Datenbanken

Einzelnes Konto mit mehreren Datenbanken

Nächste Schritte

  • Weitere Informationen zu Azure Spring Data Cosmos finden Sie hier.
  • Weitere Informationen zum Azure CosmosDB-Dienst finden Sie hier.

Mitwirken

Beiträge und Vorschläge für dieses Projekt sind willkommen. Für die meisten Beiträge ist die Zustimmung zu einer Lizenzvereinbarung für Mitwirkende (Contributor License Agreement, CLA) erforderlich, in der Sie erklären, dass Sie dazu berechtigt sind, uns die Rechte für die Nutzung Ihres Beitrags zu erteilen, und dies auch tun.

Wenn Sie einen Pull Request (PR) übermitteln, überprüft ein CLA-Bot automatisch, ob Sie eine Lizenzvereinbarung bereitstellen und den PR entsprechend ergänzen müssen (z.B. mit einer Bezeichnung oder einem Kommentar). Führen Sie einfach die Anweisungen des Bots aus. Sie müssen dies nur einmal für alle Repositorys ausführen, die unsere CLA verwenden.

Für dieses Projekt gelten die Microsoft-Verhaltensregeln für Open Source (Microsoft Open Source Code of Conduct). Weitere Informationen finden Sie in den häufig gestellten Fragen zum Verhaltenskodex. Sie können sich auch an opencode@microsoft.com wenden, wenn Sie weitere Fragen oder Anmerkungen haben.

Aufrufe