Remplacement d'un ORM complet (JPA / Hibernate) par une solution plus légère: modèles recommandés pour charger/enregistrer?

La réponse à vos nombreuses questions est simple. Vous avez trois choix.

1. utilisez l'un des trois outils SQL-centric que vous avez mentionnés ( MyBatis , jOOQ , DbUtils ). Cela signifie que vous devez arrêter de penser en termes de votre modèle de domaine OO et de mappage Objet-Relationnel (i.e. entities et lazy loading). SQL est sur les données relationnelles et les RBDMS sont assez bons pour calculer plans d'exécution pour "chercher impatiemment" le résultat de plusieurs jointures. Habituellement, il n'y a même pas beaucoup de besoin pour la mise en cache prématurée, et si vous avez besoin de mettre en cache l'élément de données occasionnelle, vous pouvez toujours utiliser quelque chose comme EhCache

2. N'utilisez aucun de ces outils SQL-centric et collez avec Hibernate / JPA. Parce que même si tu dis que tu n'aimes pas hiberner, tu "penses hiberner". Hibernation est très bonne à persister graphiques d'objets vers la base de données. Aucun de ces outils ne peut être forcé à travailler comme hibernation, parce que leur mission est autre chose. Leur mission est d'opérer sur SQL.

3. allez d'une manière entièrement différente et choisissez de ne pas utiliser un modèle de données relationnelles. D'autres modèles de données (graphiques, par exemple) peut mieux vous convenir. Je mets cela comme une troisième option, parce que vous pourriez ne pas réellement avoir ce choix, et je n'ai pas beaucoup d'expérience personnelle avec d'autres modèles.

notez que votre question ne concernait pas spécifiquement jOOQ. Néanmoins, avec jOOQ, vous pouvez externaliser la cartographie des résultats de requêtes plates (produites à partir de sources de table jointes) pour objecter des graphiques à travers des outils externes tels que ModelMapper . Il y a un fil de discussion intéressant sur une telle intégration sur le groupe D'utilisateurs ModelMapper .

(clause de non-responsabilité: je travaille pour la société derrière jOOQ)

La Persistance Des Approches

le spectre des solutions simples / de base à sophistiquées / riches est:

• SQL/JDBC - dur-code SQL à l'intérieur des objets
• SQL-Base de Cadre (par exemple, jOOQ, MyBatis) - Modèle d'Enregistrement Active (séparée objet général représente les données de lignes et poignées SQL)
• ORM-Framework (e.g. Hibernate, EclipseLink, Datanucléus) - Data Mapper Pattern (Objet par entité) plus Unité de modèle de travail (contexte de persistance / Gestionnaire D'entité)

vous cherchez à mettre en œuvre l'un des deux premiers niveaux. Cela signifie déplacer la mise au point loin du modèle d'objet vers SQL. Mais votre question demande des cas d'utilisation impliquant le modèle d'objet étant mappé en SQL (c'est-à-dire le comportement ORM). Vous souhaitez ajouter des fonctionnalités à partir du troisième niveau contre des fonctionnalités à partir de l'un des deux premiers niveaux.

nous pourrions essayez de mettre en œuvre ce comportement dans un dossier actif. Mais cela nécessiterait des métadonnées riches à attacher à chaque instance Active D'enregistrement - l'entité réelle impliquée, ses relations avec d'autres entités, les paramètres de chargement paresseux, les paramètres de mise à jour en cascade. Cela en ferait effectivement un objet d'entité cartographié caché. De plus, jOOQ et MyBatis ne font pas cela pour les cas D'utilisation 1 et 2.

Comment Réaliser Vos Demandes?

implémenter un comportement ORM étroit directement dans vos objets, comme une petite couche personnalisée sur le dessus de votre cadre ou SQL/JDBC brut.

Cas d'Utilisation 1: Stocker les métadonnées pour chaque entité relation de l'objet: (i) si la relation doit être paresseux-chargé (niveau de classe) et (ii) si lazy-load a eu lieu (au niveau de l'objet). Ensuite, dans la méthode getter, utilisez ces options pour déterminer s'il faut faire paresseux-load et le faire réellement.

cas D'utilisation 2: similaire à Utilisez le cas 1-Faites-le vous-même. Stockez un drapeau sale dans chaque entité. Pour chaque relation d'objet d'entité, stockez un drapeau décrivant si la sauvegarde doit être en cascade. Puis quand une entité est sauvée, visitez récursivement chaque relation "save cascade". Ecrivez toutes les entités sales découvertes.

Modèles

• Lazy Load
• Mises À Jour En Cascade
• Mappage Des Métadonnées
• Unité de travail

Pros

• les appels à SQL framework sont simples.

Cons

• vos objets deviennent plus compliqués. Jetez un coup d'oeil au code D'utilisation des cas 1 et 2 un produit open source. Ce n'est pas anodin
• manque de support pour le modèle D'objet. Si vous utilisez object model en java pour votre domaine, il aura moins de support pour les opérations de données.
• risque de fluage et d'anti-patterns de scope: la fonctionnalité manquante ci-dessus est la pointe de l'iceberg. Peut finir par faire quelque réinventer la roue et L'engrenage de L'Infrastructure dans la logique des Affaires.
• l'Éducation et l'Entretien de la non-solution standard. JPA, JDBC et SQL sont des standards. D'autres cadres ou solutions personnalisées ne le sont pas.

ça vaut le coup???

Cette solution fonctionne bien si vous avez des exigences assez simples de traitement de données et un modèle de données avec un plus petit nombre d'entités:

• Si oui, génial! Ne ci-dessus.
• si non, Cette solution est un mauvais ajustement et représente de fausses économies dans l'effort - c.-à-d. finira par ça prend plus de temps et c'est plus compliqué que d'utiliser un ORM. Dans ce cas, jetez un autre coup d'oeil à JPA - il pourrait être plus simple que vous le pensez et il soutient ORM pour CRUD plus SQL brut pour les requêtes compliquées :-).

les dix dernières années, j'ai utilisé JDBC, EJB entité beans, Hibernate, GORM et enfin JPA (dans cet ordre). Pour mon projet actuel, je suis retourné à l'utilisation JDBC simple, parce que l'accent est mis sur la performance. C'est pourquoi je voulais

• contrôle total sur la génération D'énoncés SQL: pour être en mesure de passer une déclaration à des accordeurs de performance DB, et de mettre la version optimisée dans le programme
• Full contrôle sur le nombre de déclarations SQL qui sont envoyés à la base de données
• procédures stockées (triggers), fonctions stockées (pour les calculs complexes dans les requêtes SQL)
• pour pouvoir utiliser toutes les fonctionnalités SQL disponibles sans restrictions (requêtes récursives avec CTEs, fonctions d'agrégation de fenêtres, ...)

le modèle de données est défini dans un dictionnaire de données; à l'aide d'une approche axée sur le modèle a generator crée des classes d'aide, des scripts DDL, etc. La plupart des opérations sur la base de données sont en lecture seule; seulement quelques cas d'utilisation écrire.

Question 1: aller chercher les enfants

Le système est construit sur un cas d'utilisation, et que nous avons dédiée instruction SQL pour obtenir toutes les données pour un cas d'utilisation/demande. Certains des États SQL sont plus grands que 20kb, ils rejoignent, calculent en utilisant des fonctions stockées écrites en Java/Scala, trier, paginer etc. de manière à ce que le résultat soit directement mappé dans un objet de transfert de données qui, à son tour, est introduit dans la vue (pas de traitement supplémentaire dans la couche application). En conséquence, l'objet de transfert de données est en cas d'utilisation spécifiques. Il ne contient que les données pour le cas d'utilisation (rien de plus, rien de moins).

comme le jeu de résultats est déjà" pleinement joint " il n'y a pas besoin de paresseux/impatient fetching etc. L'objet de transfert de données est terminé. Un cache n'est pas nécessaire (le le cache de la base de données est correct); l'exception: si le jeu de résultats est grand (environ 50 000 lignes), l'objet de transfert de données est utilisé comme valeur de cache.

Question 2: Épargner

après que le contrôleur a fusionné en arrière les changements de L'interface graphique, encore une fois il y a un objet spécifique qui tient les données: fondamentalement les lignes avec un État (Nouveau, supprimé, modifié, ...) dans une hiérarchie. C'est une itération manuelle pour sauvegarder les données dans la hiérarchie: les données nouvelles ou modifiées sont a persisté en utilisant certaines classes d'aide avec les commandes generate SQL insert ou update . Comme pour les éléments supprimés, ceci est optimisé dans les deletes en cascade (PostgreSql). Si plusieurs lignes doivent être supprimées, cela est optimisé en une seule déclaration delete ... where id in ... ainsi.

encore une fois, il s'agit d'un cas d'utilisation spécifique, donc il ne s'agit pas d'une approche générale. Il a besoin de plus de lignes de code, mais ce sont les lignes qui contiennent les optimisations.

le l'expérience

• il ne faut pas sous-estimer l'effort pour apprendre L'hibernation ou le JPA. Il faut prendre en compte le temps passé à configurer les caches, l'invalidation du cache dans un cluster, la recherche avide/paresseuse, et le réglage ainsi. La migration vers une autre version majeure D'hibernation n'est pas seulement une recompilation.
• il ne faut pas surestimer l'effort pour construire une application sans ORM.
• il est plus simple D'utiliser SQL directement-être fermer à SQL (comme HQL, JPQL) est pas le même, surtout si vous parlez à votre accordeur de performance DB
• les serveurs SQL sont incroyablement rapides lors de l'exécution de requêtes longues et complexes, surtout si elles sont combinées avec des fonctions stockées écrites en Scala
• même avec les instructions SQL spécifiques au cas d'utilisation, la taille du code est plus petite: les ensembles de résultats" Fully joined " sauvegardent beaucoup de lignes dans le la couche application.

informations connexes:

• quand utiliser ORM
• ANORM n'est pas un object relational mapper

Mise À Jour: Interfaces

S'il y a une entité Person dans le modèle de données logique, il y a une classe pour persister une entité Person (pour les opérations CRUD), juste comme une entité JPA.

mais le clou est qu'il n'y a pas d'entité unique Person du point de vue de l'utilisation / requête / logique commerciale: chaque méthode de service définit son propre notion d'une Person , et il ne contient que exactement les valeurs exigées par ce cas d'utilisation. Rien de plus, rien de moins. Nous utilisons Scala, de sorte que la définition et l'utilisation de nombreuses petites classes est très efficace (pas de code de chaudière setter/getter requis.)

exemple:

class GlobalPersonUtils {
  public X doSomeProcessingOnAPerson(
    Person person, PersonAddress personAddress, PersonJob personJob, 
    Set<Person> personFriends, ...)
}

est remplacé par

class Person {
  List addresses = ...
  public X doSomeProcessingOnAPerson(...)
}

class Dto {
  List persons = ...
  public X doSomeProcessingOnAllPersons()
  public List getPersons()
}

utilisant le cas d'utilisation spécifique Persons , Adresses etc: dans ce cas, le Person regroupe déjà toutes les données pertinentes. Nécessite plus de classes, mais il n'est pas nécessaire de passer autour des entités JPA.

Notez que ce traitement est en lecture seule, les résultats sont utilisés par la vue. Exemple: obtenir distinct City cas d'une personne de la liste.

si les données sont modifiées, il s'agit d'un autre cas d'utilisation: si la ville d'une personne est modifiée, cela est traité par une méthode de service différente, et la personne est récupérée à nouveau à partir de la base de données.

Avertissement: Ceci est un autre plug sans vergogne à partir d'un projet d'auteur.

Check out JSimpleDB et voir si elle répond à vos critères de simplicité / puissance. Il s'agit d'un nouveau projet né de plus de 10 ans de frustration essayant de traiter la persistance Java via SQL et ORM.

il fonctionne sur le dessus de n'importe quelle base de données qui peut fonctionner comme un magasin de clé/valeur, par exemple, FoundationDB (ou N'importe quelle base de données SQL, bien que tout sera bloqué dans une seule table clé/valeur).

Il semble que la question centrale dans la question, avec le modèle relationnel lui-même. À partir de ce qui a été décrit, une base de données de graphiques va cartographier le domaine de problème très clairement. Comme alternative, les magasins de documents sont une autre façon d'aborder le problème parce que, alors que l'impédance est encore là, les documents en général sont plus simples à raisonner que les ensembles. Bien sûr, toute approche va avoir ses propres particularités.

puisque vous voulez une bibliothèque simple et légère et D'utiliser SQL, je peux vous suggérer de jeter un oeil à fjorm . Il vous permet D'utiliser POJOs et CRUD opérations sans beaucoup d'effort.

avertissement: je suis un auteur du projet.