Tout d’abord, nous allons créer une classe java qui correspondra à la table que nous avons créée plus haut. Chaque ligne de la table correspondra à une instance de la classe et nous le ferons dans le model (logique J !). Voici la classe en question :

package com.tuto.api.model;

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

@Entity
@Table(name="articles")
public class Article {

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

       @Column(name="name")
       private String articleName;

       @Column(name="quantity")
       private int articleQte;

       @Column(name="price")
       private int articlePrice;

       public Article() {
             super();
       }

       public Article(Long id, String articleName, int articleQte, int articlePrice) {
             super();
             this.id = id;
             this.articleName = articleName;
             this.articleQte = articleQte;
             this.articlePrice = articlePrice;
       }

       public Long getId() {
             return id;
       }

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

       public String getArticleName() {
             return articleName;
       }

       public void setArticleName(String articleName) {
             this.articleName = articleName;
       }

       public int getArticleQte() {
             return articleQte;
       }

       public void setArticleQte(int articleQte) {
             this.articleQte = articleQte;
       }

       public int getArticlePrice() {
             return articlePrice;
       }

       public void setArticlePrice(int articlePrice) {
             this.articlePrice = articlePrice;
       }
}

Je pense qu’on est tous d’accord pour s’accorder à dire qu’à part les « @ machin truc là », le reste n’est rien d’autre qu’une classe java classique.

En fait ces « @ machin truc » s’appellent des « annotations » et elles permettent entre autres d’ajouter certains éléments à des classes, des méthodes et des attributs. Penchons-nous sur celles-ci :

• @Entity permet d’indiquer que la classe correspond à une table de la BD
• @Table indique le nom de la table
• @Id indique que l’attribut spécifié corresponds à la clé primaire de la table et @GeneratedValue(strategy=GenerationType.IDENTIFY) permet l’auto incrémentation.
• Et enfin @Column permet de faire le lien entre le nom du champ de la table et l’attribut.

Ça s’est dit, il est temps d’implémenter le code qui déclenche les actions pour communiquer avec la base de données : vous l’aurez compris, au tour de la couche « repository »

Le code est le suivant :

package com.tuto.api.repository;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import com.tuto.api.model.Article;

@Repository
public interface ArticleRepository extends JpaRepository<Article, Long> {

}

Quoi c’est tout 😀 ???

Et oui. C’est en ça que réside toute la puissance de spring Boot qui grâce à son composant Spring Data JPA que vous avez injecter au tout début (si si rappelez-vous !!!), il nous permet d’exécuter des requêtes SQL sans avoir besoin de les écrire.

Pourquoi une interface me direz-vous et bien tout simplement parce qu’avec une classe on aurait été obligé d’implémenter les différentes méthodes pour communiquer avec la BD mais là grâce à l’interface, tout ce qu’on a à faire est d’utiliser une interface qui, grâce à la « généricité, nous permet appliquer notre code à n’importe quelle entité d’où la syntaxe <Article, Long>. L’interface JpaRepository possède plusieurs méthodes prédéfinies que l’on va juste implémenter.

Et concernant @Repository, je pense que vous commencez à vous y habituer. Cette annotation permet simplement de déclarer l’interface comme étant un bean et que son rôle est de communiquer avec une source de données (en l’occurrence notre BD).

A ce stade, nous avons déjà fait la moitié du travail, il nous reste juste l’étape d’exécution de notre code. Nous allons ajouter une ligne dans notre base de données pour vous permettre de vous visualiser la chose.

Alors, pour exécuter son code, la méthode la plus facile est implémenter l’interface

CommandLineRunner

Et comme d’habitude lorsqu’on implémente une interface, il faut redéfinir des méthodes. Ici en l’occurrence, il s’agit de méthode run() :

public void run(String... args) throws Exception { }

Pour ajouter donc un article dans la base de données, il vous faut écrire une commande dans la méthode run() et du coup votre fichier ApiApplication devra ressembler à celui-ci :

package com.tuto.api;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import com.tuto.api.model.Article;
import com.tuto.api.repository.ArticleRepository;

@SpringBootApplication
public class ApiApplication implements CommandLineRunner {

       @Autowired
       private ArticleRepository articleRepository;

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

       @Override
       public void run(String... args) throws Exception {
             articleRepository.save(new Article(null, "coffee", 4, 2000));
       }
}

Comme vous le voyez, j’ajoute un article dont le nom est « coffee », qui coûte 2000 et j’en ajoute 4.

Maintenant pour le visualiser, vous pouvez aller voir votre interface web de tout à l’heure :