The gist

Spring Boot offre une manière simple et efficace de créer des API REST. Dans cet article, nous expliquerons comment configurer votre propre API et la connecter à une base de données pour fournir du contenu à vos applications mobiles et Web.

Tech stack

Nous utiliserons la dernière version de Spring, en utilisant le serveur par défaut Apache Tomcat, et nous utiliserons PostgreSQL comme base de données. La machine que j’utiliserai pour ce tutoriel est un serveur Linux, mais notez que, sauf pour la configuration de la base de données, les étapes sont à peu près les mêmes sur les autres systèmes d’exploitation.

Qu’est-ce qu’une API REST? Pourquoi Spring?

Une API REST est un service web qui utilise des méthodes HTTP standard pour la communication et suit les principes de transfert d’état représentationnel (REST). Spring Boot est un framework populaire pour construire des API REST en Java car il simplifie le développement avec ses conventions, son auto-configuration, ainsi qu’une large gamme de bibliothèques et d’outils.

Si vous souhaitez en savoir plus sur le protocole REST, voici quelques liens :

https://fr.wikipedia.org/wiki/REST

Setup

Nous allons diviser la configuration en deux parties : les prérequis (installation de PostgreSQL et Java) et l’installation ainsi que la configuration de Spring

sudo service postgresql start
sudo service postgresql stop

Pour faire fonctionner Spring Boot, se rendre sur le lien suivant:

https://start.spring.io/

Sélectionner les dépendances comme ci-dessous:

Nous utiliserons Java 17 et Maven pour ce projet, mais cela pourrait également être fait avec n’importe quelle autre version de Java et Gradle.

Décompressez votre projet et ouvrez-le avec votre IDE préféré. Voici à quoi cela ressemble sur IntelliJ :

Le répertoire java est l’endroit où nous écrirons notre code.

Notez le fichier pom.xml, c’est là que vous mettrez vos dépendances, et le fichier application.properties, où vous spécifierez les informations relatives à la connexion à la base de données et au port du serveur.

L’API

Pour cet exemple, nous utiliserons une base de données d’animaux pour une animalerie. L’animalerie a une liste d’animaux, chacun associé à un nom, une espèce et un prix. En tant que propriétaire de l’animalerie, vous souhaitez pouvoir répertorier tous les animaux d’une espèce donnée ou répertorier tous les animaux par prix.

La grande chose à propos de Spring est que une fois que vous êtes connecté à la base de données, vous pouvez facilement créer des tables avec les données que vous souhaitez. Celles-ci seront créées sous forme d’objets Java contenant les propriétés que vous souhaitez utiliser.

Mise en place des tables

Nous allons commencer par configurer l’entité de la base de données (dans notre cas, la classe Animal). Créez le fichier suivant dans votre dossier java :

package com.example.demo;

import jakarta.persistence.*;

@Entity
@Table(name = "animals")
public class Animal {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String species;
    private double price;
    private boolean sold;
    // Constructors, getters, and setters can be added here.
// Default constructor
    public Animal() {    }
// Parameterized constructor    
  public Animal(String name, String species, double price, boolean sold) {        
        this.name = name;        
        this.species = species;        
        this.price = price;        
        this.sold = sold;    }
//Parameterized constructor 2    
     public Animal(String name, String species, double price) {
        this.name = name;
        this.species = species;
        this.price = price;
        this.sold=false;
    }  

    @Override
    public String toString() {
        return "Animal{" +
                "id=" + id +
                ", name='" + name + ''' +
                ", species='" + species + ''' +
                ", price=" + price +
                ", sold=" + sold +
                '}';
    }
    // Getters and setters
    public Long getId() {        return id;    }

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

    public String getName() {        return name;    }

    public void setName(String name) {        this.name = name;    }

    public String getSpecies() {        return species;    }

    public void setSpecies(String species) {
        this.species = species;    }

    public double getPrice() {        return price;    }

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

    public boolean isSold() {        return sold;    }

    public void setSold(boolean sold) {        this.sold = sold;    }
}

Dans l’ensemble, cela ressemble à une classe Java régulière. Notez les distinctions suivantes :

1. Il nécessite un constructeur avec toutes les valeurs.
2. Il a l’annotation @Entity, qui signifie que c’est une entité JPA.
3. Il a les annotations @Table qui spécifient le nom de la table de base de données à laquelle cette entité est mappée.
4. L’id de l’animal a deux annotations associées, @Id et @GeneratedValue(strategy = GenerationType.IDENTITY). @Id indique le champ de clé primaire de l’entité. @GeneratedValue(strategy = GenerationType.IDENTITY) configure la stratégie de génération des valeurs de clé primaire.

La prochaine étape dans le développement de notre API consiste à la connecter à une base de données. Pour ce faire, nous travaillerons avec le fichier application.properties.

Vous commencerez par créer un nouvel utilisateur psql, qui sera associé à une base de données. Pour l’exercice, l’utilisateur sera appelé John, associé au mot de passe password1234 (a adapter à votre installation 🙂 ).

Voici à quoi devrait ressembler votre fichier application.properties. Les trois premières lignes spécifient les informations de connexion à la base de données.

La ligne spring.jpa.hibernate.ddl-auto=create-drop indique que la table sera créée lorsque l’application démarre et supprimée lorsque l’application se termine.

Notez que par défaut, lorsque vous exécutez l’application, elle démarrera un serveur sur le port 8080. Pour le changer, vous pouvez ajouter la ligne suivante à votre fichier application.properties :

server.port=8081

Exécutez l’application, et vous devriez remarquer dans la console que la ligne suivante apparaît :

Hibernate: create table animals (price float(53) not null, sold boolean not null, id bigserial not null, name varchar(255), species varchar(255), primary key (id))

Cela signifie que la table a été créée. Maintenant, passons à son accès !

Création des méthodes

La structure de notre code sera organisée comme suit :

Une classe contrôleur contiendra les méthodes que nous utiliserons.

Une classe service contiendra la logique “en coulisse” pour chaque méthode.

Un référentiel (repository) contiendra l’interface entre notre code Java et notre base de données.

The controller:

Nous démarrons par la création de la classe AnimalController:

package com.example.demo;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api/petShopAPI")
public class AnimalController {

@GetMapping("/getAnimals")
public String getAnimals()
{

return "Nothing there yet!";

}
}

Les annotations sont assez simples pour celui-ci :

• @RestController : indique que c’est un contrôleur REST.
• @RequestMapping(“/api/petShopAPI”) : spécifie le chemin d’URL pour ce contrôleur. Cela peut être utile si vous souhaitez avoir plusieurs contrôleurs pour votre API.

Le mappage GET est associé à la méthode getAnimals(), et avec l’extension d’URL /getAnimals. Si vous lancez l’application et accédez à votre navigateur à l’URL :

localhost:8080/api/petShopAPI/getAnimals

Vous devriez voir le texte suivant à l’écran :

Nothing there yet!

Nous allons ensuite créer les méthodes suivantes :

    @PostMapping("/buyAnimal")
    public void buyAnimal(@RequestParam(name="name", required=true)String name, @RequestParam(name="species", required=true)String species, @RequestParam(name="price", required=true) double price )
    {
        
    }

    @PutMapping("/sellAnimal")
    public void sellAnimal(@RequestParam(name="name", required=true)String animalName)
    {

    }

    @DeleteMapping("/removeAnimalFromInventory")
    public void removeAnimal(@RequestParam(name="id", required=true)long animalID)
    {

    }

Ces méthodes sont les points d’extrémité que nous utiliserons pour modifier la base de données des animaux.

L’annotation @RequestParam permet d’ajouter des informations supplémentaires à la requête. Disons que vous souhaitez acheter un Animal (c’est-à-dire l’ajouter à la base de données). Vous passeriez les informations suivantes avec votre requête POST :

name=Mephisto 
species=cat 
price=300.0

Pour des raisons de sécurité, il est parfois préférable d’utiliser des en-têtes plutôt que des paramètres, mais cela sera abordé dans un prochain article de blog.

Pour tester si votre contrôleur de base fonctionne, vous pourriez installer un programme comme Postman qui vous aiderait à générer des requêtes POST, PUT et DELETE.

Ici, j’ai utilisé Postman pour simuler la requête POST mentionnée ci-dessus:

Il m’a généré une réponse 200 OK, ce qui signifie que la requête n’a généré aucune erreur avec notre API.

Le service et le repository:

Actuellement, notre code n’interagit pas beaucoup avec la base de données. Pour résoudre cela, nous allons créer une classe AnimalService et une interface AnimalRepository.

package com.example.demo;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface AnimalRepository extends JpaRepository<Animal, Long> {
}

package com.example.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class AnimalService {
    AnimalRepository animalRepository;

    @Autowired
    public AnimalService(AnimalRepository animalRepository){
        this.animalRepository=animalRepository;
    }
    
}

L’interface AnimalRepository contient des méthodes qui accèdent directement à la base de données. En revanche, la classe AnimalService contiendra la logique réelle de notre code.

L’annotation @Autowired dans le constructeur signale à Spring que lorsqu’il crée une instance de AnimalService, il devrait automatiquement fournir une instance de AnimalRepository.

Nous procéderons de la même manière en ajoutant un constructeur au contrôleur, pour indiquer qu’il doit créer une instance du service :

public class AnimalController {
    AnimalService animalService;
    @Autowired
    public AnimalController(AnimalService animalService) {
        this.animalService = animalService;
    }

    //... Rest of the code goes here
}

Cela nous permettra d’utiliser directement le service dans le contrôleur.

Concentrons-nous maintenant sur le service lui-même. Commençons par travailler sur la façon d’ajouter un nouvel animal à notre base de données :

@Service
public class AnimalService {
// Your service constructor here...
    public void buyAnimal(String name, String species, double price){
        Animal newAnimal= new Animal(name,species,price);
        animalRepository.save(newAnimal);
    }
}

Nous mettrons ensuite à jour le code du contrôleur pour appeler cette méthode lorsqu’une requête POST est effectuée :

@RestController
@RequestMapping("/api/petShopAPI")
public class AnimalController {
    
// Your other methods and constructor...
    @PostMapping("/buyAnimal")
    public void buyAnimal(@RequestParam(name="name", required=true)String name, @RequestParam(name="species", required=true)String species, @RequestParam(name="price", required=true) double price )
    {
       animalService.buyAnimal(name, species, price);
    }

}

Relancez le code et essayez à nouveau votre requête, vous devriez avoir la sortie console suivante :

Hibernate: insert into animals (name,price,sold,species) values (?,?,?,?)

Cela indique que vous avez ajouté avec succès Mephisto à la liste des animaux dans votre inventaire. Cependant, cela ne nous dit pas vraiment comment accéder à notre inventaire.

Pour se concentrer là-dessus, nous allons implémenter la méthode GET, d’abord dans le service :

@Service
public class AnimalService {
// Your service constructor here...
    public List<Animal> getAnimals(){
        return animalRepository.findAll();
    }
}

Et dans le controller:

@RestController
@RequestMapping("/api/petShopAPI")
public class AnimalController {
    
// Your other methods and constructor...
    @GetMapping("/getAnimals")
    public List<Animal> getAnimals()
    {
          return animalService.getAnimals();
    }
}

Remarquez comment nous avons modifié le type de retour de la méthode ? Il devrait maintenant afficher une liste d’animaux lorsque vous lancez la requête dans le navigateur.

Essayez de relancer le code et de faire d’abord une requête POST, puis une requête GET :

La sortie est un tableau JSON. Vous pouvez considérer JSON comme une manière standard de transmettre des informations. Un objet JSON est généralement construit comme une carte de propriétés et de valeurs, et il est couramment utilisé en conjonction avec les API REST.

Prochaines étapes:

Dans la prochaine partie de notre tutoriel, nous implémenterons les méthodes PUT et DELETE, et nous vous montrerons diverses méthodes de manipulation de la base de données, ainsi que l’utilisation des en-têtes de requête.

Vous pouvez accéder à la seconde partie de notre tutoriel en cliquant ici.

Si vous avez des questions, n’hésitez pas à les poser ci-dessous, ou à visiter notre site Web à :

lizardanddog.com

https://www.cloco.ai