Est-ce que rester agnostique à la mise en œuvre en vaut vraiment la peine?

J'ai un projet sur lequel je travaille actuellement en utilisant Tomcat, Spring 4, Spring Security, MySQL et JPA avec Hibernate.

J'ai choisi JPA du point de vue qu'il est censé rendre la mise en œuvre sous-jacente des fournisseurs ORM transparente, ou du moins moins douloureuse. Je dirais que cela utilise mentalement la spécification sur la mise en œuvre (JAX-RS) est le point de vue par défaut de la communauté de développement Java.

Je suis curieux de savoir si c'est vraiment une tâche qui mérite d'être accomplie. Je suis sûr que si j'utilisais Hibernate directement, je gagnerais en puissance car je pourrais utiliser des fonctionnalités qui ne font pas partie de la spécification JPA principale.

Une partie de ma préoccupation vient de l'idée de YAGNI. Je programme essentiellement dans un style et une mode spécifiques (en utilisant JPA au lieu de Hibernate) afin qu'à un moment donné dans le futur, je puisse échanger mon implémentation ORM. Je doute fortement que cela se produise au cours de la vie du produit, donc je fais essentiellement des efforts pour quelque chose dont je ne récolterai probablement jamais les bénéfices.

Quelles sont vos pensées? La «programmation vers l'interface» en vaut-elle la peine lorsqu'il s'agit de choses comme JPA? Avez-vous déjà échangé une implémentation ORM entière dans un produit? Avez-vous déjà pu éviter complètement l'abstraction de quelque chose comme JPA qui fuit de toute façon? Personnellement, j'ai déjà un seul appel SQL natif (pour nettoyer les tables de la base de données), et il y a des choses que j'aimerais faire avec qui sont intégrées dans la spécification JPA (obtenir / définir des préfixes pour vos méthodes et la différence entre MEMBER OF / IN, qui ne me liant qu'à une implémentation sous-jacente me donnera une chance d'éviter.

de sorte qu'à un moment donné dans le futur, je puisse échanger mon implémentation ORM. Je doute fortement que cela se produise au cours de la durée de vie du produit, donc je fais essentiellement des efforts pour quelque chose dont je ne profiterai probablement jamais des avantages de

D'après mon expérience, le projet d'entreprise typique ne change jamais:

1. Base de données
2. ORM
3. La langue

Je ne connais pas les chiffres, mais le pourcentage d'applications à 2 niveaux que j'ai vu implémenter puis modifier l'une de ces choses serait probablement inférieur à 10%. Si cela se produit, c'est rare, et cela se produit généralement dans les 2-3 premiers mois du projet lorsque les gens sont encore en mode découverte. La plupart des systèmes que je connais fonctionnent toujours sur leurs plates-formes d'origine 8 à 10 ans plus tard.

Plus souvent que d'échanger un ORM, voulez-vous savoir ce que j'ai vu de plus? Suppression complète de l'ORM pour passer à SQL en raison de problèmes de performances. Peu importe quoi, dans ce cas, tu vas réécrire des trucs.

En ce qui concerne la mise en œuvre agnostique, c'est un mythe. Cela revient vraiment à faire le poids. Mon approche consiste donc à embrasser la couche de données. Faites-en une partie de première classe de votre langue et de votre design. Cela rend les projets plus heureux et plus réussis.

Est-ce que ça vaut le coup?
Cela dépendrait entièrement de l'application.
Si vous écrivez une application interne pour une seule entreprise, oubliez-la. Cette base de données survivra à l'application par des années, voire des décennies.
À moins bien sûr que l'on vous ait donné à comprendre dès le départ que la base de données devrait être remplacée par quelque chose d'autre dans un avenir proche.
Si vous l'écrivez pour la vente à des clients, qui peuvent avoir différents moteurs de base de données, ET les exigences sont telles qu'il est censé prendre en charge plusieurs moteurs de base de données, ALORS cela a du sens.

Pour la plupart des gens qui écrivent des applications Java, cela n'est pas pertinent.

D'après mon expérience: non, cela ne vaut pas la peine en cas de JPA / Hibernate.

La «programmation vers l'interface» en vaut-elle la peine lorsqu'il s'agit de choses comme JPA?

C'est le cas, mais n'a rien à voir avec JPA en particulier. Vous pouvez faire de la "programmation aux interfaces" de l'Hibernate. Il ne s'agit pas de cacher un framework sous une norme, il s'agit de SOLID .

Avez-vous déjà échangé une implémentation ORM entière dans un produit?

Oui et non. L'un des produits de notre entreprise a partiellement migré d'Hibernate vers jOOQ (ce qui n'a rien à voir avec JPA). Ce n'était pas exactement un "projet d'entreprise typique" mentionné par @codenheim, donc l'échange était possible.

Je ne vois aucun intérêt à échanger Hibernate avec un autre ORM compatible JPA.

Avez-vous déjà pu éviter complètement l'abstraction de quelque chose comme JPA qui fuit de toute façon?

Non, c'est impossible car JPA et Hibernate sont très complexes. Et vous devez de toute façon gérer les problèmes de performances et les défauts de conception d'Hibernate.

Au risque de paraître à contre-courant ici, je dirais que oui, ça vaut le coup. Et ça ne l'est pas.

Le problème n'est pas tant de changer votre ORM ou votre fournisseur de base de données en tant que tel. Il s'agit plus d'une question de séparation des préoccupations et de rester agile.

Une fois que vous commencez à vous fier à certains détails d'implémentation d'une bibliothèque, vous commencez à créer des enchevêtrements de plus en plus profonds.

Si vous savez que votre implémentation ORM est Hibernate, cette connaissance commence à s'infiltrer dans toute l'architecture de votre application. Et chaque fois qu'une nouvelle technologie arrive qui déplace Hibernate ou JPA aussi profondément que Hibernate l'a fait pour tout ce qui l'a précédé, vous constatez que les dépendances sont devenues beaucoup plus profondes que prévu.

Il est beaucoup mieux de cacher toute la préoccupation de maintenir votre modèle quelque part à l'écart, où toutes les subtilités des transactions avec les bases de données et les transactions et ainsi de suite, peuvent être facilement ignorées par le reste de l'application. Dans ce coin sombre à distance, vous pouvez vous nouer des détails d'implémentation spécifiques si vous le souhaitez - cela n'a plus vraiment d'importance.

Le problème avec l'agnosticisme d'implémentation est que vous perdrez du temps dans votre temps en tant que développeur.

J'ai écrit plusieurs projets que nous avons gaspillés beaucoup de temps à écrire sur une interface, qui n'ont ensuite jamais été utilisés d'une manière nouvelle, jamais convertis et simplement utilisés tels quels pendant des années

J'ai également perdu beaucoup de temps à convertir des logiciels dont personne ne s'attendait à ce qu'ils aient besoin d'être convertis.

La seule vraie observation que je dois faire, c'est que la première est beaucoup moins douloureuse.