¿Qué ORM de Java prefieres y por qué? [cerrado]

Es una pregunta bastante abierta. Comenzaré un nuevo proyecto y estoy mirando diferentes ORM para integrar con el acceso a la base de datos.

¿Tienes algún favorito? ¿Hay alguna que le aconseje mantenerse alejado?

He dejado de usar ORM.

La razón no es ningún gran defecto en el concepto. Hibernate funciona bien. En cambio, descubrí que las consultas tienen una sobrecarga baja y puedo ajustar mucha lógica compleja en consultas SQL grandes, y transferir gran parte de mi procesamiento a la base de datos.

Así que considere usar el paquete JDBC.

Ninguno, porque tener un ORM quita demasiado control con pequeños beneficios. Los ahorros de tiempo ganados se eliminan fácilmente cuando tiene que depurar anomalías resultantes del uso del ORM. Además, los ORM desalientan a los desarrolladores a aprender SQL y cómo funcionan las bases de datos relacionales y usar esto para su beneficio.

Muchos ORM son geniales, necesita saber por qué desea agregar abstracción sobre JDBC. Puedo recomendarle http://www.jooq.org (descargo de responsabilidad: soy el creador de jOOQ, por lo que esta respuesta es parcial). jOOQ adopta el siguiente paradigma:

• SQL es algo bueno. Muchas cosas se pueden expresar muy bien en SQL. No hay necesidad de abstracción completa de SQL.
• El modelo de datos relacionales es algo bueno. Ha demostrado ser el mejor modelo de datos de los últimos 40 años. No hay necesidad de bases de datos XML o modelos de datos verdaderamente orientados a objetos. En cambio, su empresa ejecuta varias instancias de Oracle, MySQL, MSSQL, DB2 o cualquier otro RDBMS.
• SQL tiene una estructura y sintaxis. No debe expresarse utilizando la concatenación de cadenas de "bajo nivel" en JDBC, o la concatenación de cadenas de "alto nivel" en HQL, que son propensas a contener errores de sintaxis.
• El enlace variable tiende a ser muy complejo cuando se trata de consultas importantes. ESO es algo que debería ser abstraído.
• Los POJO son excelentes al escribir código Java manipulando datos de la base de datos.
• Los POJO son difíciles de escribir y mantener manualmente. La generación de código es el camino a seguir. Tendrá consultas seguras para la compilación, incluida la seguridad del tipo de datos.
• La base de datos es lo primero. Si bien la aplicación en la parte superior de su base de datos puede cambiar con el tiempo, la base de datos en sí misma probablemente durará más.
• Sí, tiene procedimientos almacenados y tipos definidos por el usuario (UDT) en su base de datos heredada. Su herramienta de base de datos debería soportar eso.

Hay muchos otros buenos ORM. Especialmente Hibernate o iBATIS tienen una gran comunidad. Pero si está buscando una intuitiva y simple, le diré que pruebe jOOQ. ¡Te va a encantar! :-)

Mira este ejemplo de SQL:

  // Select authors with books that are sold out
  SELECT * 
    FROM T_AUTHOR a
   WHERE EXISTS (SELECT 1
                   FROM T_BOOK
                  WHERE T_BOOK.STATUS = 'SOLD OUT'
                    AND T_BOOK.AUTHOR_ID = a.ID);

Y cómo se puede expresar en jOOQ:

  // Alias the author table
  TAuthor a = T_AUTHOR.as("a");

  // Use the aliased table in the select statement
  create.selectFrom(a)
        .whereExists(create.selectOne()
                           .from(T_BOOK)
                           .where(T_BOOK.STATUS.equal(TBookStatus.SOLD_OUT)
                           .and(T_BOOK.AUTHOR_ID.equal(a.ID))))));

Hibernate, porque es básicamente el estándar de facto en Java y fue una de las fuerzas impulsoras en la creación de la JPA. Tiene un excelente soporte en Spring, y casi todos los frameworks de Java lo admiten. Finalmente, GORM es una envoltura realmente genial a su alrededor que hace buscadores dinámicos y así sucesivamente usando Groovy.

Incluso se ha portado a .NET (NHibernate) para que pueda usarlo allí también.

Hibernate, porque:

• es estable: existe desde hace tantos años que carece de problemas importantes
• dicta los estándares en el campo ORM
• implementa el estándar (JPA), además de dictarlo.
• tiene toneladas de información al respecto en Internet. Hay muchos tutoriales, soluciones de problemas comunes, etc.
• es poderoso: puede traducir un modelo de objeto muy complejo en un modelo relacional.
• tiene soporte para cualquier RDBMS mayor y medio
• es fácil trabajar con él, una vez que lo aprendes bien

Algunos puntos sobre por qué (y cuándo) usar ORM:

• trabaja con objetos en su sistema (si su sistema se ha diseñado bien). Incluso si usa JDBC, terminará haciendo una capa de traducción, de modo que transfiera sus datos a sus objetos. Pero mis apuestas son que hibernar es mejor en traducción que cualquier solución personalizada.
• No te priva del control. Puede controlar las cosas con detalles muy pequeños, y si la API no tiene alguna función remota, ejecute una consulta nativa y la tendrá.
• cualquier sistema de tamaño mediano o grande no puede permitirse el lujo de tener una tonelada de consultas (ya sea en un lugar o dispersas), si pretende ser mantenible
• Si el rendimiento no es crítico. Hibernate agrega sobrecarga de rendimiento, que en algunos casos no se puede ignorar.

Yo recomendaría usar MyBatis . Es una capa delgada encima de JDBC, es muy fácil asignar objetos a tablas y aún usar SQL simple, todo está bajo su control.

Tuve una muy buena experiencia con Avaje Ebean cuando estaba escribiendo una aplicación JavaSE de tamaño mediano.

Utiliza anotaciones JPA estándar para definir entidades, pero expone una API mucho más simple (No EntityManager o cualquiera de esas basura de entidades adjuntas / desconectadas). También le permite usar fácilmente consultas SQL o llamadas JDBC de eventos simples cuando sea necesario.

También tiene una API muy fluida y segura para escribir para consultas. Puedes escribir cosas como:

List<Person> boys = Ebean.find(Person.class)
                                  .where()
                                       .eq("gender", "M")
                                       .le("age", 18)
                                  .orderBy("firstName")
                                  .findList();

SimpleORM , porque es sencillo y sin magia. Define todas las estructuras de metadatos en código Java y es muy flexible.

SimpleORM proporciona una funcionalidad similar a Hibernate al asignar datos en una base de datos relacional a objetos Java en la memoria. Las consultas se pueden especificar en términos de objetos Java, la identidad del objeto se alinea con las claves de la base de datos, las relaciones entre los objetos se mantienen y los objetos modificados se enjuagan automáticamente a la base de datos con bloqueos optimistas.

Pero a diferencia de Hibernate, SimpleORM utiliza una estructura y arquitectura de objetos muy simples que evitan la necesidad de análisis complejos, procesamiento de código de bytes, etc. dependencia (Slf4j). (Hibernate tiene más de 2400 K más unos 2000 K de jarras dependientes). Esto hace que SimpleORM sea fácil de entender y reduce en gran medida el riesgo técnico.

Eclipse Link , por muchas razones, pero notablemente siento que tiene menos hinchazón que otras soluciones principales (al menos menos hinchazón en la cara).

Oh y Eclipse Link ha sido elegido para ser la implementación de referencia para JPA 2.0

Si bien comparto las preocupaciones con respecto a los reemplazos de Java para consultas SQL de forma libre, realmente creo que las personas que critican a ORM lo están haciendo debido a un diseño de aplicación generalmente pobre.

El verdadero OOD está impulsado por clases y relaciones, y ORM le ofrece un mapeo consistente de diferentes tipos de relaciones y objetos. Si utiliza una herramienta ORM y termina codificando expresiones de consulta en cualquier lenguaje de consulta que admita el marco ORM (incluidos, entre otros, árboles de expresiones Java, métodos de consulta, OQL, etc.), definitivamente está haciendo algo mal, es decir, su modelo de clase lo más probable es que no respalde sus requisitos de la manera que debería. Un diseño de aplicación limpio realmente no necesita consultas a nivel de aplicación. He estado refactorizando muchos proyectos que la gente comenzó a usar un marco ORM de la misma manera que se usaban para incrustar constantes de cadena SQL en su código, y al final todos quedaron sorprendidos de lo simple y fácil de mantener que toda la aplicación se vuelve una vez que coinciden sube tu modelo de clase con el modelo de uso. Por supuesto, para cosas como la funcionalidad de búsqueda, etc., necesita un lenguaje de consulta, pero aun así las consultas están tan limitadas que crear una VISIÓN y mapeo aún más complejo que a una clase persistente de solo lectura es mucho más agradable de mantener y mirar que construir expresiones en algún lenguaje de consulta en el código de su aplicación. El enfoque VIEW también aprovecha las capacidades de la base de datos y, a través de la materialización, puede ser mucho mejor en términos de rendimiento que cualquier SQL escrito a mano en su fuente Java. Por lo tanto, no veo ninguna razón para que una aplicación no trivial NO use ORM. pero incluso entonces las consultas están tan limitadas que crear una VIEW y un mapeo aún más complejos que a una clase persistente de solo lectura es mucho más agradable de mantener y observar que construir expresiones en algún lenguaje de consulta en el código de su aplicación. El enfoque VIEW también aprovecha las capacidades de la base de datos y, a través de la materialización, puede ser mucho mejor en términos de rendimiento que cualquier SQL escrito a mano en su fuente Java. Por lo tanto, no veo ninguna razón para que una aplicación no trivial NO use ORM. pero incluso entonces las consultas están tan limitadas que crear una VIEW y un mapeo aún más complejos que a una clase persistente de solo lectura es mucho más agradable de mantener y observar que construir expresiones en algún lenguaje de consulta en el código de su aplicación. El enfoque VIEW también aprovecha las capacidades de la base de datos y, a través de la materialización, puede ser mucho mejor en términos de rendimiento que cualquier SQL escrito a mano en su fuente Java. Por lo tanto, no veo ninguna razón para que una aplicación no trivial NO use ORM.