
Los proyectos con ejemplos y ejercicios usan la herramienta Maven para obtener las dependencias.
Sucede ocasionalmente, que Maven puede tener problemas para obtener estas dependencias del repositorio centralizado. En estos casos, cuando abrimos el proyecto, Eclipse nos muestra numerosos errores indicando que algunas clases no han podido ser encontradas.
Si os sucede esto, aquí se explica como se suele resolver este problema:
Abrid un terminal de comandos y situaros en la raíz del proyecto (donde está el fichero pom.xml).
Ejecutad:
mvn dependency:purge-local-repository
Después, ya desde el Eclipse, refrescad las dependencias de la siguiente manera:
Sobre el proyecto en el package explorer --> botón derecho --> Maven --> Update project.
Hecho esto, los problemas de clases no encontradas desaparecerán.
Presentación de una aplicación mínima JPA usando Hibernate
Análisis del paso de un provider (Hibernate) a otro (EclipseLink)
Lección analizando como mejorar la declaración de dependencias en el proyecto.
¿Como creéis que se comportará la aplicación si hay dos providers diferentes en el classpath?
Controlando explícitamente que JPA provider va a usar nuestro persistence unit
Explicación de como vamos a usar la clase service provider para simular la creación de un persistence unit desde un contenedor.
Demostración práctica de las ideas de la última lección
Presentación a alto nivel del mecanismo de lazy loading y del método getReference
Presentación del código de ejemplo para la implementación de equals y hashcode sobre una entidad.
Explicación de por qué es incorrector implementar el equals comparando directamente el resultado de getClass() sobre los objetos que comparamos
Implementación de equals y hashcode usando getInstance y métodos getter para acceder a la otra instancia.
Proyecto que muestra como las diferencias de implementación de eclipselink y hibernate pueden tener efectos en los requisitos para implementar equals y hashcode.
Proyecto que muestra problemas que podemos tener si usamos una clave sintetica para implementar equals y hashcode
Uso de la propiedad natural para evitar los errors mostrados en la lección anterior
Aunque el uso de una propiedad natural para implementar equals y hashcode nos resuelve algunos problemas, tampoco está exento de los suyos !
Relaciones bidireccionales y presentación de las dudas que trataremos en la sección
Presentación de la cuestión: ¿Que sucede cuando intentamos guardar los datos de una relación bidireccional y estos son inconsistentes?
Muestra la ejecución del código presentado en la lección anterior y analiza el comportamiento de las relaciones al refrescar su contenido.
Explicación de la política de loading en el caso de los distintos tipos de relaciones
Demostración de como se comporta el eager loading en el caso de una relación recursiva
Propagación de operaciones de modificación sobre las relaciones
Demostración de la propagación de la operación de persist a partir de una operación de merge
¿Otro curso de JPA?
Sí, pero éste es diferente.
En este curso re-aprenderás los conceptos fundamentales de JPA con vocación de hacer un uso profesional de ellos.
Seguro que conoces la existencia del persistence context, pero: ¿sabes que implicaciones tiene gestionar centenares de miles de entidades en una sola transacción?
Seguro que has usado transacciones en tus aplicaciones, pero: ¿sabrías determinar las implicaciones en el uso del persistence context, y por tanto en el rendimiento, de operaciones realizadas en una misma transacción?
También es muy probable que hayas usado transacciones aisladas en un mismo caso de uso, pero ¿Sabrías decir que sucede cuando una misma entidad se modifica en las dos transacciones?
¿Conoces siempre por que motivo se actualizan, o no se actualizan, en base de datos entidades que has modificado en la aplicación? ¿Sabrías reconocer para cada situación cuando se ejecutar un flush y cuando no?
Como ves, la dinámica en el curso es constante: analizar un aspecto básico (entity manager, persistence context, transacción) y exprimirlo al máximo para entenderlo desde su fundamento.
No son en absoluto casos sencillos. Representamos situaciones reales donde programadores expertos comenten errores con graves implicaciones (bajo rendimiento o incluso dejar la aplicación sin conexiones a base de datos!).
Para hacerlo más interesante, el curso está construido en forma de desafío constante para el alumno. Te recomiendo no verlo sin más, un video detrás de otro. Los videos plantean las preguntas que después se irán resolviendo. Detén los vídeos en los momentos donde se realizan las preguntas y acepta el desafío: ¿Cual crees que será la respuesta? ¿Que te indica la experiencia previa que tienes? ¿Crees que podrías resolverlo por tu mismo antes de seguir con el video?
Como hemos dicho, los temas tratados en el curso son los fundamentales a JPA. Esto permite hacer el curso accesible a alumnos con distintos bagajes en la tecnología: cada uno de ellos obtendrá un beneficio diferente según su nivel:
Si estás realizando un curso introductorio puedes usar este curso como complemento. ¿Te interesa ver como se usa a nivel avanzado los conceptos que estás aprendiendo? Quizás no lo entiendas, al menos en una primera visualización, en un 100%, pero tendrás una visión más completa de lo que estás aprendiendo.
Si ya lleva usando un tiempo la tecnología, estoy seguro que te sentirás identificado en muchos de los problemas que se tratan. ¡Este es tu curso para salvarte de horas de frustración intentando resolver los casos que se muestran!
¿Eres ya experto en el tema? ¡Acepta pues el desafío! Mira como resolverías los problemas planteados y cuestiona lo que has hecho hasta ahora.
Por último, y especialmente dedicados a vosotros, los que pensáis ir a entrevistas de trabajo relacionadas con JPA. Si trabajáis bien el curso, seréis capaces de demostrar un nivel de conocimiento de la tecnología fuera de lo común.