Comment construire et tester une API Spring Boot avec Apidog

```html

Avez-vous déjà voulu créer une application web ou un microservice avec Java, mais vous êtes-vous senti dépassé par la complexité et la configuration impliquées ? Si c'est le cas, vous n'êtes pas seul. De nombreux développeurs sont aux prises avec les défis du développement web, tels que la configuration du serveur, la gestion des dépendances, la gestion de la base de données, et plus encore.

C'est pourquoi Spring Boot change la donne. Spring Boot est un framework qui simplifie le développement web avec Java. Il offre des fonctionnalités telles que l'auto-configuration, les serveurs intégrés, les dépendances de démarrage, et plus encore. Avec Spring Boot, vous pouvez vous concentrer sur l'écriture de votre logique métier, plutôt que de vous occuper du code passe-partout.

Mais créer une application web ou un microservice ne suffit pas. Vous devez également le tester. Les tests sont essentiels pour garantir la qualité et la fiabilité de votre logiciel. Ils vous aident à trouver et à corriger les bogues, à améliorer les performances et à prévenir les erreurs.

C'est là qu'Apidog entre en jeu.

💡

Apidog est un outil qui vous aide à tester et à déboguer vos API. Il vous permet de vous connecter à votre API et d'explorer les points de terminaison, de créer et d'exécuter des cas de test, et de générer des rapports. Avec Apidog, vous pouvez tester votre API plus rapidement et plus facilement, sans écrire de code.

button

Dans cet article de blog, vous apprendrez comment créer et tester une API Spring Boot avec Apidog. Vous créerez une simple API RESTful avec Spring Boot et la testerez avec Apidog.

Qu'est-ce que Spring Boot et pourquoi l'utiliser ?

Spring Boot est un framework qui simplifie le développement des applications Spring. Il fournit de nombreuses fonctionnalités et conventions qui facilitent la création, la configuration, l'exécution et le déploiement des applications Spring. Certains des avantages de l'utilisation de Spring Boot sont :

Il dispose d'un système de gestion des dépendances de démarrage qui ajoute automatiquement les bibliothèques et les versions requises pour votre projet.
Il dispose d'un serveur web intégré qui vous permet d'exécuter votre application sans aucune configuration ou installation supplémentaire.
Il dispose d'un mécanisme d'auto-configuration qui détecte et applique les paramètres optimaux pour votre application en fonction des dépendances et de l'environnement.
Il dispose d'une prise en charge prête pour la production qui comprend des fonctionnalités telles que les contrôles d'intégrité, les métriques, la journalisation et la sécurité.

Avec Spring Boot, vous pouvez vous concentrer sur l'écriture de votre logique métier et laisser le framework gérer le reste.

Qu'est-ce qu'Apidog et comment peut-il vous aider à tester votre API ?

Apidog est un outil qui vous aide à tester vos API de manière simple et intuitive. Il vous permet de vous connecter à votre API, d'explorer les points de terminaison et de créer et d'exécuter des cas de test pour votre API. Certaines des fonctionnalités d'APIdog sont :

Il dispose d'une interface utilisateur graphique qui facilite l'interaction avec votre API et la visualisation des résultats.
Il dispose d'un éditeur de code qui vous permet d'écrire et de modifier vos cas de test à l'aide d'assertions JavaScript et Chai.
Il dispose d'un exécuteur de tests qui exécute vos cas de test et vous montre l'état, la sortie et les erreurs de chaque test.
Il dispose d'un générateur de rapports qui crée un rapport complet et personnalisable de vos résultats de test.

Avec Apidog, vous pouvez tester votre API de manière rapide et fiable et garantir sa qualité et sa fonctionnalité.

Configuration du projet

La première étape consiste à créer un projet Spring Boot avec Spring Initializr. Spring Initializr est un outil web qui génère une structure et une configuration de projet de base pour vous en fonction de vos préférences. Pour utiliser Spring Initializr, suivez ces étapes :

Accédez à https://start.spring.io/ et renseignez les détails de votre projet. Pour cet exemple, j'utiliserai les paramètres suivants :

Project : Maven Project
Language : Java
Spring Boot : 3.2.3
Project Metadata :
Group : com.example
Artifact : apidog-demo
Name : apidog-demo
Description : Demo project for Spring Boot
Package name : com.example.apidog-demo
Packaging : Jar
Java : 17
Dependencies : Spring Web, Spring Data JPA, H2 Database

Cliquez sur le bouton GENERATE et téléchargez le fichier zip de votre projet.

Extrayez le fichier zip et ouvrez le projet dans votre IDE préféré.

Ajout des dépendances pour Spring Web et Spring Data JPA

L'étape suivante consiste à ajouter les dépendances pour Spring Web et Spring Data JPA. Spring Web est un module qui fournit le support web essentiel pour la création d'API RESTful avec Spring. Spring Data JPA est un module qui simplifie l'accès et la manipulation des données dans les bases de données relationnelles à l'aide de JPA et Hibernate.

Pour ajouter ces dépendances, vous pouvez utiliser Spring Initializr comme mentionné ci-dessus, ou vous pouvez modifier manuellement le fichier pom.xml de votre projet et ajouter les dépendances suivantes :

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
  <groupId>com.h2database</groupId>
  <artifactId>h2</artifactId>
  <scope>runtime</scope>
</dependency>

Configuration des propriétés de l'application

L'étape suivante consiste à configurer les propriétés de l'application. Le fichier application.properties est un fichier qui contient les paires clé-valeur qui définissent le comportement et les paramètres de votre application. Pour cet exemple, nous utiliserons les propriétés suivantes :

# Enable the H2 console for accessing the database
spring.h2.console.enabled=true
# Set the path of the H2 console
spring.h2.console.path=/h2-console
# Set the URL of the database
spring.datasource.url=jdbc:h2:mem:testdb
# Set the username of the database
spring.datasource.username=sa
# Set the password of the database
spring.datasource.password=
# Set the dialect of the database
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
# Show the SQL statements in the console
spring.jpa.show-sql=true
# Generate the database schema from the entity classes
spring.jpa.hibernate.ddl-auto=update
# Enable the Swagger UI for documenting the API
springdoc.swagger-ui.enabled=true
# Set the path of the Swagger UI
springdoc.swagger-ui.path=/swagger-ui.html

Création de l'API

L'étape suivante consiste à créer l'API. L'API se composera d'un modèle de domaine, d'un référentiel et d'un contrôleur pour une entité simple appelée Book. Un Book aura les propriétés suivantes : id, title, author et price.

Création du modèle de domaine et d'un référentiel pour une entité simple

Le modèle de domaine est une classe qui représente les données et le comportement de l'entité. Le référentiel est une interface qui étend l'interface JpaRepository et fournit les méthodes d'accès et de manipulation des données de l'entité.

Pour créer le modèle de domaine et le référentiel pour l'entité Book, suivez ces étapes :

Créez un nouveau package appelé com.example.apidogdemo.model et créez une nouvelle classe appelée Book.java à l'intérieur.
Annotez la classe avec @Entity pour la marquer comme une entité JPA et @Table pour spécifier le nom de la table dans la base de données.
Définissez les propriétés de la classe et annotez-les avec @Id, @GeneratedValue, @Column et @NotNull pour spécifier respectivement la clé primaire, la stratégie de génération, le nom de la colonne et la contrainte de validation.
Générez les getters et setters, le constructeur et la méthode toString pour la classe.

La classe Book.java devrait ressembler à ceci :

package com.example.apidogdemo.model;

import javax.persistence.*;
import javax.validation.constraints.NotNull;
import java.math.BigDecimal;

@Entity
@Table(name = "books")
public class Book {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "title")
    @NotNull
    private String title;

    @Column(name = "author")
    @NotNull
    private String author;

    @Column(name = "price")
    @NotNull
    private BigDecimal price;

    public Book() {
    }

    public Book(Long id, String title, String author, BigDecimal price) {
        this.id = id;
        this.title = title;
        this.author = author;
        this.price = price;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public BigDecimal getPrice() {
        return price;
    }

    public void setPrice(BigDecimal price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Book{" +
                "id=" + id +
                ", title='" + title + '\'' +
                ", author='" + author + '\'' +
                ", price=" + price +
                '}';
    }
}

Créez un nouveau package appelé com.example.apidogdemo.repository et créez une nouvelle interface appelée BookRepository.java à l'intérieur.
Annotez l'interface avec @Repository pour la marquer comme un référentiel Spring Data JPA.
Étendez l'interface JpaRepository et spécifiez le type d'entité et le type de clé primaire comme paramètres génériques.
Facultativement, vous pouvez définir des méthodes personnalisées pour interroger les données de l'entité.

L'interface BookRepository.java devrait ressembler à ceci :

package com.example.apidogdemo.repository;

import com.example.apidogdemo.model.Book;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface BookRepository extends JpaRepository<Book, Long> {
    // You can define custom methods here
}

Création d'un contrôleur et définition des points de terminaison pour les opérations CRUD

Le contrôleur est une classe qui gère les requêtes et les réponses de l'API. Le contrôleur définit les points de terminaison pour les opérations CRUD (créer, lire, mettre à jour et supprimer) pour l'entité.

Pour créer le contrôleur et définir les points de terminaison pour l'entité Book, suivez ces étapes :

Créez un nouveau package appelé com.example.apidogdemo.controller et créez une nouvelle classe appelée BookController.java à l'intérieur.
Annotez la classe avec @RestController pour la marquer comme un contrôleur Spring MVC qui renvoie des réponses JSON.
Annotez la classe avec @RequestMapping pour spécifier le chemin de base des points de terminaison.
Injectez l'instance BookRepository à l'aide de l'annotation @Autowired.
Définissez les points de terminaison pour les opérations CRUD à l'aide des annotations @GetMapping, @PostMapping, @PutMapping et @DeleteMapping et spécifiez le chemin et les paramètres de chaque point de terminaison.
Utilisez la classe ResponseEntity pour encapsuler les données de réponse et le code d'état pour chaque point de terminaison.
Utilisez l'annotation @Valid pour valider le corps de la requête pour les points de terminaison de création et de mise à jour.
Utilisez les annotations @ExceptionHandler et @ResponseStatus pour gérer les exceptions et renvoyer le code d'état et le message appropriés.

La classe BookController.java devrait ressembler à ceci :

package com.example.apidogdemo.controller;

import com.example.apidogdemo.model.Book;
import com.example.apidogdemo.repository.BookRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.server.ResponseStatusException;

import javax.validation.Valid;
import java.util.List;
import java.util.Optional;

@RestController
@RequestMapping("/api/books")
public class BookController {

    @Autowired
    private BookRepository bookRepository;

    // Get all books
    @GetMapping
    public ResponseEntity<List<Book>> getAllBooks() {
        List<Book> books = bookRepository.findAll();
        return new ResponseEntity<>(books, HttpStatus.OK);
    }

    // Get a book by id
    @GetMapping("/{id}")
    public ResponseEntity<Book> getBookById(@PathVariable Long id) {
        Optional<Book> book = bookRepository.findById(id);
        if (book.isPresent()) {
            return new ResponseEntity<>(book.get(), HttpStatus.OK);
        } else {
            throw new ResponseStatusException(HttpStatus.NOT_FOUND, "Book not found");
        }
    }

    // Create a book
    @PostMapping
    public ResponseEntity<Book> createBook(@Valid @RequestBody Book book) {
        Book savedBook = bookRepository.save(book);
        return new ResponseEntity<>(savedBook, HttpStatus.CREATED);
    }

    // Update a book by id
    @PutMapping("/{id}")
    public ResponseEntity<Book> updateBook(@PathVariable Long id, @Valid @RequestBody Book book) {
        Optional<Book> existingBook = bookRepository.findById(id);
        if (existingBook.isPresent()) {
            book.setId(id);
            Book updatedBook = bookRepository.save(book);
            return new ResponseEntity<>(updatedBook, HttpStatus.OK);
        } else {
            throw new ResponseStatusException(HttpStatus.NOT_FOUND, "Book not found");
        }
    }

    // Delete a book by id
    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteBook(@PathVariable Long id) {
        Optional<Book> existingBook = bookRepository.findById(id);
        if (existingBook.isPresent()) {
            bookRepository.deleteById(id);
            return new ResponseEntity<>(HttpStatus.NO_CONTENT);
        } else {
            throw new ResponseStatusException(HttpStatus.NOT_FOUND, "Book not found");
        }
    }

    // Handle the validation exceptions
    @ExceptionHandler(javax.validation.ConstraintViolationException.class)
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    public String handleValidationExceptions(javax.validation.ConstraintViolationException ex) {
        return ex.getMessage();
    }
}

Test de l'API Spring boot avec APIdog

La dernière étape consiste à tester l'API avec Apidog. Apidog est un outil qui vous aide à tester vos API de manière simple et intuitive. Il vous permet de vous connecter à votre API, d'explorer les points de terminaison et de créer et d'exécuter des cas de test pour votre API.

button

Pour tester l'API avec Apidog, suivez ces étapes :

Lancez Apidog et créez un nouveau projet en cliquant sur le bouton Nouveau projet.

Entrez le nom et la description de votre projet et cliquez sur le bouton Créer.

Enter details to create new project on Apidog

Entrez l'URL de base de votre API et cliquez sur le bouton Connecter.

Vous pouvez voir la liste des points de terminaison de votre API dans le panneau de gauche. Vous pouvez cliquer sur chaque point de terminaison pour voir les détails et les exemples dans le panneau de droite.

Vous pouvez créer et exécuter des cas de test pour votre API en cliquant sur l'onglet Cas de test dans le panneau de droite. Vous pouvez utiliser l'éditeur de code pour écrire et modifier vos cas de test à l'aide d'assertions JavaScript et Chai.

Vous pouvez utiliser l'exécuteur de tests pour exécuter vos cas de test et voir l'état, la sortie et les erreurs de chaque test. Vous pouvez utiliser le générateur de rapports pour créer un rapport complet et personnalisable de vos résultats de test.

Conclusion

Dans cet article de blog, vous avez appris comment créer et tester une API Spring Boot avec Apidog. Vous avez créé une simple API RESTful avec Spring Boot et l'avez testée avec Apidog.

Spring Boot est un framework qui simplifie le développement web avec Java. Il offre des fonctionnalités telles que l'auto-configuration, les serveurs intégrés, les dépendances de démarrage, et plus encore. Avec Spring Boot, vous pouvez vous concentrer sur l'écriture de votre logique métier, plutôt que de vous occuper du code passe-partout.

button

```