Comment créer une API Rest avec Spring Boot en utilisant MySQL et JPA

Les dépendances de démarrage et de test sont au cœur de la création de l'application Spring Boot à servir sur le serveur.

Passons maintenant à APIApplication.java qui est le fichier principal.

package com.rest.API;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class ApiApplication {
public static void main(String[] args) {
      SpringApplication.run(ApiApplication.class, args);
   }
}

Ici, le nom du package est dans la première ligne du code. En utilisant ce nom de package, vous pouvez importer n'importe quelle classe, méthode ou instance dans un autre fichier de package.

Après cela, deux modules sont importés du package "org.springframework.boot".

1. Candidature de printemps
2. SpringBootApplication

Étant donné que Spring Boot est le dernier framework de développement d'applications de Spring, il a besoin des packages de Spring Application ainsi que de ses packages spécifiques.

Après cela @SpringBootApplication L'annotation est utilisée. Cette annotation consiste en une annotation utilisée dans Spring :

1. @Composant — Indique au compilateur que la classe suivante est un composant qui doit être inclus lors de la compilation de l'ensemble de l'application.
2. @ComponentScan — Celui-ci fait le Scan des packages que nous allons utiliser dans la classe Java suivante.
3. @EnableAutoConfiguration - permet au mécanisme de configuration automatique de Spring Boot d'importer des modules importants pour que Spring Boot s'exécute.

Ce sont les annotations utilisées pour démarrer l'application Spring Boot à exécuter sur un serveur.

Voici un article que j'ai écrit sur les annotations et leurs utilisations en Java.

Créons un modèle pour nos données

Créons une classe Model pour enregistrer, récupérer, mettre à jour et supprimer les détails d'un livre.

Pour cela, je dois créer un nouveau package nommé model et à l'intérieur de cela, créer un Book.java class pour mettre mon code.

package com.rest.API.model;
import javax.persistence.*;
import javax.validation.constraints.NotBlank;
@Entity
@Table(name = "books")
public class Book {
    @Id
    @GeneratedValue
    private Long id;
@NotBlank
    private String book_name;
@NotBlank
    private String author_name;
@NotBlank
    private String isbn;
public Book(){
        super();
    }
public Book(Long id, String book_name, String author_name, String isbn) {
        super();
        this.id = id;
        this.book_name = book_name;
        this.author_name = author_name;
        this.isbn=isbn;
    }
public Long getId() {
        return id;
    }
public void setId(Long id) {
        this.id = id;
    }
public String getBook_name() {
        return book_name;
    }
public void setBook_name(String book_name) {
        this.book_name = book_name;
    }
public String getAuthor_name() {
        return author_name;
    }
public void setAuthor_name(String author_name) {
        this.author_name = author_name;
    }
public String getIsbn() {
        return isbn;
    }
public void setIsbn(String isbn) {
        this.isbn = isbn;
    }
}

Ici, j'utilise JPA (Java Persistence API) qui est une collection de classes et de méthodes pour stocker en continu des données dans une base de données.

@Entité - utilisé pour indiquer que cette classe va être une entité dans la base de données.

@Table — qui prend des valeurs comme le nom que vous allez donner à votre table

@identifiant — indique que l'id est la clé primaire/clé d'identification pour cette table

@PasVide— est utilisé pour dire que ces attributs ne doivent pas être vides.

En dehors de cela, il existe un constructeur vide qui a une super méthode pour satisfaire les coutumes JPA. Les méthodes getter et setter sont généralement dans une classe POJO (Plain old Java object ).

Création du référentiel

Ensuite, nous allons créer un dépôt package pour gérer la gestion de base de données en Java.

Créez une interface appelée BookRepository.java à l'intérieur du dépôt paquet.

package com.rest.API.repository;
import com.rest.API.model.Book;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
@Repository
public interface BookRepository extends JpaRepository<Book, Long> {
}

J'ai importé le JpaRepository package pour utiliser ce référentiel dans le BookRepository interface en connectant mon modèle de livre le plus récemment codé pour faire CRUD opérations.

Il existe déjà des méthodes intégrées dans ces référentiels pour effectuer des opérations CRUD.

Ex :

.findAll() - to get All datas
.save()    - to save the got Data
.delete()  - to delete the data

Dans la balise <>, nous prenons le nom du modèle que nous allons utiliser et le type de données de la clé primaire.

@Repository :Annotation utilisée pour indiquer le DAO (Data Access Object ) composant dans la couche de persistance.

Il indique au compilateur que l'interface va utiliser le référentiel pour effectuer des activités de base de données.

Création du contrôleur et de la gestion des exceptions

Créez un nouveau package appelé contrôleur, et à l'intérieur qui créent un BookController.java fichier qui contient les points de terminaison.

package com.rest.API.controller;

import com.rest.API.exception.BookNotFoundException;
import com.rest.API.model.Book;
import com.rest.API.repository.BookRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.http.ResponseEntity;
import javax.validation.Valid;
import java.util.List;

@RestController
public class BookController {

@Autowired
    BookRepository bookRepository;

// Get All Notes
    @GetMapping("/books")
    public List<Book> getAllNotes() {
        return bookRepository.findAll();
    }

// Create a new Note
    @PostMapping("/books")
    public Book createNote(@Valid @RequestBody Book book) {
        return bookRepository.save(book);
    }

// Get a Single Note
    @GetMapping("/books/{id}")
    public Book getNoteById(@PathVariable(value = "id") Long bookId) throws BookNotFoundException {
        return bookRepository.findById(bookId)
                .orElseThrow(() -> new BookNotFoundException(bookId));
    }

// Update a Note
    @PutMapping("/books/{id}")
    public Book updateNote(@PathVariable(value = "id") Long bookId,
                           @Valid @RequestBody Book bookDetails) throws BookNotFoundException {

Book book = bookRepository.findById(bookId)
                .orElseThrow(() -> new BookNotFoundException(bookId));

book.setBook_name(bookDetails.getBook_name());
        book.setAuthor_name(bookDetails.getAuthor_name());
        book.setIsbn(bookDetails.getIsbn());

Book updatedBook = bookRepository.save(book);

return updatedBook;
    }

// Delete a Note
    @DeleteMapping("/books/{id}")
    public ResponseEntity<?> deleteBook(@PathVariable(value = "id") Long bookId) throws BookNotFoundException {
        Book book = bookRepository.findById(bookId)
                .orElseThrow(() -> new BookNotFoundException(bookId));

bookRepository.delete(book);

return ResponseEntity.ok().build();
    }
}

Le premier package importé concerne l'exception Livre introuvable (pour laquelle nous allons créer un fichier dans un instant).

Explication des annotations que nous avons utilisées ici :

1. RestController : Cette annotation est utilisée pour désigner chaque méthode de la classe annotée en tant qu'objet de domaine.

Alors, qu'est-ce qu'un objet de domaine… ?

Il dit simplement que Domain Object ==Business Object.

Ils sont généralement représentés par des entités et des objets de valeur liés au point de terminaison que nous donnons pour obtenir les données de la base de données.

2. Câblage automatique :Cette annotation est utilisée pour câbler automatiquement les classes du bean.

Pour cela, vous devez connaître "Qu'est-ce qu'une classe de bean .. ? ”

Fondamentalement, une classe Java Bean est une classe simple qui encapsule de nombreux objets.

Ceci est un article que j'ai écrit sur Java Bean Classes.

Voici les annotations de mappage pour les points de terminaison pour effectuer des opérations CRUD.

3. GetMapping : Ceci est une interface qui contient le chemin du point de terminaison pour exécuter une méthode Get. Cette interface GetMapping utilise l'interface RequestMapping qui peut avoir la méthode "path, value, params, headers" pour exécuter la méthode Get dans les versions antérieures de Spring.

Maintenant, c'est simplifié en utilisant GetMapping.

4. Post-mapping  :Il s'agit d'une interface qui contient le chemin du point de terminaison pour exécuter la méthode Post.

5. PutMapping : Ceci est une interface qui contient le chemin du point de terminaison pour exécuter la méthode Put à mettre à jour.

6. Supprimer le mappage : Ceci est une interface qui contient le chemin du point de terminaison pour exécuter la méthode Delete.

Dans les dernières lignes, vous avez probablement remarqué le "ResponseEntity ” mot-clé.

Qu'est-ce que c'est …??

C'est une classe Java qui hérite de HttpEntity classe pour manipuler les réponses HTTP. Si la demande de connexion est "OK ” ou s'il y a des problèmes, lancez une exception de HttpEntity classe.

orElseThrow() : Il s'agit d'une méthode trouvée dans la Classe facultative en Java8 qui a été introduit pour gérer les exceptions. La classe facultative fournit diverses méthodes utilitaires pour vérifier la présence ou l'absence d'un objet, ce qui aide à gérer NullPointerException.

orElseLancer est une méthode qui renvoie la valeur si elle est présente, sinon invoque une exception.

Créer une NotFoundException s'il n'y a pas un tel book_id

Comme la méthode orElseThrow lève une exception NotFound. Ce qui suit est la partie de gestion des exceptions. Créer une BookNotFoundException.java fichier à l'intérieur du package d'exception.

package com.rest.API.exception;
public class BookNotFoundException extends Exception {
private long book_id;
public BookNotFoundException(long book_id) {
        super(String.format("Book is not found with id : '%s'", book_id));
        }
}

La classe créée étend la superclasse d'exception. Dans le constructeur, je passe le book_id et imprime l'exception.

Alors, c'est tout…

Nous avons terminé la partie API REST. Vous pouvez maintenant créer l'application (ce qui a été expliqué dans la partie 1) et effectuer des tests avec Postman.

Connexion avec la base de données MySql

Dans application.properties de vos ressources dossier, ajoutez ce qui suit :

## Spring DATASOURCE (DataSourceAutoConfiguration & DataSourceProperties)
spring.datasource.url = jdbc:mysql://localhost:3306/library
spring.datasource.username = root //normally put your MySQL username 
spring.datasource.password = YOUR_MYSQL_PASSWORD
## Hibernate Properties
# The SQL dialect makes Hibernate generate better SQL for the chosen database
spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQL5InnoDBDialect
# Hibernate ddl auto (create, create-drop, validate, update)
spring.jpa.hibernate.ddl-auto = update

C'est tout.

Nous avons construit une API REST de base dans Spring Boot. Félicitations !

Si quelque chose ne va pas ou doit être corrigé, veuillez me le faire savoir dans la section des commentaires.

Contactez-moi sur Twitter.

Bon codage !