Travailler avec des objets d'entité

4.1 Transactions et intégrité de la base de données

Le mode de fonctionnement normal d'une base de données est lorsqu'elle reçoit chaque minute des milliers de requêtes provenant de centaines de clients différents. Dans ce cas, des situations surviennent souvent lorsque les mêmes données sont accessibles à partir de différentes requêtes.

Moins souvent, mais, encore une fois, il arrive de temps en temps qu'une requête lise une certaine ligne et qu'une autre requête la modifie en même temps. Imaginez ce qui se passe si quelqu'un lit une ligne qui n'est qu'à moitié modifiée ? Rien de bon.

Ce problème est résolu de plusieurs manières. Tout d'abord, vous pouvez simplement verrouiller la ligne qui change. Aussi bien pour la lecture que pour l'écriture. Cette méthode fonctionne, mais la vitesse de la base en souffre grandement.

La deuxième méthode consiste à verrouiller la chaîne pour l'écriture uniquement. Cependant, il y aura toujours un problème lorsque quelqu'un essaiera de lire la ligne partiellement modifiée. Conclusion - il ne devrait pas y avoir de situation où la ligne est partiellement modifiée.

Par conséquent, ils ont proposé une troisième méthode - les transactions. Une transaction est un groupe d'actions qui sont exécutées soit toutes ensemble, soit aucune. Il ne peut pas y avoir de situation où une partie des actions a été effectuée et la seconde partie ne l'a pas été. S'il n'est pas possible d'effectuer toutes les modifications, toutes les modifications déjà apportées sont annulées.

Tout serveur SQL moderne vous permet de modifier les données uniquement dans les transactions. Vous ouvrez une transaction, apportez des modifications à n'importe quel nombre de tables et validez la transaction. SQL Server essaie alors d'apporter des modifications. Si tout va bien, ils seront ajoutés à la base de données générale. En cas de problème, toutes les modifications seront annulées.

Hibernate utilise également ce paradigme. C'est pourquoi, dans la leçon précédente, nous avons vu qu'en essayant d'enregistrer l'objet Employee dans la base de données, une transaction était d'abord ouverte et, après l'enregistrement, elle était validée.

Nous aborderons ce sujet plus en détail, mais pour l'instant, sachez simplement pourquoi les transactions sont nécessaires et où elles sont généralement utilisées.

4.2 Obtenir des objets

Si Hibernate exécute une requête pour obtenir des données, il n'est pas nécessaire d'ouvrir explicitement une transaction. Hibernate lui-même le fera s'il le juge bon : il a ses paramètres, ainsi que les paramètres du serveur SQL.

Nous analyserons comment travailler avec la base de données. Et le plus simple d'entre eux est d'obtenir un objet par son ID . Pour ce faire, utilisez la méthode get()sur l' objet de session . La forme générale d'une telle demande :

Class Name = session.get(Class.class, ID);

Exemple:

public User getUserById(Integer id) {
    try (Session session = sessionFactory.openSession()) {
        User user = session.get(User.class, id);
        return user;
    }
}

4.3 Enregistrer (ajouter) des objets

Si vous souhaitez enregistrer votre objet dans la base de données, une requête sera exécutée au niveau SQLINSÉRER. Par conséquent, vos actions doivent être effectuées dans le cadre d'une transaction distincte. De plus, il est préférable d'utiliser la méthode persist()de l'objet de session pour persistence .

La forme générale d'une telle demande :

session.persist(An object);

La méthode persist()change non seulement la base, mais aussi l'objet lui-même. Le fait est que lorsque nous ajoutons un objet à la base de données, cet objet n'a pas encore son propre ID avant de l'ajouter . Eh bien, généralement, bien qu'il y ait des nuances. Et après avoir ajouté l'objet a déjà un ID .

public boolean saveUser(User user) {
    try (Session session = sessionFactory.openSession()) {
            Transaction transaction = session.beginTransaction();
            session.persist(user);
            transaction.commit();
            return true;
    }
    catch() {
    return false;
   	}
}

L'objet Session a également une méthode save()qui exécute une fonction similaire. C'est juste que la méthode save()est l'ancienne norme Hibernate et la méthode persist()est la norme JPA.

4.4 Suppression d'objets

Si vous souhaitez supprimer un objet existant, il est très facile de le faire. Pour ce faire, l'objet de session a une méthode spéciale - remove().

La forme générale d'une telle demande :

session.remove(An object);

Et, bien sûr, écrivons le code avec un exemple :

public boolean removeUser(User user) {
    try (Session session = sessionFactory.openSession()) {
            Transaction transaction = session.beginTransaction();
            session.remove(user);
            transaction.commit();
            return true;
    }
    catch() {
    return false;
   	}
}

Pourquoi est-ce si difficile, demandez-vous?

Eh bien, tout d'abord, toute modification de la base de données a toujours des conséquences différentes et pas toujours évidentes. Et deuxièmement, cet objet pourrait avoir des objets enfants qui lui sont associés, etc. Les scénarios de suppression sont donc souvent non triviaux.