Azure Spring Data Cosmos-klientbibliotek för Java

  • Artikel
  • 15 minuter för att läsa

Azure Spring Data Cosmos tillhandahåller Spring Data-stöd för Azure Cosmos DB med SQL API,baserat på Spring Data-ramverket. Azure Cosmos DB är en globalt distribuerad databastjänst som gör att utvecklare kan arbeta med data med hjälp av en mängd olika standard-API:er, till exempel SQL, MongoDB, Cassandra, Graph och Table.

Stöd för Spring-dataversion

Det här projektet stöder både spring-data-commons 2.2.x - och spring-data-commons 2.3.x -versioner. Maven-användare kan ärva spring-boot-starter-parent från projektet för att hämta ett avsnitt om beroendehantering så att Spring kan hantera versioner för beroenden.

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

Med den här konfigurationen kan du även åsidosätta enskilda beroenden genom att åsidosätta en egenskap i ditt eget projekt. Om du till exempel vill uppgradera till ett annat Spring Data-release-träna lägger du till följande i dinpom.xml.

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

Om du inte vill använda kan du behålla fördelen med beroendehanteringen genom spring-boot-starter-parent att använda ett scope=import beroende:

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

Med den här konfigurationen kan du inte åsidosätta enskilda beroenden med hjälp av en egenskap enligt förklaringen ovan. För att uppnå samma resultat måste du lägga till en post i dependencyManagement för projektet före spring-boot-dependencies posten. Om du till exempel vill uppgradera till ett annat Spring Data-release-träna lägger du till följande i pom.xml.

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

Anteckning

Ersätt och ${spring.boot.version} med de versioner av Spring Boot och Spring Data som du vill använda i ${spring.data.version} projektet.

Komma igång

Inkludera paketet

Om du använder Maven lägger du till följande beroende.

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

Förutsättningar

  • Java Development Kit (JDK), version 8 eller senare.
  • Ett aktivt Azure-konto. Om du inte har ett kan du registrera dig för en kostnadsfri utvärderingsversion. Du kan också använda Azure Cosmos DB Emulator för utveckling och testning. Eftersom https-certifikatet för emulatorn är själv signerat måste du importera dess certifikat till Java-arkivet för betrodda certifikat, vilket förklaras här
  • (Valfritt) SLF4J är en loggningsfasad.
  • (Valfritt) SLF4J-bindning används för att associera ett specifikt loggningsramverk med SLF4J.
  • (Valfritt) Maven

SLF4J behövs bara om du planerar att använda loggning. Ladda även ned en SLF4J-bindning som länkar SLF4J-API:et med valfri loggningsimplementering. Mer information finns i användarhandboken för SLF4J.

Konfigurera konfigurationsklass

För att konfigurera konfigurationsklassen måste du utöka AbstractCosmosConfiguration

Azure-spring-data-cosmos stöder också Response Diagnostics String och Query Metrics . Ange queryMetricsEnabled flaggan till true i application.properties för att aktivera frågemått. Förutom att ange flaggan implementerar du för ResponseDiagnosticsProcessor att logga diagnostikinformation.

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

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

    @Override
    public CosmosConfig cosmosConfig() {
        return CosmosConfig.builder()
                           .enableQueryMetrics(queryMetricsEnabled)
                           .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);
        }
    }

}

Anpassa konfiguration

Du kan anpassa DirectConnectionConfig eller eller både och och och tillhandahålla dem som ska GatewayConnectionConfigCosmosClientBuilder anpassas CosmosAsyncClient

@Bean
public CosmosClientBuilder getCosmosClientBuilder() {

    DirectConnectionConfig directConnectionConfig = new DirectConnectionConfig();
    GatewayConnectionConfig gatewayConnectionConfig = new GatewayConnectionConfig();
    return new CosmosClientBuilder()
        .endpoint(uri)
        .directMode(directConnectionConfig, gatewayConnectionConfig);
}

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

Som standard @EnableCosmosRepositories genomsöker det aktuella paketet alla gränssnitt som utökar ett av Spring Datas lagringsplatsgränssnitt. Använd den för att kommentera configuration-klassen och genomsöka ett annat rotpaket @EnableCosmosRepositories(basePackageClass=UserRepository.class) med om projektlayouten har flera projekt.

Definiera en entitet

Definiera en enkel entitet som objekt i Azure Cosmos DB.

Du kan definiera entiteter genom att lägga till anteckningen och ange egenskaper som är relaterade till containern, till exempel containernamn, enheter för programbegäran @Container (RU:er), time to live och automatiskt skapa container.

Containrar skapas automatiskt om du inte vill det. Ställ autoCreateContainer in på false i anteckningar för att inaktivera automatisk @Container generering av containrar.

Anteckning

Som standard tilldelas enheter för begäran till nyligen skapade containrar 400. Ange ett annat ru-värde för att anpassa enheter för begäran för containern som skapats av SDK:n (minsta RU-värde är 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;
    }
}

Fältet id används som objekt-ID i Azure Cosmos DB. Om du vill använda ett annat fält firstName som objekt id kommenterar du bara fältet med @Id anteckningar.

Anteckningen anger @Container(containerName="myContainer") containernamnet i Azure Cosmos DB.

Kommentaren i fältet @PartitionKey anger det här fältet som lastName partitionsnyckel i Azure Cosmos DB.

Skapa containrar med dataflöde för autoskalning

Kommentarsfältet anger autoScale att containern ska skapas med dataflödet för automatisk skalning om värdet är true. Standardvärdet är false, vilket innebär att containrar skapas med manuellt dataflöde.

Läs mer om dataflöde för autoskalning här

@Container(containerName = "myContainer", autoScale = true, ru = "4000")
public class UserSample {
    @Id
    private String emailAddress;

}

Stöd för kapslad partitionsnyckel

Spring Data Cosmos SDK stöder kapslad partitionsnyckel. Om du vill lägga till kapslad partitionKeyPath partitionsnyckel använder du fältet i @Container anteckningen.

partitionKeyPath bör endast användas för att stödja kapslad partitionsnyckelsökväg. Använd -anteckningen för allmänt @PartitionKey stöd för partitionsnyckel.

Som standard @PartitionKey har kommentaren företräde, om inget annat anges.

I följande exempel visas hur du använder funktionen Kapslad partitionsnyckel korrekt.

@Container(containerName = "nested-partition-key", partitionKeyPath = "/nestedEntitySample/nestedPartitionKey")
public class NestedPartitionKeyEntitySample {

    private NestedEntitySample nestedEntitySample;
}

public class NestedEntitySample {
    private String nestedPartitionKey;
}

Skapa lagringsplatsen

Utökar CosmosRepository-gränssnittet, som ger stöd för Spring Data-lagringsplatsen.

@Repository
public interface UserRepository extends CosmosRepository<User, String> {
    Iterable<User> findByFirstName(String firstName);
    long countByFirstName(String firstName);
    User findOne(String id, String lastName);
}
  • findByFirstName metoden är anpassad frågemetod. Den hittar objekt per firstName.

QueryAnnotation: Använda kommenterade frågor i lagringsplatsen

Azure Spring Data Cosmos har stöd för att ange kommenterade frågor i lagringsplatsen med hjälp av @Query .

Här följer några exempel på kommenterade frågor i synkrona CosmosRepository :

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

Här följer några exempel på kommenterade frågor i 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);
}

Frågorna som anges i kommentaren är samma som Cosmos-frågorna. Mer information om hur du SQL i Cosmos finns i följande artiklar:

Skapa en programklass

Här skapar du en programklass med alla komponenter.

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

    }
}

Autokoda UserRepository gränssnittet för att utföra åtgärder som att spara, ta bort, hitta och så vidare.

Spring Data Azure Cosmos DB använder CosmosTemplate och ReactiveCosmosTemplate för att köra frågorna bakom CosmosTemplate- och ReactiveCosmosTemplate Du kan använda mallen själv för mer komplexa frågor.

Viktiga begrepp

CrudRepository och ReactiveCrudRepository

Azure Spring Data Cosmos stöder ReactiveCrudRepository och CrudRepository som tillhandahåller grundläggande CRUD-funktioner:

  • save
  • findAll
  • findOne efter ID
  • deleteAll
  • ta bort efter ID
  • ta bort entitet

Spring Data-anteckningar

Det finns två sätt att mappa ett fält i domänklassen till fältet för Azure Cosmos DB Item: – kommentera ett fält i domänklassen med . Det här fältet mappas till id@Id Objekt i id Cosmos DB. – Ange namnet på det här fältet id till . Det här fältet mappas till Objekt i id Azure Cosmos DB.

Stöder automatisk generering av strängtypen UID:er med hjälp @GeneratedValue-anteckningen. ID-fältet för en entitet med ett strängtyps-ID kan kommenteras med för att automatiskt generera ett @GeneratedValue slumpmässigt UUID före infogningen.

public class GeneratedIdEntity {

    @Id
    @GeneratedValue
    private String id;

}
  • SpEL-uttryck och anpassat containernamn.
    • Som standard är containernamnet klassnamnet för användardomänklassen. Om du vill anpassa det lägger du till @Container(containerName="myCustomContainerName")-kommentaren i domänklassen. Containerfältet stöder också SpEL-uttryck (t.ex. container = "${dynamic.container.name}" eller container = "#{@someBean.getContainerName()}" ) för att kunna ange containernamn programmässigt/via konfigurationsegenskaper.
    • För att SpEL-uttryck ska fungera korrekt måste du lägga @DependsOn("expressionResolver") till ovanpå Spring Application-klassen.
@SpringBootApplication
@DependsOn("expressionResolver")
public class SampleApplication {

}
  • Custom IndexingPolicy Som standard anges IndexingPolicy av Azure-tjänsten. Om du vill anpassa den lägger du till anteckningar @CosmosIndexingPolicy i domänklassen. Den här anteckningen har 4 attribut att anpassa, se följande:
// 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 {};

Azure Cosmos DB Partition

Azure-spring-data-cosmos stöder Azure Cosmos DB partition.

Om du vill ange att ett fält i domänklassen ska vara partitionsnyckelfält kommenterar du det med @PartitionKey .

När du utför CRUD-åtgärden anger du partitionsvärdet.

Mer exempel på partitions-CRUD finns i test här

Optimistisk låsning

Azure-spring-data-cosmos har stöd för optimistisk låsning för specifika containrar, vilket innebär att upserts/borttagningar efter objekt misslyckas med ett undantag om objektet ändras av en annan process under tiden.

Om du vill aktivera optimistisk låsning för en container skapar du _etag bara ett strängfält och markerar det @Version med anteckningen . Se följande:

@Container(containerName = "myContainer")
public class MyItem {
    String id;
    String data;
    @Version
    String _etag;
}

Anpassad Spring Data-fråga, sidindebar och sortering

Azure-spring-data-cosmos stöder anpassade spring-data-frågor,till exempel en find-åtgärd som

Stöder Spring Data Pageable, Slice och Sort. – Baserat på tillgängliga RU:er på databaskontot kan cosmosDB returnera objekt som är mindre än eller lika med den begärda storleken. – På grund av det här variabelantalet returnerade objekt i varje iteration bör användaren inte förlita sig på totalPageSize, utan i stället iterera över växlingsbar bör göras på det här sättet.

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 Data Rest

Azure-spring-data-cosmos stöder spring-boot-starter-data-rest.

  • Stöder listtyp och kapslad typ i domänklass.
  • Konfigurerbar ObjectMapper-böna med unikt namn cosmosObjectMapper konfigurerar du bara anpassade ObjectMapper om du verkligen behöver det. Till exempel:
@Bean(name = "cosmosObjectMapper")
public ObjectMapper objectMapper() {
    return new ObjectMapper(); // Do configuration to the ObjectMapper if required
}

Granskning

Azure-spring-data-cosmos stöder granskningsfält på databasentiteter med hjälp av spring-data-standardanteckningar.

Den här funktionen kan aktiveras genom att @EnableCosmosAuditing lägga till anteckningar i programkonfigurationen.

Entiteter kan kommentera fält med @CreatedBy hjälp av , och @CreatedDate@LastModifiedBy@LastModifiedDate . De här fälten uppdateras automatiskt.

@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 av flera databaser

Azure-spring-data-cosmos stöder konfiguration av flera databaser, inklusive "flera databaskonton" och "enskilt konto, med flera databaser".

Konton med flera databaser

I exemplet används filen application.properties:

# 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

Definitionen för Entitet och lagringsplats liknar den ovan. Du kan placera olika databasentiteter i olika paket.

Eller stöder användar definiera cosmos-mallen, använder eller för att ange namnet på eller bönan som ska användas med de identifierade @EnableReactiveCosmosRepositories@EnableCosmosRepositoriesreactiveCosmosTemplateRefcosmosTemplateRefReactiveCosmosTemplateCosmosTemplate lagringsplatsen.

Om du har flera Cosmos-databaskonton kan du definiera flera CosmosAsyncClient . Om det enskilda Cosmos-kontot har flera databaser kan du använda samma CosmosAsyncClient för att initiera Cosmos-mallen.

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

I exemplet ovan har vi två Cosmos-konton. Du kan skapa så CosmosAsyncClient här:

@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)
        .responseDiagnosticsProcessor(new ResponseDiagnosticsProcessorImplementation())
        .build();
}

Om du vill definiera queryMetricsEnabled eller kan du skapa för ResponseDiagnosticsProcessorCosmosConfig Cosmos-mallen.

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

Skapa en Application klass:

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

Enskilt konto med flera databaser

I exemplet används filen application.properties:

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

Definitionen för Entitet och lagringsplats liknar den ovan. Du kan placera olika databasentiteter i olika paket.

Du kan använda EnableReactiveCosmosRepositories med olika för att definiera flera databaser i ett enda reactiveCosmosTemplateRef Cosmos-konto.

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

    }
}

Skapa en Application klass:

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

Betaversionspaket

Betaversion som skapats master från gren är tillgänglig. Du kan referera till master använda betaversionspaket.

Felsökning

Allmänt

Om du stöter på en bugg kan du skicka in ett problem här.

Om du vill föreslå en ny funktion eller ändringar som kan göras kan du öppna ett ärende på samma sätt som för en bugg.

Aktivera klientloggning

Azure-spring-data-cosmos använder SLF4j som loggningsfasad som stöder inloggning i populära loggningsramverk som log4j och logback. Om du till exempel vill använda spring logback som loggningsramverk lägger du till följande xml i resursmappen.

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

Exempel

Se exempelprojektet här.

Konton med flera databaser

Se exempelprojektet för flera databaser.

Enskilt konto med flera databaser

Se exempelprojektet Enskilt konto med flera databaser.

Nästa steg

Bidra

Det här projektet välkomnar bidrag och förslag. De flesta bidrag kräver att du godkänner ett licensavtal för bidragsgivare (CLA) som deklarerar att du har rätt till och faktiskt ger oss rättigheter att använda ditt bidrag.

När du skickar en pull-förfrågan avgör en CLA-robot automatiskt om du måste tillhandahålla ett licensavtal för bidrag med lämplig PR (t.ex. etikett eller kommentar). Följ bara robotens anvisningar. Du behöver bara göra detta en gång för alla repor som använder vårt licensavtal för bidrag.

Det här projektet använder sig av Microsofts uppförandekod för öppen källkod. Mer information finns i Vanliga frågor och svar om uppförandekoden eller kontakta om du har ytterligare frågor eller kommentarer.

Visningar