Connectez Spring Boot à MySQL

Bonjour à tous,

Dans ce tutoriel je vais vous expliquer le processus que j'ai suivi afin de connecter Spring Boot à MySQL, afin de créer une API pour mon Front-End.

Conditions préalables :

• IDE (j'utilise Intellij IDEA donc ce tutoriel sera basé sur cela)

• MySql Workbench

Cliquez ici pour le code source.

Créer un projet Spring Boot à l'aide de Spring Initializr

Visitez start.spring.io et sélectionnez :
Projet : Maven
Langage : Java
Démarrage de printemps : 3.3.0
Écrivez les champs nécessaires avec votre contenu
Conditionnement : POT
Java : 17

Quant aux dépendances, il nous faudra :

• Pilote MySQL

• Web de printemps

• Données de printemps JPA

Après cela, l'initialisation devrait ressembler à ceci :

Cliquez sur Générer et enregistrez le dossier dans le chemin souhaité et extrayez le contenu du dossier.

Configuration IntelliJ et Mysql

Tout d’abord, créez une base de données dans MySQL. J'ai utilisé MySQL Workbench pour cela.

Même la base de données la plus simple fonctionnera, comme ceci :

Ouvrez le contenu du dossier dans l'IDE de votre choix. Je couvrirai ce tutoriel en utilisant Intellij IDEA.

Ouvrez le fichier application.properties qui se trouve dans scr/resources/application.properties

Dans ce fichier, nous configurons les paramètres qui nous aideront à nous connecter dans notre base de données.

Écrivez ces paramètres dans le fichier :

Remplacez ${DB_NAME}, ${DB_USER}, ${DB_PASSWORD} par les informations d'identification de votre base de données.

Ces paramètres nous aideront à nous connecter à la base de données que nous avons créée :

spring.jpa.show-sql=true:

Cela permet la journalisation des instructions SQL générées par Hibernate. Lorsqu'il est défini sur true, Hibernate imprimera les instructions SQL sur la console.

spring.jpa.hibernate.ddl-auto=update:

Ce paramètre est utilisé pour mettre à jour automatiquement le schéma de la base de données pour qu'il corresponde aux définitions d'entité. La mise à jour de la valeur signifie qu'Hibernate mettra à jour le schéma existant, en ajoutant toutes les nouvelles colonnes ou tables requises par les mappages d'entités.

logging.level.org.hibernate.SQL=DEBUG:

Cela définit le niveau de journalisation du logger Hibernate SQL sur DEBUG. Il fournira des informations détaillées sur les instructions SQL en cours d'exécution.

logging.level.org.hibernate.type.descriptor.sql.BasicBinder=TRACE:

Cela définit le niveau de journalisation du classeur SQL du descripteur de type Hibernate sur TRACE. Cela enregistrera des informations détaillées sur la liaison des paramètres dans les instructions SQL.

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver:

Ceci spécifie le nom de la classe du pilote JDBC pour MySQL. Il indique à Spring Boot quel pilote utiliser pour établir la connexion à la base de données.

spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQLDialect:

Cela définit le dialecte Hibernate sur MySQLDialect, qui est optimisé pour MySQL. Il permet à Hibernate de générer des instructions SQL compatibles avec MySQL.

Maintenant, créez un sous-package dans le package principal de votre projet, et appelez-le « modèle ». À l’intérieur, créez une classe en l’appelant comme vous le souhaitez, dans mon cas je l’appellerai Utilisateurs.

package com.evaluation.evaluationSystem.model;

import jakarta.persistence.*;

@Entity
@Table(name = "users")
public class Users {
    public Long getId() {
        return id;
    }

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

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

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

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

    public String getEmail() {
        return email;
    }

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

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

Dans ce fichier, dans ce fichier nous définissons une entité JPA Users qui sera mappée à une table de base de données users. La classe comprend des champs pour l'identifiant, l'e-mail et le mot de passe qui correspondent aux colonnes de la table des utilisateurs, alors assurez-vous que le champ s'aligne avec les colonnes de votre base de données.

Ensuite, créez un autre sous-package appelé « contrôleur » et créez-y un fichier.

package com.evaluation.evaluationSystem.controller;

import com.evaluation.evaluationSystem.model.Users;
import com.evaluation.evaluationSystem.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Optional;

@RestController
public class UsersController {
    @Autowired
    private UserRepository userRepository;

    @GetMapping("/users")
    public List<Users> getUsers(@RequestParam("search") Optional<String> searchParam){
        return searchParam.map(param -> userRepository.getContainingQuote(param))
                .orElse(userRepository.findAll());
    }
}

Dans ce fichier, nous définissons un point de terminaison d'API RESTful (/users) qui peut éventuellement filtrer les entités Utilisateurs en fonction d'un paramètre de recherche. Il utilise UserRepository pour l'interaction avec la base de données et renvoie les résultats au format JSON grâce à l'annotation @RestController. Remplacez "/users" par le point de terminaison de votre choix.

Créez un sous-package supplémentaire (le dernier) appelé référentiel et créez une interface de fichier (attention, pas de classe).

package com.evaluation.evaluationSystem.repository;

import com.evaluation.evaluationSystem.model.Users;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;

import java.util.List;

public interface UserRepository extends JpaRepository<Users, Long> {
    @Query("SELECT u FROM Users u WHERE u.email LIKE %:word%")
    List<Users> getContainingQuote(@Param("word") String word);
}

Dans ce fichier, nous définissons la requête qui nous permettra de récupérer les données de la base de données. Assurez-vous de le modifier en fonction de vos besoins. Nous écrivons cette requête en utilisant JPQL (Java Persistence Query Language). Il s'agit d'un langage de requête défini dans le cadre de la spécification Java Persistence API (JPA), qui est utilisé pour effectuer des opérations de base de données sur des objets et des entités Java.

Votre dernière structure de dossiers devrait ressembler à ceci :

Maintenant, accédez au fichier principal (dans mon cas, EvaluationSystemApplication) et exécutez le projet. Si tout fonctionne bien, visiter localhost:8080/users (ou le point de terminaison que vous avez choisi) affichera vos données de la base de données. Assurez-vous de remplir le tableau des données avec du contenu.

Conclusion

J'espère que ce tutoriel vous a aidé. Moi aussi je suis nouveau dans cet environnement, donc j'apprends aussi. Chaque commentaire et suggestion est plus que bienvenu !

N'hésitez pas à suivre mon compte GitHub pour rester informé de mon parcours de développement d'une application Web full stack utilisant Spring Boot, MySQL et React !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!