Prise en charge de Spring Data

Cet article décrit comment Spring Cloud Azure et Spring Data peuvent être utilisés ensemble.

Prise en charge d’Azure Cosmos DB Spring Data

Azure Cosmos DB est un service de base de données distribué à l’échelle mondiale qui permet aux développeurs d’utiliser des données à l’aide de diverses API standard, telles que SQL, MongoDB, Graph et Stockage Table Azure.

Configuration des dépendances

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

Paramétrage

Le tableau suivant répertorie les propriétés configurables de spring-cloud-azure-starter-data-cosmos:

Concepts clés

La liste suivante présente les concepts clés de la prise en charge de Spring Data :

• Spring Data CrudRepository et ReactiveCrudRepository, qui fournissent les fonctionnalités CRUD de base suivantes :

  • sauvegarder
  • findAll
  • findOne par ID
  • deleteAll
  • supprimer par ID
  • supprimer une entité

• Annotation spring Data @Id. Il existe deux façons de mapper un champ dans une classe de domaine au id d’un document Azure Cosmos DB :

  • Annotez un champ dans la classe de domaine avec @Id. Ce champ est mappé au document id dans Azure Cosmos DB.
  • Définissez le nom de ce champ sur id. Ce champ est mappé au document id dans Azure Cosmos DB.

  Remarque

  Si les deux méthodes sont appliquées, l’annotation @Id a une priorité plus élevée.

• Noms de collection personnalisés. Par défaut, le nom de collection sera le nom de classe de la classe de domaine utilisateur. Pour le personnaliser, ajoutez des @Document(collection="myCustomCollectionName") d’annotation à votre classe de domaine, c’est tout.

• Prend en charge partition Azure Cosmos DB. Pour spécifier un champ de votre classe de domaine à utiliser comme champ de clé de partition, annotez-le avec @PartitionKey. Lorsque vous effectuez des opérations CRUD, spécifiez votre valeur de partition. Pour plus d’exemples, consultez AddressRepositoryIT.java sur GitHub.

• Prend en charge requête personnalisée Spring Data opération de recherche.

• Prend en charge spring-boot-starter-data-rest.

• Prend en charge les types list et imbriqués dans les classes de domaine.

Utilisation de base

Utiliser une clé privée pour accéder à Azure Cosmos DB

Le moyen le plus simple de connecter Azure Cosmos DB avec spring-cloud-azure-starter-data-cosmos est avec une clé primaire. Ajoutez les propriétés suivantes :

spring:
  cloud:
    azure:
      cosmos:
        key: ${AZURE_COSMOS_KEY}
        endpoint: ${AZURE_COSMOS_ENDPOINT}
        database: ${AZURE_COSMOS_DATABASE}

Définir une entité

Définissez une entité en tant que document dans Azure Cosmos DB, comme illustré dans l’exemple suivant :

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

Le champ id sera utilisé comme id de document dans Azure Cosmos DB. Vous pouvez également annoter n’importe quel champ avec @Id pour le mapper au document id.

L’annotation @Container(containerName = "mycollection") est utilisée pour spécifier le nom de la collection de votre document dans Azure Cosmos DB.

Créer des référentiels

Pour créer des référentiels, étendez l’interface ReactiveCosmosRepository, qui fournit la prise en charge des référentiels Spring Data.

@Repository
public interface UserRepository extends ReactiveCosmosRepository<User, String> {
    Flux<User> findByFirstName(String firstName);
}

Actuellement, l’interface ReactiveCosmosRepository fournit des opérations d’enregistrement, de suppression et de recherche de base. D’autres opérations seront prises en charge ultérieurement.

Créer une classe d’application

L’exemple suivant crée une classe d’application avec tous les composants :

@SpringBootApplication
public class CosmosSampleApplication implements CommandLineRunner {

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

    @Autowired
    private UserRepository repository;

    @Autowired
    private CosmosProperties properties;

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

    public void run(String... var1) {
        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());

    }

    @PostConstruct
    public void setup() {
        // For this example, remove all of the existing records.
        this.repository.deleteAll().block();
    }
}

Cet exemple inclut une interface de UserRepository automatiquement câblée pour prendre en charge les opérations d’enregistrement, de suppression et de recherche.

Échantillons

Consultez gitHub azure-spring-boot-samples .

Outre l’utilisation de la bibliothèque spring-cloud-azure-starter-data-cosmos, vous pouvez utiliser directement azure-spring-data-cosmos bibliothèque pour des scénarios plus complexes. Pour plus d’informations, consultez bibliothèque de client Spring Data pour Azure Cosmos DB.