Utiliser les classes java dans Grails

Question

J'ai une application Java \ Spring \ Hibernate - complète avec des classes de domaine qui sont essentiellement des POJO Hibernate

Il existe une fonctionnalité qui, à mon avis, peut être bien écrite en Grails.

Je souhaite réutiliser les classes de domaine que j'ai créées dans l'application Java principale

Quelle est la meilleure façon de le faire?

Dois-je écrire de nouvelles classes de domaine étendant les classes Java? cela semble collant Ou puis-je "générer" des contrôleurs à partir des classes de domaine Java?

Quelles sont les meilleures pratiques en matière de réutilisation des objets de domaine Java dans Grails \ Groovy Je suis sûr qu'il doit y avoir d'autres personnes écrivant des morceaux dans grails \ groovy

Si vous connaissez un tutoriel qui parle d'une telle intégration, ce serait génial !!!

PS: Je suis un novice dans le grails, il est donc possible que l’évidence manque. Merci !!!

Answer 1

Voulez-vous vraiment / devez-vous utiliser Grails plutôt que simplement Groovy?

Vous ne pouvez vraiment pas utiliser Grails pour ajouter une pièce à une application Web existante. L'ensemble "convention sur configuration" approche signifie que vous devez quasiment respecter les règles de Grails, sinon il ne sert à rien de l’utiliser. Et l’une de ces règles est que les objets de domaine sont des classes Groovy fortement "améliorées". par le runtime Grails.

Il serait peut-être possible de les faire étendre les classes Java existantes, mais je ne parierais pas dessus - et toutes les parties Spring et Hibernate de votre application existante devraient être mises au rebut, ou du moins vous auriez dû dépenser beaucoup d’efforts pour les faire fonctionner à Grails. Vous combattrez le cadre plutôt que d'en tirer profit.

IMO, vous avez deux options:

• Réécrivez votre application dans Grails tout en réutilisant le plus possible le code existant.
• Conservez votre application telle qu'elle est et ajoutez de nouvelles choses dans Groovy sans utiliser Grails.

Ce dernier est probablement mieux dans votre situation. Grails est conçu pour créer de nouvelles applications Web très rapidement, c'est là que ça brille. Ajouter des éléments à une application existante n’est tout simplement pas son objectif.

MODIFIER: En ce qui concerne la clarification dans les commentaires: si vous envisagez d'écrire essentiellement une interface de saisie / maintenance de données pour les données utilisées par une autre application et que la base de données soit le seul canal de communication entre elles, cela pourrait fonctionner assez bien avec Grails; il peut certainement être configuré pour utiliser un schéma de base de données existant au lieu de créer ses propres classes de domaine (bien que cette dernière demande moins de travail).

Answer 2

Knowing just how well Groovy and Grails excel at integrating with existing Java code, I think I might be a bit more optimistic than Michael about your options.

First thing is that you're already using Spring and Hibernate, and since your domain classes are already POJOs they should be easy to integrate with. Any Spring beans you might have can be specified in an XML file as usual (in grails-app/conf/spring/resources.xml) or much more simply using the Spring bean builder feature of Grails. They can then be accessed by name in any controller, view, service, etc. and worked with as usual.

Here are the options, as I see them, for integrating your domain classes and database schema:

• Bypass GORM and load/save your domain objects exactly as you're already doing.

  Grails doesn't force you to use GORM, so this should be quite straightforward: create a .jar of your Java code (if you haven't already) and drop it into the Grails app's lib directory. If your Java project is Mavenized, it's even easier: Grails 1.1 works with Maven, so you can create a pom.xml for your Grails app and add your Java project as a dependency as you would in any other (Java) project.

  Either way you'll be able to import your classes (and any supporting classes) and proceed as usual. Because of Groovy's tight integration with Java, you'll be able to create objects, load them from the database, modify them, save them, validate them etc. exactly as you would in your Java project. You won't get all the conveniences of GORM this way, but you would have the advantage of working with your objects in a way that already makes sense to you (except maybe with a bit less code thanks to Groovy). You could always try this option first to get something working, then consider one of the other options later if it seems to make sense at that time.

  One tip if you do try this option: abstract the actual persistence code into a Grails service (StorageService perhaps) and have your controllers call methods on it rather than handling persistence directly. This way you could replace that service with something else down the road if needed, and as long as you maintain the same interface your controllers won't be affected.

• Create new Grails domain classes as subclasses of your existing Java classes.

  This could be pretty straightforward if your classes are already written as proper beans, i.e. with getter/setter methods for all their properties. Grails will see these inherited properties as it would if they were written in the simpler Groovy style. You'll be able to specify how to validate each property, using either simple validation checks (not null, not blank, etc.) or with closures that do more complicated things, perhaps calling existing methods in their POJO superclasses.

  You'll almost certainly need to tweak the mappings via the GORM mapping DSL to fit the realities of your existing database schema. Relationships would be where it might get tricky. For example, you might have some other solution where GORM expects a join table, though there may even be a way to work around differences such as these. I'd suggest learning as much as you can about GORM and its mapping DSL and then experiment with a few of your classes to see if this is a viable option.

• Have Grails use your existing POJOs and Hibernate mappings directly.

  I haven't tried this myself, but according to Grails's Hibernate Integration page this is supposed to be possible: "Grails also allows you to write your domain model in Java or re-use an existing domain model that has been mapped using Hibernate. All you have to do is place the necessary 'hibernate.cfg.xml' file and corresponding mappings files in the '%PROJECT_HOME%/grails-app/conf/hibernate' directory. You will still be able to call all of the dynamic persistent and query methods allowed in GORM!"

  Googling "gorm legacy" turns up a number of helpful discussions and examples, for example this blog post by Glen Smith (co-author of the soon-to-be-released Grails in Action) where he shows a Hibernate mapping file used to integrate with "the legacy DB from Hell". Grails in Action has a chapter titled "Advanced GORM Kungfu" which promises a detailed discussion of this topic. I have a pre-release PDF of the book, and while I haven't gotten to that chapter yet, what I've read so far is very good, and the book covers many topics that aren't adequately discussed in other Grails books.

Sorry I can't offer any personal experience on this last option, but it does sound doable (and quite promising). Whichever option you choose, let us know how it turns out!

Answer 3

This post provides some suggestions for using grails for wrapping existing Java classes in a web framework.