• 10 heures
  • Difficile

Ce cours est visible gratuitement en ligne.

course.header.alt.is_video

course.header.alt.is_certifying

J'ai tout compris !

Mis à jour le 01/03/2022

Créez, modifiez et supprimez des données avec Spring Data JPA

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Compétences évaluées

  • Créer, modifier et supprimer des données avec Spring Data JPA
  • Question 1

    Vous travaillez sur un projet où 2 entités sont modélisées : User et Role. Entre ces 2 entités, il y a une relation bidirectionnelle plusieurs à plusieurs. Le type de cascade est PERSIST et MERGE des 2 côtés de la relation. Quel sera le résultat du code suivant ?

    package com.openclassrooms.dataLayer;
    import javax.transaction.Transactional;
    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.openclassrooms.dataLayer.model.Role;
    import com.openclassrooms.dataLayer.model.User;
    import com.openclassrooms.dataLayer.service.UserService;
    @SpringBootApplication
    public class DataLayerApplication implements CommandLineRunner {
    @Autowired
    private UserService userService;
    public static void main(String[] args) {
    SpringApplication.run(DataLayerApplication.class, args);
    }
    @Override
    @Transactional
    public void run(String... args) throws Exception {
    Role adminRole = new Role();
    adminRole.setName("ADMIN");
    User chuck = new User();
    chuck.setUsername("chuck");
    chuck.setPassword("youwillnotfindme");
    chuck.getRoles().add(adminRole);
    userService.saveUser(chuck);
    }
    }

     

    • Un nouvel utilisateur est ajouté en base de données. Il n’est lié à aucun rôle.

    • Un nouvel utilisateur est ajouté en base de données et est lié au rôle existant “ADMIN” via la table de jointure.

    • Un nouvel utilisateur et un nouveau rôle sont ajoutés en base de données. Les 2 sont liés ensemble via la table de jointure.

    • Aucune opération n’est exécutée sur la base de données, le code ne permet pas l’ajout de l’utilisateur.

  • Question 2

    Il est possible d’utiliser la méthode save() fournie par l’interface CrudRepository, tant pour l’ajout (Create) que pour la mise à jour (Update). Comment Spring Data JPA sait-il faire la différence entre ces 2 opérations ?

    • Un paramètre supplémentaire doit être fourni à la méthode save pour distinguer les 2 opérations.

    • Le contenu de l’objet est inspecté, si l’ID est défini c’est une mise à jour, sinon c’est un ajout.

    • Spring Data JPA ne sait pas faire la différence, il créera à chaque fois une nouvelle entrée dans la base de données.

    • Pour que la méthode save() déclenche une mise à jour au lieu d’un nouveau, il faut ajouter une annotation @Update.

  • Question 3

    Par défaut, l’appel de la méthode save() pour la mise à jour d’une entité génère une requête SQL qui va mettre à jour tous les champs de l’entité, même ceux qui n’ont pas changé. Quel est le code qui permet de générer une requête SQL qui mettra à jour uniquement les champs qui ont changé ?

    • package com.openclassrooms.dataLayer.model;
      import java.util.List;
      import javax.persistence.CascadeType;
      import javax.persistence.Column;
      import javax.persistence.Entity;
      import javax.persistence.FetchType;
      import javax.persistence.GeneratedValue;
      import javax.persistence.GenerationType;
      import javax.persistence.Id;
      import javax.persistence.JoinColumn;
      import javax.persistence.JoinTable;
      import javax.persistence.ManyToMany;
      import org.hibernate.annotations.Update;
      @Entity
      @Update
      public class User {
      @Id
      @GeneratedValue(strategy = GenerationType.IDENTITY)
      private int id;
      @Column(name = "username")
      private String username;
      @Column(name = "password")
      private String password;
      }
    • package com.openclassrooms.dataLayer.model;
      import java.util.List;
      import javax.persistence.CascadeType;
      import javax.persistence.Column;
      import javax.persistence.Entity;
      import javax.persistence.FetchType;
      import javax.persistence.GeneratedValue;
      import javax.persistence.GenerationType;
      import javax.persistence.Id;
      import javax.persistence.JoinColumn;
      import javax.persistence.JoinTable;
      import javax.persistence.ManyToMany;
      import org.hibernate.annotations.DynamicInsert;
      @Entity
      @DynamicInsert
      public class User {
      @Id
      @GeneratedValue(strategy = GenerationType.IDENTITY)
      private int id;
      @Column(name = "username")
      private String username;
      @Column(name = "password")
      private String password;
      }
    • package com.openclassrooms.dataLayer.model;
      import java.util.List;
      import javax.persistence.CascadeType;
      import javax.persistence.Column;
      import javax.persistence.Entity;
      import javax.persistence.FetchType;
      import javax.persistence.GeneratedValue;
      import javax.persistence.GenerationType;
      import javax.persistence.Id;
      import javax.persistence.JoinColumn;
      import javax.persistence.JoinTable;
      import javax.persistence.ManyToMany;
      import org.hibernate.annotations.DynamicUpdate;
      @Entity
      @DynamicUpdate
      public class User {
      @Id
      @GeneratedValue(strategy = GenerationType.IDENTITY)
      private int id;
      @Column(name = "username")
      private String username;
      @Column(name = "password")
      private String password;
      }
    • package com.openclassrooms.dataLayer.model;
      import java.util.List;
      import javax.persistence.CascadeType;
      import javax.persistence.Column;
      import javax.persistence.Entity;
      import javax.persistence.FetchType;
      import javax.persistence.GeneratedValue;
      import javax.persistence.GenerationType;
      import javax.persistence.Id;
      import javax.persistence.JoinColumn;
      import javax.persistence.JoinTable;
      import javax.persistence.ManyToMany;
      @Entity
      public class User {
      @Id
      @GeneratedValue(strategy = GenerationType.IDENTITY)
      private int id;
      @Column(name = "username")
      private String username;
      @Column(name = "password")
      private String password;
      }