Accéder aux données avec MySQL

Getting Started | Accessing data with MySQL (spring.io)

Ce guide vous guide tout au long du processus de création d'une application Spring connectée à une base de données MySQL (par opposition à une base de données intégrée en mémoire, que la plupart des autres guides et de nombreux exemples d'applications utilisent). Il utilise Spring Data JPA pour accéder à la base de données, mais ce n'est qu'un des nombreux choix possibles (par exemple, vous pouvez utiliser Spring JDBC).

Ce que vous allez construire

Vous allez créer une base de données MySQL, créer une application Spring et la connecter à la base de données nouvellement créée.

MySQL est sous licence GPL, donc tout programme binaire que vous distribuez avec lui doit également utiliser la GPL. Voir la licence publique générale GNU .

De quoi as-tu besoin

MySQL version 5.6 ou supérieure. Si Docker est installé, il peut être utile d'exécuter la base de données en tant que conteneur .

Environ 15 minutes
Un éditeur de texte ou IDE favori
Java 17 ou version ultérieure
Gradle 7.5+ ou Maven 3.5+
Vous pouvez également importer le code directement dans votre IDE :

Comment remplir ce guide

Comme la plupart des guides de démarrage de Spring , vous pouvez recommencer à zéro et terminer chaque étape ou vous pouvez ignorer les étapes de configuration de base qui vous sont déjà familières. Dans tous les cas, vous vous retrouvez avec un code fonctionnel.

Pour repartir de zéro , passez à Démarrer avec Spring Initializr .

Pour ignorer les bases , procédez comme suit :

Téléchargez et décompressez le référentiel source de ce guide, ou clonez-le à l'aide de Git :git clone https://github.com/spring-guides/gs-accessing-data-mysql.git
cd dans gs-accessing-data-mysql/initial
Passez directement à Créer la base de données .

Lorsque vous avez terminé , vous pouvez vérifier vos résultats par rapport au code dans gs-accessing-data-mysql/complete.

À partir de Spring Initializr

Vous pouvez utiliser ce projet pré-initialisé et cliquer sur Générer pour télécharger un fichier ZIP. Ce projet est configuré pour s'adapter aux exemples de ce didacticiel.

Pour initialiser manuellement le projet :

Accédez à https://start.spring.io . Ce service récupère toutes les dépendances dont vous avez besoin pour une application et effectue l'essentiel de la configuration pour vous.
Choisissez Gradle ou Maven et la langue que vous souhaitez utiliser. Ce guide suppose que vous avez choisi Java.
Cliquez sur Dépendances et sélectionnez Spring Web , Spring Data JPA et MySQL Driver .
Cliquez sur Générer .
Téléchargez le fichier ZIP résultant, qui est une archive d'une application Web configurée avec vos choix.

Si votre IDE dispose de l'intégration Spring Initializr, vous pouvez terminer ce processus à partir de votre IDE.

Vous pouvez également bifurquer le projet depuis Github et l'ouvrir dans votre IDE ou un autre éditeur.

Créer la base de données

Ouvrez un terminal (invite de commande sous Microsoft Windows) et ouvrez un client MySQL en tant qu'utilisateur pouvant créer de nouveaux utilisateurs.

Par exemple, sur un système Linux, utilisez la commande suivante :

$ sudo mysql --password

Celui-ci se connecte à MySQL rootet permet l'accès à l'utilisateur depuis tous les hôtes. Ce n'est pas la méthode recommandée pour un serveur de production.

Pour créer une nouvelle base de données, exécutez les commandes suivantes à l' mysqlinvite :

mysql> create database db_example; -- Creates the new database
mysql> create user 'springuser'@'%' identified by 'ThePassword'; -- Creates the user
mysql> grant all on db_example.* to 'springuser'@'%'; -- Gives all privileges to the new user on the newly created database

Créer le fichier `application.properties`

Spring Boot vous donne des valeurs par défaut sur toutes les choses. Par exemple, la base de données par défaut est H2. Par conséquent, lorsque vous souhaitez utiliser une autre base de données, vous devez définir les attributs de connexion dans le fichier application.properties.

Créez un fichier de ressources appelé src/main/resources/application.properties, comme le montre la liste suivante :

spring.jpa.hibernate.ddl-auto=update
spring.datasource.url=jdbc:mysql://${MYSQL_HOST:localhost}:3306/db_example
spring.datasource.username=springuser
spring.datasource.password=ThePassword
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
#spring.jpa.show-sql: true

Ici, spring.jpa.hibernate.ddl-auto peut être none, update, create, ou create-drop. Voir la documentation Hibernate pour plus de détails.

none: La valeur par défaut pour MySQL. Aucune modification n'est apportée à la structure de la base de données.
update: Hibernate modifie la base de données en fonction des structures d'entité données.
create: Crée la base de données à chaque fois mais ne la supprime pas à la fermeture.
create-drop: crée la base de données et la supprime à SessionFactory la fermeture.

Vous devez commencer par createou update, car vous ne disposez pas encore de la structure de la base de données. Après la première exécution, vous pouvez le basculer sur updateou none, selon les exigences du programme. À utiliser updatelorsque vous souhaitez apporter des modifications à la structure de la base de données.

La valeur par défaut pour H2 et les autres bases de données intégrées est create-drop. Pour les autres bases de données, telles que MySQL, la valeur par défaut est none.

C'est une bonne pratique de sécurité, une fois que votre base de données est en état de production, de la définir sur none, de révoquer tous les privilèges de l'utilisateur MySQL connecté à l'application Spring et de donner à l'utilisateur MySQL uniquement SELECT, UPDATE, INSERTet DELETE. Vous pouvez en savoir plus à ce sujet à la fin de ce guide.

Créer le `@Entity`modèle

Vous devez créer le modèle d'entité, comme le src/main/java/com/example/accessingdatamysql/User.javamontre la liste suivante (dans ) :

package com.example.accessingdatamysql;

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

@Entity // This tells Hibernate to make a table out of this class
public class User {
  @Id
  @GeneratedValue(strategy=GenerationType.AUTO)
  private Integer id;

  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;
  }
}

Hibernate traduit automatiquement l'entité en table.

Créer le référentiel

Vous devez créer le référentiel qui contient les enregistrements d'utilisateurs, comme le src/main/java/com/example/accessingdatamysql/UserRepository.java montre la liste suivante (dans ) :

package com.example.accessingdatamysql;

import org.springframework.data.repository.CrudRepository;

import com.example.accessingdatamysql.User;

// This will be AUTO IMPLEMENTED by Spring into a Bean called userRepository
// CRUD refers Create, Read, Update, Delete

public interface UserRepository extends CrudRepository<User, Integer> {

}

Spring implémente automatiquement cette interface de référentiel dans un bean qui porte le même nom (avec un changement de casse — il s'appelle userRepository).

Créer un contrôleur

Vous devez créer un contrôleur pour gérer les requêtes HTTP adressées à votre application, comme le src/main/java/com/example/accessingdatamysql/MainController.javamontre la liste suivante (dans ) :

package com.example.accessingdatamysql;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller // This means that this class is a Controller
@RequestMapping(path="/demo") // This means URL's start with /demo (after Application path)
public class MainController {
  @Autowired // This means to get the bean called userRepository
         // Which is auto-generated by Spring, we will use it to handle the data
  private UserRepository userRepository;

  @PostMapping(path="/add") // Map ONLY POST Requests
  public @ResponseBody String addNewUser (@RequestParam String name
      , @RequestParam String email) {
    // @ResponseBody means the returned String is the response, not a view name
    // @RequestParam means it is a parameter from the GET or POST request

    User n = new User();
    n.setName(name);
    n.setEmail(email);
    userRepository.save(n);
    return "Saved";
  }

  @GetMapping(path="/all")
  public @ResponseBody Iterable<User> getAllUsers() {
    // This returns a JSON or XML with the users
    return userRepository.findAll();
  }
}

L'exemple précédent spécifie explicitement POSTand GETpour les deux points de terminaison. Par défaut, @RequestMapping mappe toutes les opérations HTTP.

Créer une classe d'application

Spring Initializr crée une classe simple pour l'application. La liste suivante montre la classe créée par Initializr pour cet exemple (dans src/main/java/com/example/accessingdatamysql/AccessingDataMysqlApplication.java):

package com.example.accessingdatamysql;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class AccessingDataMysqlApplication {

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

}

Pour cet exemple, vous n'avez pas besoin de modifier la AccessingDataMysqlApplication classe.

@SpringBootApplicationest une annotation de commodité qui ajoute tout ce qui suit :

@Configuration: marque la classe comme source de définitions de bean pour le contexte de l'application.
@EnableAutoConfiguration: demande à Spring Boot de commencer à ajouter des beans en fonction des paramètres de chemin de classe, d'autres beans et de divers paramètres de propriété. Par exemple, si spring-webmvc se trouve sur le chemin de classe, cette annotation marque l'application en tant qu'application Web et active des comportements clés, tels que la configuration d'un fichier DispatcherServlet.
@ComponentScan: indique à Spring de rechercher d'autres composants, configurations et services dans le com/examplepackage, lui permettant de trouver les contrôleurs.

La main() méthode utilise la méthode de Spring Boot SpringApplication.run() pour lancer une application. Avez-vous remarqué qu'il n'y avait pas une seule ligne de XML ? Il n'y a web.xml pas non plus de fichier. Cette application Web est 100 % Java pur et vous n'avez pas eu à configurer de plomberie ou d'infrastructure.

Construire un JAR exécutable

Vous pouvez exécuter l'application à partir de la ligne de commande avec Gradle ou Maven. Vous pouvez également créer un seul fichier JAR exécutable contenant toutes les dépendances, classes et ressources nécessaires et l'exécuter. La création d'un jar exécutable facilite l'expédition, la version et le déploiement du service en tant qu'application tout au long du cycle de développement, dans différents environnements, etc.

Si vous utilisez Gradle, vous pouvez exécuter l'application en utilisant ./gradlew bootRun. Vous pouvez également créer le fichier JAR en utilisant ./gradlew buildpuis en exécutant le fichier JAR, comme suit :

java -jar build/libs/gs-accessing-data-mysql-0.1.0.jar

Si vous utilisez Maven, vous pouvez exécuter l'application en utilisant ./mvnw spring-boot:run. Vous pouvez également créer le fichier JAR avec ./mvnw clean packagepuis exécuter le fichier JAR, comme suit :

java -jar cible/gs-accessing-data-mysql-0.1.0.jar

Les étapes décrites ici créent un fichier JAR exécutable. Vous pouvez également créer un fichier WAR classique .

Lorsque vous exécutez l'application, le résultat de la journalisation s'affiche. Le service devrait être opérationnel en quelques secondes.

Testez l'application

Maintenant que l'application est en cours d'exécution, vous pouvez la tester à l'aide curld'un outil similaire. Vous disposez de deux points de terminaison HTTP que vous pouvez tester :

GET localhost:8080/demo/all: Obtient toutes les données. POST localhost:8080/demo/add: Ajoute un utilisateur aux données.

La commande curl suivante ajoute un utilisateur :

$ curl http://localhost:8080/demo/add -d name=First -d email=someemail@someemailprovider.com

La réponse doit être la suivante :

Saved

La commande suivante affiche tous les utilisateurs :

$ curl http://localhost:8080/demo/all

La réponse doit être la suivante :

[{"id":1,"name":"First","email":"someemail@someemailprovider.com"}]

Apportez quelques modifications de sécurité

Lorsque vous êtes dans un environnement de production, vous pouvez être exposé à des attaques par injection SQL. Un pirate informatique peut injecter DROP TABLEou toute autre commande SQL destructrice. Ainsi, par mesure de sécurité, vous devez apporter quelques modifications à votre base de données avant d'exposer l'application à vos utilisateurs.

La commande suivante révoque tous les privilèges de l'utilisateur associé à l'application Spring :

mysql> revoke all on db_example.* from 'springuser'@'%';

Désormais, l'application Spring ne peut rien faire dans la base de données.

L'application doit disposer de certains privilèges, utilisez donc la commande suivante pour accorder les privilèges minimum dont l'application a besoin :

mysql> grant select, insert, delete, update on db_example.* to 'springuser'@'%';

La suppression de tous les privilèges et l'octroi de certains privilèges donnent à votre application Spring les privilèges nécessaires pour apporter des modifications uniquement aux données de la base de données et non à la structure (schéma).

Lorsque vous souhaitez apporter des modifications à la base de données :

Accorder des autorisations.
Changez le spring.jpa.hibernate.ddl-autoen update.
Réexécutez vos applications.

Répétez ensuite les deux commandes présentées ici pour rendre votre application sûre pour une utilisation en production à nouveau. Mieux encore, utilisez un outil de migration dédié, comme Flyway ou Liquibase.

Résumé

Toutes nos félicitations! Vous venez de développer une application Spring liée à une base de données MySQL et prête pour la production !

Modifié le: mercredi 8 novembre 2023, 07:22