Uso de clases de Java en Grails

Question

que tienen una aplicación Java \ Primavera \ Hibernate - completa con clases de dominio que son básicamente de hibernación POJOs

hay una pieza de funcionalidad que creo que se puede escribir bien en Grails.

Deseo volver a utilizar las clases de dominio que he creado en el principal aplicación Java

¿Cuál es la mejor manera de hacerlo?

¿Debo escribir nuevas clases de dominio ampliando las clases de Java? esto suena pegajoso ¿O puedo 'generar' controladores de las clases de dominio Java?

¿Cuáles son las mejores prácticas en torno a la reutilización de objetos de dominio en Java Grails \ maravilloso Estoy seguro de que hay otros escribiendo algunas piezas en griales \ maravilloso

Si sabe de un tutorial que habla de una integración-tales que sería increíble !!!

PD: Soy bastante novato en Grails-Groovy por lo que puede estar perdiendo lo obvio. Gracias !!!

Answer 1

¿De verdad quieres/necesitas usar Grails en lugar de solo Groovy?

Grails realmente no es algo que pueda usar para agregar una pieza a una aplicación web existente. Todo el enfoque de "convención sobre configuración" significa que prácticamente debes seguir las reglas de Grails, de lo contrario no tiene sentido usarlo. Y una de esas reglas es que los objetos de dominio son clases de Groovy que son fuertemente "mejoradas" por el tiempo de ejecución de Grails.

Podría ser posible hacer que amplíen las clases de Java existentes, pero yo no apostaría a ello, y todas las partes de Spring and Hibernate de su aplicación existente tendrían que descartarse, o al menos tendrían que gastar mucho esfuerzo para que funcionen en Grails. Lucharás contra el marco en lugar de sacar provecho de él.

OMI tiene dos opciones:

• reescribir su aplicación desde cero en Grails, mientras que la reutilización de la mayor cantidad de código existente como sea posible.
• Mantenga su aplicación como está y agregue cosas nuevas en Groovy, sin usar Grails.

Esto último es probablemente mejor en su situación. Grails está destinado a crear nuevas aplicaciones web muy rápidamente, ahí es donde brilla. Agregar cosas a una aplicación existente no es lo que estaba hecho.

EDIT: En cuanto a la clarificación en los comentarios: si usted está planeando escribir básicamente un/frontend mantenimiento de entrada de datos para los datos utilizados por otra aplicación y tienen el PP como el único canal de comunicación entre ellos, que el poder en realidad funcionan bastante bien con Grails; ciertamente se puede configurar para usar un esquema DB existente en lugar de crear el suyo propio de las clases de dominio (aunque este último es menos trabajo).

Answer 2

En esta publicación se brindan algunas sugerencias para usar grails para wrapping existing Java classes in a web framework.

Answer 3

Sabiendo lo bien que Groovy y Grails se destacan en la integración con el código Java existente, creo que podría ser un poco más optimista que Michael acerca de sus opciones.

Lo primero es que ya está utilizando Spring e Hibernate, y dado que sus clases de dominio ya son POJO, deberían ser fáciles de integrar. Los beans Spring que pueda tener se pueden especificar en un archivo XML como de costumbre (en grails-app/conf/spring/resources.xml) o mucho más simplemente utilizando la función Spring bean builder de Grails. A continuación, se puede acceder por su nombre en cualquier controlador, vista, servicio, etc. y se trabajó como de costumbre.

Estas son las opciones, como las veo, para la integración de sus clases de dominio y el esquema de base de datos:

• bypass GORM y de carga/guardar objetos de dominio tal y como ya se está haciendo.

  Grails no lo obliga a usar GORM, por lo que debería ser bastante sencillo: cree un .jar de su código Java (si no lo ha hecho) y suéltelo en el directorio lib de la aplicación Grails. Si su proyecto Java está mavenizado, es aún más fácil: Grails 1.1 funciona con Maven, por lo que puede crear un pom.xml para su aplicación Grails y agregar su proyecto Java como una dependencia como lo haría en cualquier otro proyecto (Java).

  De cualquier manera usted podrá import sus clases (y cualquier clase de apoyo) y proceder de la forma habitual. Debido a la estrecha integración de Groovy con Java, podrá crear objetos, cargarlos desde la base de datos, modificarlos, guardarlos, validarlos, etc., exactamente como lo haría en su proyecto Java. No obtendrá todas las comodidades de GORM de esta manera, pero tendría la ventaja de trabajar con sus objetos de una manera que ya tiene sentido para usted (excepto tal vez con un código un poco menos gracias a Groovy). Siempre puedes probar esta opción primero para que funcione algo, luego considerar una de las otras opciones más adelante si parece tener sentido en ese momento.

  Un consejo si prueba esta opción: abstraiga el código de persistencia real en un servicio de Grails (StorageService quizás) y pida a sus controladores que utilicen métodos en lugar de manejar la persistencia directamente. De esta forma, podría reemplazar ese servicio con algo más en el futuro si fuera necesario, y siempre que mantenga la misma interfaz, sus controladores no se verán afectados.

• Cree nuevas clases de dominio Grails como subclases de sus clases Java existentes.

  Esto podría ser bastante sencillo si sus clases ya están escritas como beans propios, es decir, con métodos getter/setter para todas sus propiedades. Grails verá estas propiedades heredadas como si estuvieran escritas en el estilo Groovy más simple. Podrá especificar cómo validar cada propiedad, utilizando verificaciones de validación simples (no nulas, no en blanco, etc.) o con cierres que hacen cosas más complicadas, tal vez llamando a métodos existentes en sus superclases de POJO.

  Es casi seguro que tendrá que modificar las asignaciones a través del GORM mapping DSL para adaptarse a las realidades de su esquema de base de datos existente. Las relaciones serían donde podría ser complicado. Por ejemplo, es posible que tenga alguna otra solución donde GORM espera una tabla de unión, aunque puede haber una forma de evitar las diferencias como estas. Te sugiero que aprendas todo lo que puedas sobre GORM y su asignación de DSL y luego experimentes con algunas de tus clases para ver si esta es una opción viable.

• Haz que Grails use tus mapeos POJO e Hibernate existentes directamente.

  No he probado esto por mi cuenta, pero según Grails Hibernate Integration page se supone que es posible: "Grails también le permite escribir su modelo de dominio en Java o reutilizar un modelo de dominio existente que se ha mapeado usando Hibernate .Todo lo que tiene que hacer es colocar el archivo 'hibernate.cfg.xml' y los archivos de asignaciones correspondientes en el directorio '% PROJECT_HOME%/grails-app/conf/hibernate'. ¡Todavía podrá llamar a todos los métodos dinámicos persistentes y de consulta permitidos en GORM! "

  Google legacy" gorm legacy "presenta una serie de útiles discusiones y ejemplos, por ejemplo this blog post por Glen Smith (coautor de el pronto en ser lanzado Grails en acción) donde muestra un archivo de mapeo de Hibernate utilizado para integrarse con "el DB heredado del infierno". Grails en acción tiene un capítulo titulado "Advanced GORM Kungfu" que promete una discusión detallada de este tema. Tengo un PDF de prelanzamiento del libro, y aunque todavía no he llegado a ese capítulo, lo que he leído hasta ahora es muy bueno, y el libro cubre muchos temas que no son discutido adecuadamente en otros libros de Grails.

Lo siento, no puedo ofrecer ninguna experiencia personal en esta última opción, pero parece factible (y bastante prometedor). Cualquiera que sea la opción que elija, ¡háganos saber cómo resulta!