Comment créer une API REST avec Spring Boot

2023/01/16

L’acronyme REST signifie REpresentational State Transfer, tandis que API signifie Application Programming Interface. Ensemble, ils font référence à une API REST. Une API REST est un service qui transfère les requêtes et les réponses entre deux systèmes logiciels, sur une architecture REST.

L’architecture REST crée des services Web accessibles via des URL à l’aide de l’un des quatre verbes de requête : POST, GET, PUT et DELETE. Ainsi, vous pourriez dire qu’une API REST est un logiciel qui vous permet de créer, lire, mettre à jour et supprimer des ressources via des URL.

Vous pouvez apprendre à créer une API REST à l’aide de Spring Boot.

Initialisation de l’application Spring Boot

La première chose à faire est de vous familiariser avec les bases de Spring et de configurer une application Spring Boot. Vous devrez cependant modifier les dépendances. En plus de la dépendance Web, vous devrez obtenir la dépendance Spring Data Java Persistent API (JPA) et le pilote de la base de données que vous avez l’intention d’utiliser (cette application utilisera MySQL).

Pour cette API REST, vous aurez besoin d’un contrôleur, d’un modèle et d’un référentiel. Ainsi, l’API REST aura la structure de fichiers suivante :

Création du modèle

La première classe que vous devrez créer est le modèle client, qui stocke la logique des données.

package com.onlineshopaholics.api.model;

import jakarta.persistence.Column; import jakarta.persistence.Entity; import jakarta.persistence.GeneratedValue; import jakarta.persistence.GenerationType; import jakarta.persistence.Id; import jakarta.persistence.Table;


@Table(name="customer")
@Entity
public class Customer {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Integer id;
    @Column(name="customername")
    private String name;
    private String email;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getEmail() {
        return email;
    }

public void setEmail(String email) { this.email = email; } }

À partir de la classe de clients ci-dessus, vous verrez que chaque client aura un identifiant, un nom et un e-mail. Vous remarquerez également plusieurs annotations qui servent à des fins différentes.

@Entity : Déclare la classe de clients en tant qu’entité JPA. Cela signifie que JPA utilisera les champs de la classe pour créer des colonnes dans une base de données relationnelle.
@Table : désigne le nom de la table qui sera mappée à la classe de modèle client.
@Id : Désigne une propriété qui identifiera de manière unique l’entité dans la base de données.
@GeneratedValue et @GenerationType : ces éléments fonctionnent ensemble pour spécifier une stratégie de génération automatique pour le champ auquel il est associé. Ainsi, le champ id générera automatiquement une valeur unique à chaque fois que vous créerez un nouveau client.
@Column : désigne une propriété qui correspond à une colonne de la base de données. Ainsi, la propriété name correspondra à une colonne de nom de client dans la base de données.

Création du référentiel

Ce référentiel vous permettra d’interagir avec les données clients de la base de données.

package com.onlineshopaholics.api.repository;

import org.springframework.data.repository.CrudRepository; import com.onlineshopaholics.api.model.Customer;


public interface CustomerRepository extends CrudRepository<Customer, Integer>{}

Le référentiel client étend l’interface CrudRepositoy<T,ID> de Spring , en lui transmettant la classe de modèle Customer avec le type de l’identifiant unique de l’entité, Integer.

L’interface CrudRepository donne accès à plus de 10 opérations, y compris les méthodes CRUD génériques dont vous aurez besoin pour l’API REST. Ainsi, étant donné que CrudRepository définit déjà les méthodes dont vous aurez besoin, il n’est pas nécessaire de les déclarer explicitement dans l’interface CustomerRepository.

Création du contrôleur

Le contrôleur vous permet de mettre à jour les données de votre base de données à l’aide du modèle et du référentiel.

package com.onlineshopaholics.api.controller;

import java.util.Optional;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import com.onlineshopaholics.api.model.Customer;
import com.onlineshopaholics.api.repository.CustomerRepository;
@RestController
@RequestMapping("/customers")
public class CustomerController {
    @Autowired
    private CustomerRepository customerRepository;
    // create new customer
    @PostMapping("/add")
    public Customer addNewCustomer(@RequestBody Customer newCustomer){
        Customer user = new Customer();
        user.setName(newCustomer.getName());
        user.setEmail(newCustomer.getEmail());
        customerRepository.save(user);
        return user; 
    }
    // view all customers
    @GetMapping("view/all")
    public @ResponseBody Iterable<Customer> getAllCustomers(){
        return customerRepository.findAll();
    }
    // view specific customer
    @GetMapping("view/{id}")
    public Optional<Customer> getCustomer(@PathVariable Integer id) {
        return customerRepository.findById(id);
    }
    // update an existing customer
    @PutMapping("/edit/{id}")
    public String update(@RequestBody Customer updateCustomer, @PathVariable Integer id) {
        return customerRepository.findById(id)
                 .map(customer -> {
                       customer.setName(updateCustomer.getName());
                       customer.setEmail(updateCustomer.getEmail());
                       customerRepository.save(customer);
                       return "Customer details have been successfully updated!";
                 }).orElseGet(() -> {
                       return "This customer doesn't exist";
                 });
    }
    // delete customer
    @DeleteMapping("delete/{id}")
    public String delete(@PathVariable("id")Integer id) {
        customerRepository.deleteById(id); 
        return "Customer has been successfully deleted!";
    }
}

Le contrôleur ci-dessus équipe l’API REST d’opérations CRUD, en utilisant cinq des méthodes d’interface CrudRepository<T,ID> (chacune affectée à une méthode spécifique). Le contrôleur utilise également plusieurs annotations Spring importantes qui lui permettent d’exécuter ses fonctions.

@RestController : cette annotation a deux objectifs. Il marque une classe pour la découverte par l’analyse des composants. Il indique également à Spring d’écrire la valeur de retour pour toutes les méthodes de cette classe dans le corps de la réponse.
@RequestMapping : définit le modèle de demande de base que le contrôleur gérera. Ainsi, ce contrôleur traitera toutes les demandes adressées à « /clients ».
@ResponseBody : permet à une méthode de renvoyer une entité entière.
@RequestBody : permet de convertir le corps de la requête en objet.
@RequestParam : permet d’isoler une propriété d’un objet.
@PathVariable : vous permet de mapper une valeur de requête à un espace réservé. Il mappe l’ID donné à la méthode de suppression avec une valeur existante dans la base de données.
@PostMapping : permet de créer des ressources.
@GetMapping : vous permet de lire les données des ressources.
@PutMapping : permet de mettre à jour les ressources.
@DeleteMapping : permet de supprimer des ressources.

Connecter la base de données à votre application

Pour connecter une base de données à n’importe quelle application Spring, vous devez utiliser le fichier application.properties sous le dossier des ressources. Ce fichier est initialement vide, vous pouvez donc le remplir avec les propriétés appropriées pour la base de données que vous avez l’intention d’utiliser. Cette application utilisera une base de données MySQL donc, le fichier application.properties contiendra les données suivantes :

spring.jpa.hibernate.ddl-auto=update spring.jpa.open-in-view=false spring.datasource.url=jdbc:mysql://${MYSQL_HOST:localhost}:3306/onlineshopaholics spring.datasource.username=root spring.datasource.password=securepw spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

Les données ci-dessus montrent que cette application se connectera à une base de données MySQL appelée onlineshopaholics, avec un nom d’utilisateur « root » et « securepw » comme mot de passe. Votre prochaine étape consiste à créer la base de données et la table client dans MySQL.

Création de demandes

Il existe de nombreux outils que vous pouvez utiliser pour tester votre API REST. Postman est un outil de test d’API REST populaire, et vous pouvez l’utiliser pour tester l’API simple que vous avez créée. Après avoir créé la table MySQL et exécuté l’application Spring, vous pouvez lancer Postman et expérimenter les quatre verbes de requête.

Demande POST

Cette requête vous permettra de créer de nouveaux clients à l’aide de l’API REST. Pour compléter cette demande, vous devrez vous rendre dans la section des en-têtes de votre demande de publication et créer un nouvel en-tête (Content-Type). Vous devez définir la valeur de cet en-tête sur application/json, car vous allez créer de nouveaux clients à l’aide de JSON.

Dans le corps de la requête, vous devrez changer le type en raw et insérer votre JSON. Ensuite, vous devrez insérer l’URL du message :

L’envoi de la requête renverra la réponse suivante :

Vous pouvez voir que la demande a réussi et que le nouveau client a également un identifiant.

OBTENIR la requête

Maintenant que vous avez un client, vous pouvez le visualiser avec la requête get qui renvoie tous les clients :

Soit chaque client par identifiant :

Requête PUT

Vous pouvez mettre à jour Janet avec un nouveau nom de famille et une nouvelle adresse e-mail.

Supprimer la demande

Vous pouvez également supprimer Janet de la base de données.

Testez votre API Spring REST à l’aide de JUnit

Avec Spring Boot, vous pouvez tester n’importe quelle application (y compris les API REST) à l’aide du fichier de test de Spring. Les tests logiciels sont importants pour Spring Boot. Chaque application Spring initialisée utilise JUnit pour les tests et vous permet d’envoyer des requêtes à vos API REST.