ORM Technologies vs JDBC?

JDBC

1. avec JDBC, le développeur doit écrire du code pour mapper la représentation de données d'un modèle objet à un modèle de données relationnelles et son schéma de base de données correspondant.
2. avec JDBC, le mappage automatique des objets Java avec des tables de base de données et vice versa de conversion doit être pris en charge par le développeur manuellement avec des lignes de code.
3. JDBC supporte uniquement le langage de requête structuré natif (SQL). Développeur doit trouver le moyen efficace pour accéder à la base de données, c'est-à-dire sélectionner une requête efficace à partir d'un certain nombre de requêtes pour effectuer la même tâche.
4. Application utilisant JDBC pour traiter les données persistantes (tables de base de données) ayant le code spécifique de base de données en grande quantité. Le code écrit pour mapper des données de table aux objets d'application et vice versa est en fait pour mapper des champs de table aux propriétés d'objet. Comme la table a changé ou la base de données a changé alors il est essentiel de changer la structure de l'objet ainsi que de changer le code écrit à la carte tableau-objet/objet-de-table.
5. avec JDBC, il est de la responsabilité du développeur de gérer le jeu de résultats JDBC et de le convertir en objets Java par le code pour utiliser ces données persistantes dans l'application. Ainsi, avec JDBC, la cartographie entre les objets Java et les tables de base de données se fait manuellement.
6. avec JDBC, la mise en cache est maintenue par codage manuel.
7. dans JDBC il n'y a pas de vérification que chaque utilisateur a toujours des données mises à jour. Cette vérification doit être ajoutée par le développeur.

mise en veille prolongée.

1. Hibernate est une solution souple et puissante pour cartographier les classes Java aux tables de base de données. Hibernate lui-même s'occupe de ce mappage en utilisant des fichiers XML pour que le développeur n'ait pas besoin d'écrire de code pour cela.
2. Hibernate fournit la persistance transparente et le développeur n'a pas besoin d'écrire le code explicitement pour cartographier les tables tuples de base de données aux objets d'application pendant l'interaction avec RDBMS.
3. Hibernate fournit un langage de requête Hibernate langage de requête puissant (indépendant du type de base de données) qui est exprimé dans une syntaxe SQL comme familière et comprend le plein soutien pour les requêtes polymorphic. Hibernate prend également en charge les requêtes SQL natives. Il sélectionne également un moyen efficace d'effectuer une tâche de manipulation de base de données pour une application.
4. hibernation fournit cette cartographie elle-même. La mise en correspondance entre les tableaux et les objets d'application se fait en XML fichier. S'il y a un changement dans la base de données ou dans n'importe quelle table alors le seul besoin de changer les propriétés de fichier XML.
5. Hibernate réduit les lignes de code en maintenant la cartographie objet-table elle-même et renvoie le résultat à l'application sous forme D'objets Java. Il libère le programmeur de la manipulation manuelle de données persistantes, réduisant ainsi le temps de développement et le coût de maintenance.
6. hibernation, avec persistance transparente, le cache est réglé sur application work space. Les tuples relationnels sont déplacé dans ce cache à la suite de la requête. Il améliore les performances si l'application client lit les mêmes données plusieurs fois pour la même écriture. La persistance transparente automatique permet au développeur de se concentrer davantage sur la logique d'affaires plutôt que sur ce code d'application.
7. Hibernate permet au développeur de définir le type de version champ À application, en raison de ce champ défini Hibernate mises à jour de version champ de la table de base de données chaque fois que relational tuple est mis à jour sous forme D'objet de classe Java cette table. Ainsi, si deux utilisateurs récupèrent le même tuple, puis le modifient et qu'un utilisateur enregistre ce tuple modifié dans la base de données, la version est automatiquement mise à jour pour ce tuple par hibernation. Quand un autre utilisateur essaie de sauver le tuple mis à jour à la base de données alors il ne permet pas de le sauver parce que cet utilisateur n'a pas de données mises à jour.

Ça dépend aussi de la courbe d'apprentissage.

Orme des Caraïbes a une courbe d'apprentissage assez faible (API simple, langage de requête simple) si vous êtes assez heureux avec les annotations JPA pour la cartographie (@Entity, @Table, @OneToMany etc).

je crois que vous avez oublié de regarder "Fonctionnelle Relational Mapping"

Je résumerais en disant:

• si vous voulez vous concentrer sur les structures de données, utilisez un ORM comme JPA / Hibernate
• si vous voulez faire la lumière sur les traitements, jetez un oeil aux bibliothèques FRM: QueryDSL ou Jooq
• si vous avez besoin d'accorder vos requêtes SQL à des bases de données spécifiques, utilisez JDBC et les requêtes SQL natives

la force de divers "mappages relationnels"" les technologies sont transférables: vous vous assurez que votre application fonctionnera sur la plupart des bases de données ACID. Autrement, vous allez gérer les différences entre les différents dialectes SQL lorsque vous écrivez manuellement les requêtes SQL.

bien sûr, vous pouvez vous limiter à la norme SQL92 (et ensuite faire de la programmation fonctionnelle) ou vous pouvez réutiliser certains concepts de programmation fonctionnelle avec des cadres ORM

les strengths ORM sont construits sur un objet session qui peut agir comme un goulot d'étranglement:

1. il gère le cycle de vie des objets tant que la transaction de base de données sous-jacente est en cours.
2. il maintient un mappage individuel entre vos objets java et vos lignes de base de données (et utilise un cache interne pour éviter les objets dupliqués).
3. il détecte automatiquement les mises à jour d'association et les objets orphelins à supprimer
4. il traite les questions de concurrence avec optimiste ou pessimiste verrouillage.

néanmoins, ses forces sont aussi ses faiblesses:

1. la session doit être capable de comparer des objets donc vous devez implémenter les méthodes equals/hashCode Mais L'égalité des objets doit être enracinée sur des "clés D'affaires" et non sur l'id de la base de données (les nouveaux objets transitoires n'ont pas D'ID de la base de données!). Cependant, certains concepts revisités n'ont pas d'égalité commerciale (une opération par exemple). Une solution de contournement commune repose sur des GUIDs qui ont tendance à perturber la base de données administrateur.

2. la session doit modifier les relations d'espionnage mais ses règles de mappage poussent l'utilisation de collections inappropriées pour les algorithmes d'affaires. Parfois, vous souhaitez utiliser un HashMap mais L'ORM exigera que la clé soit un autre "objet de domaine riche" au lieu d'un autre "objet de lumière"... Ensuite, vous devez mettre en œuvre l'égalité d'objet sur l'objet de domaine riche agissant comme une clé... Mais vous ne pouvez pas parce que cet objet n'a pas de contrepartie dans le monde des affaires. Si vous revenez à une liste simple sur laquelle vous devez itérer (et les problèmes de performance résultent de)

3. l'API ORM est parfois Impropre à une utilisation dans le monde réel. Par exemple, les applications web du monde réel tentent de renforcer l'isolement des sessions en ajoutant des clauses "où" lorsque vous récupérez des données... Puis la "Session".get( id) " ne suffit pas et vous devez vous tourner vers des DSL plus complexes (HSQL, API critères) ou revenir vers le SQL natif

4. les objets de la base de données conflits avec d'autres objets dédiés à d'autres cadres (comme OXM frameworks = Object/XML Mapping). Par exemple, si vos services de repos utilisent la bibliothèque jackson pour sérialiser un objet d'affaires. Mais ce Jackson correspond exactement à un hibernant. Ensuite, soit vous fusionnez les deux et un fort couplage entre votre API et votre base de données apparaît Ou vous devez implémenter une traduction et tout le code que vous avez sauvegardé de l'ORM est perdu là...

de l'autre côté, la FRM est un compromis entre "Object Relational Mapping" (ORM) et les requêtes SQL natives (avec JDBC)

la meilleure façon d'expliquer les différences entre FRM et ORM consiste à adopter une approche DDD.

• Object Relational Mapping autorise l'utilisation de "rich Domain Object" qui sont des classes Java dont les États sont mutables pendant la transaction de base de données
• la cartographie relationnelle fonctionnelle repose sur des "objets de domaine pauvres" qui sont immuables (à tel point que vous devez cloner un nouveau chaque fois que vous voulez modifier son contenu)

il libère les contraintes mises sur la session ORM et s'appuie la plupart du temps sur un DSL sur le SQL (donc la portabilité n'a pas d'importance) Mais d'un autre côté, vous devez examiner les détails de la transaction, les questions de concurrence

Liste des personnes = queryFactory.selectFrom(personne) .où( personne.prénom.EQ ("John"), personne.lastName.eq ("Doe")) .fetch ();