Saltar navegación

20260115 JPA_2 - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 19 de enero de 2026 por Raquel G.

5 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale 00:00:00
Pues nuestro modelo 00:00:01
Ya lo empezamos a hacer el otro día 00:00:04
Empleado 00:00:05
Venga 00:00:07
Empleado tendrá 00:00:08
Su clave primaria ID, su nombre 00:00:11
Y luego 00:00:14
Por tener una clave ajena que nos lleva 00:00:15
A departamento 00:00:18
Entonces el empleado que tiene dentro 00:00:19
Tiene un objeto departamento 00:00:21
Vale, y esto es algo natural 00:00:23
No tenemos que 00:00:26
esto no es de JPA 00:00:27
sería el modelo natural 00:00:30
vale, los getter y los setter 00:00:32
y no hicimos nada más 00:00:35
bueno, entonces 00:00:36
ahora 00:00:39
lo que necesitamos es hacer el mapeo 00:00:41
para que la herramienta 00:00:44
hibernate que vamos a poner por debajo 00:00:46
implementando JPA sea capaz 00:00:48
ella sola de hacer automáticamente 00:00:50
el traslado y cuando yo haga un get 00:00:52
de empleado, ella solita 00:00:54
rellene todo, rellene 00:00:56
el ID, el nombre, el departamento 00:00:58
por ejemplo, ¿vale? Entonces tenemos que hacer 00:01:00
un mapeo, configurar 00:01:02
tenemos que configurar un mapeo para que nuestra 00:01:04
herramienta JPA con 00:01:06
hibernate a respuestas 00:01:08
de una sentencia simple, ¡puf! 00:01:10
construya toda la estructura 00:01:12
desde la base de datos 00:01:14
olvidándome yo de SELE, de 00:01:15
SQL y de leches, bueno 00:01:18
entonces vamos a mencionar 4, 5, 6 las 00:01:19
anotaciones básicas de JPA 00:01:22
que hay poco más que saber para poder 00:01:24
hacer cualquier mapeo en realidad 00:01:26
la básica 00:01:27
entity, ¿vale? la anotación 00:01:30
entity es la básica que define 00:01:32
que esto es una entidad 00:01:34
JPA 00:01:36
una entidad que va a gestionar 00:01:37
mi herramienta 00:01:40
de persistencia 00:01:42
mi contexto de persistencia 00:01:43
¿vale? porque todo esto lo mencionamos el otro 00:01:45
día, estas herramientas 00:01:49
cuando las usamos 00:01:51
instanciamos un contexto de persistencia 00:01:53
Ese contexto de persistencia 00:01:56
Incluirá los objetos que queramos que sean persistentes 00:01:59
Que no tienen por qué ser todos los de mi aplicación 00:02:03
Habrá objetos que irán por libre 00:02:06
Que están desconectados de la base de datos 00:02:07
Y objetos persistentes que sí que queremos 00:02:09
Que estén conectados con la base de datos 00:02:12
¿Vale? Pues esto es una clase 00:02:14
De la cual instanciaremos objetos 00:02:18
Que querremos meter en ese contexto de persistencia 00:02:20
Para que la herramienta los gestione, los sincronice, etc. 00:02:22
Pues entonces hay anotación entity 00:02:25
Que es la 00:02:27
La básica, ¿vale? 00:02:28
Eso es para la persistent 00:02:31
Para que JPA 00:02:32
Entienda que esto es una entidad 00:02:35
Que tiene que poder 00:02:37
Gestionar y mapear con la base de datos 00:02:39
Vale, entonces entity es una 00:02:42
Anotación que se importa de 00:02:43
La API JPA, que la API JPA 00:02:45
Pues está en Jakarta, persistence 00:02:48
Si estuviéramos en la versión 00:02:49
De hace un tiempecito 00:02:52
en lugar de Jakarta Persistence estaría 00:02:53
JavaX Persistence 00:02:55
porque a veces los import en función de si has 00:02:57
actualizado la máquina o no, te ofrecen uno u otro 00:02:59
pero 00:03:01
asumid en vuestra cabeza como ya asuméis 00:03:03
JavaX y Jakarta es como si fuera 00:03:05
lo mismo, Jakarta es la 00:03:07
versión que la sustituye, pero esencialmente 00:03:09
es lo mismo 00:03:11
vale, entonces 00:03:12
al poner entity ya 00:03:14
JPA asume 00:03:17
que esto se va a corresponder con una tabla 00:03:18
que se llama empleado 00:03:21
las mayúsculas como si no existieran 00:03:23
porque en SQL no las distingue 00:03:25
mírame 00:03:28
pues las que pusimos el otro día 00:03:28
y el proyecto está subido 00:03:34
un segundín Dani, espérate, están aquí 00:03:35
es el conector de Java 00:03:38
va a ser imprescindible 00:03:46
y la de Hibernate 00:03:47
¿vale? 00:03:49
es decir, el conector 00:03:52
porque todo esto está apoyado sobre 00:03:54
JDBC, recordad, esto 00:03:56
no sustituye a JDBC 00:03:58
esto es una capa por encima 00:03:59
que usa por debajo JDBC 00:04:01
no lo sustituye porque JDBC es imprescindible 00:04:03
entonces el driver 00:04:06
hace falta 00:04:08
y luego la dependencia esta 00:04:08
nos hace falta pues porque es la implementación 00:04:12
de JPA 00:04:14
entonces si no es igual 00:04:15
Pues tú haces una anotación 00:04:28
Para indicar el nombre 00:04:30
Que es la anotación 00:04:31
¿Por qué no me escribe esto? 00:04:32
Ah, table 00:04:36
¿Vale? 00:04:38
Table que tiene 00:04:47
Por ejemplo, pues eso 00:04:48
Imagínate que se llama empleados 00:04:51
Claro, si no se llama así 00:04:53
Esto asociad a que es muy parecida a la idea de Jaxbe 00:04:58
Lo que pasa es que son otras anotaciones 00:05:02
Y en lugar de mapear con un XML 00:05:04
Mapea con una tabla 00:05:05
¿Vale? Esta es opcional solo si cambia el nombre 00:05:07
Entonces, en mi caso en particular 00:05:10
La tabla se llama empleado 00:05:14
Entonces la voy a dejar así para que funcione 00:05:16
Aunque podría quitarla porque es el mismo nombre 00:05:19
Entonces 00:05:23
Si yo ya no anoto nada más 00:05:29
No anoto nada más 00:05:36
Pues JPA asume que hay una tabla que se llama empleados 00:05:37
con campos exactamente 00:05:41
con este nombre 00:05:43
sin ninguna característica 00:05:44
me deja también 00:05:47
importar una vez que 00:05:54
ya, pero no, no, no 00:05:56
bueno, es que no tenga nada que ver 00:05:59
eso es al margen de JPA 00:06:01
trabajar, que lo puedes trabajar 00:06:03
nosotros estamos en 00:06:05
usando la API JPA 00:06:07
que es la que tenemos que usar, es la que usa 00:06:09
Spring cuando se mueve la capa por encima 00:06:11
Claro, pero es que Hibernate 00:06:13
tiene dos usos 00:06:17
el uso a través de JPA 00:06:18
o el uso directo 00:06:21
y el estándar es el uso 00:06:23
a través de JPA 00:06:25
y de hecho Spring 00:06:26
es otra capa sobre JPA 00:06:29
que a su vez JPA va sobre Hibernate 00:06:31
Hibernate sobre JDBC 00:06:33
y hay capas hasta el infinito 00:06:34
Vale, entonces 00:06:36
si no se pone nada más 00:06:39
JPA 00:06:40
asumiría 00:06:43
que hay una tabla con campos 00:06:45
con estos nombres y ya está 00:06:47
lo que pasa es que bueno, este es problemático 00:06:49
ahora lo ponemos con él 00:06:51
porque en cuanto hay nombre no hay problema 00:06:53
asumiría que hay un campo de tipo 00:06:55
entero 00:06:57
y aquí uno de tipo bar chart 00:06:58
y ya está, y que se llaman así 00:07:01
si no se llaman así 00:07:03
los podemos anotar 00:07:05
¿Vale? Con column 00:07:08
¿Vale? Por ejemplo 00:07:11
Nombre 00:07:13
Resulta que no se llama así 00:07:14
Pues lo podemos anotar 00:07:16
Con 00:07:18
Column ¿Vale? 00:07:20
En el otro también se podría 00:07:26
¿Vale? 00:07:28
Pero bueno 00:07:29
Si alguna cosa no nos funciona 00:07:33
Nos vamos a tiro fijo y la cambiamos 00:07:34
Porque yo no me lo recuerdo todo de memoria 00:07:36
Tengo 00:07:38
Tendría 00:07:39
Tengo la chuletilla por ahí, en algún momento tendré que abrirla 00:07:42
Pero hay muchas cosas de la que no me acuerdo 00:07:44
A ver, pues yo que sé, imaginaos pues eso que se llama así 00:07:45
Pues ya está 00:07:48
Ah, ya está 00:07:50
Decía que es raro que no me la permita importar 00:07:58
Vale, en mi caso, pues bueno 00:08:00
Como se llama nombre, ¿verdad? 00:08:02
Pues la llamo nombre y ya está 00:08:05
Vale 00:08:06
Aquí lo que pasa es que necesitamos 00:08:09
Más cosas 00:08:12
Primero, el ID 00:08:13
el ID 00:08:15
es autoincrement, es generado 00:08:16
por la base de datos 00:08:20
entonces eso hay que decírselo a JPA 00:08:21
porque cuando nosotros 00:08:24
JPA 00:08:25
tiene que saber que este 00:08:28
no tiene que pasarlo 00:08:29
cuando haga un insert 00:08:31
no tiene que pasarlo porque la base de datos lo va 00:08:33
a generar, entonces 00:08:35
hay que avisarle a JPA, hay que caracterizar 00:08:37
a JPA, hay que caracterizarle 00:08:40
todo lo mejor posible 00:08:41
Vale, pues id es una clave primaria 00:08:43
Entonces id 00:08:46
Para decir que es una clave primaria 00:08:47
Pues se anota con id 00:08:49
Entonces esto solamente 00:08:55
Implica que es clave primaria 00:08:58
Lo cual a jpa le viene muy bien 00:09:00
Para detectar ya desde el mundo 00:09:03
De los objetos si hay inconsistencias 00:09:05
Porque hay dos objetos con la misma clave 00:09:08
No te va a permitir 00:09:09
bueno, pues entonces, si además 00:09:10
queremos decirle, oye 00:09:15
que esta clave primaria es autoincrement 00:09:17
pues le tenemos que poner 00:09:18
el atributo correspondiente 00:09:20
que este es el que nunca me acuerdo 00:09:22
pero aquí lo tengo que 00:09:24
por ejemplo aquí seguro que está 00:09:25
claro, por ejemplo 00:09:28
aquí seguro 00:09:31
que hay uno 00:09:39
vale 00:09:40
esto 00:09:46
es lo que ponemos 00:09:48
para indicar 00:09:55
que es 00:09:59
una clave primaria 00:10:02
autogenerada 00:10:05
¿vale? 00:10:07
esta anotación de aquí 00:10:09
para poner que es una clave primaria autogenerada 00:10:10
da igual 00:10:12
si, si, si, da lo mismo 00:10:28
a mi me gusta 00:10:30
más ponerlo en los métodos 00:10:32
Pero esos sí que son manías 00:10:34
¿Vale? 00:10:36
Para indicarle a JPA 00:10:38
Que esta clave se autogenera 00:10:41
En la base de datos 00:10:43
No se asigna desde aquí 00:10:45
No se asigna desde aquí 00:10:47
¿Hay alguien que se identifique? 00:10:49
¿Auto? 00:10:50
¿Auto no suena más a... 00:10:51
No sé decirte 00:10:54
La que se pone es esta 00:10:58
No sé decirte 00:11:00
Vale, que suba, si son Getty Set 00:11:02
Ah, los de Yakarta 00:11:04
A los que él te ofrezca de Yacarta 00:11:06
Pero tú has cambiado 00:11:07
Tu proyecto 00:11:12
A ver, le has cambiado el nivel 00:11:14
De la máquina virtual y de compilación 00:11:18
Pues no sé 00:11:19
Si has puesto la dependencia correcta 00:11:24
No estás en un nivel 00:11:27
De compilación 00:11:30
Del año Gatapun 00:11:33
Debería ofrecerte 00:11:34
Vale 00:11:36
entonces con esto 00:11:39
estos dos campos están completamente 00:11:42
caracterizados, no hay que caracterizar 00:11:44
ya nada más, pero claro 00:11:45
tenemos un campo raro 00:11:47
este campo de aquí es raro 00:11:49
porque este 00:11:53
campo de aquí en realidad 00:11:55
nosotros hemos puesto que es una propiedad 00:11:57
de tipo objeto departamento 00:11:59
pero en la tabla 00:12:01
en la tabla lógicamente no es un objeto 00:12:02
en la tabla es 00:12:05
un entero 00:12:07
en la tabla es un entero 00:12:09
entonces ahí sí que hay un mapeo raro 00:12:12
es un entero 00:12:14
y sin embargo en el objeto 00:12:16
empleado es un objeto 00:12:17
enterito de departamento 00:12:20
claro, eso es así, porque esto es una clave ajena 00:12:21
lógicamente, entonces hay que decírselo 00:12:24
a JPA 00:12:26
hay que decírselo a JPA y hay que decirle 00:12:27
oye, tú 00:12:30
si lo veis todo más claro 00:12:30
porque está todo al principio en las propiedades 00:12:34
pues ponerlo en las propiedades 00:12:36
entonces 00:12:37
aquí en getDepartamento 00:12:39
le diríamos 00:12:42
oye tú, para construir este objeto 00:12:45
departamento, para construirlo 00:12:47
que sepas que esto 00:12:49
viene de una clave que es 00:12:51
muchos a uno 00:12:54
recordad que estamos en empleado 00:12:56
esto ya era en la clase empleado 00:12:58
entonces, desde el empleado 00:13:01
las relaciones de muchos 00:13:03
a uno, ¿verdad? muchos empleados 00:13:05
Un departamento 00:13:07
Entonces desde aquí, desde empleado 00:13:08
Esto viene porque es una relación 00:13:10
De muchos empleados, un departamento 00:13:12
Y le tengo que avisar a JPA 00:13:14
De esta manera 00:13:17
Cuidado que esto viene 00:13:18
Porque hay aquí una clave ajena 00:13:20
¿Vale? 00:13:22
Entonces JPA cuando recupera este objeto 00:13:26
Dice, ah ojo 00:13:28
Espérate, que para recuperarlo 00:13:30
Tengo que seguir la clave 00:13:32
E irme hasta la otra tabla 00:13:34
Entonces se le hace el select correspondiente 00:13:35
Y se va hasta la otra tabla 00:13:37
Pero claro, de la clave ajena hay que configurar más 00:13:38
Hay que configurar por lo menos 00:13:42
Oye, ¿cuál es el campo del que tienes que tirar? 00:13:44
Que no lo hemos puesto 00:13:45
Entonces, esto 00:13:46
Aquí 00:13:49
A ver que lo ponga bien 00:13:55
Vale 00:13:59
Claro 00:14:10
Entonces hay que decirle 00:14:23
El campo del que tirar 00:14:29
Para construir el objeto departamento 00:14:30
Entonces el campo del que tirar 00:14:32
Es id barra baja departamento 00:14:35
En mi caso 00:14:37
Y en el vuestro si habéis 00:14:38
Hecho la misma base de datos 00:14:39
Vale 00:14:41
Pero aquí hay muchas más cosas que se pueden configurar 00:14:42
Se podría dejar así 00:14:54
Y listo 00:14:55
Y ya esta entidad está bien configurada 00:14:56
¿Vale? 00:15:00
Pero hay más cosas que se pueden configurar aquí 00:15:02
Que si no lo hacemos 00:15:04
Cogen los valores por defecto 00:15:05
Y una de ellas es especialmente interesante. 00:15:07
Bueno, varias. 00:15:12
Hay una, por ejemplo, que es updatable. 00:15:13
Aunque esta quizás es la menos interesante. 00:15:20
A ver, un momento que... 00:15:27
Así, ¿vale? 00:15:31
Entonces, esta es un poco una tontería. 00:15:36
Y es, me especifica, si una vez creado el objeto empleado, 00:15:38
ya tengo yo mi objeto persistente 00:15:44
empleado, entonces recordad 00:15:46
que en realidad vamos a estar siempre trabajando en los 00:15:48
objetos, luego ya los diferentes 00:15:50
commits y las diferentes cosas 00:15:52
que hace hibernate van a ser las que 00:15:54
hagan que eso se refleje en la base de datos 00:15:56
pero para nosotros nuestro problema 00:15:58
va a estar en los objetos 00:16:00
bueno pues aquí el tema es cuando tenga yo un objeto 00:16:01
empleado persistente que lo cree por primera 00:16:04
vez, ya veremos como lo puedo crear o hacerlo 00:16:06
aparecer, si su 00:16:08
objeto departamento que 00:16:10
tiene colgando ahí un departamento, el que tiene colgando 00:16:12
lo voy a poder modificar o no 00:16:14
si lo voy a 00:16:16
si lo pongo a true, lo voy a poder 00:16:18
modificar y si no, no lo voy a poder modificar 00:16:20
ese empleado va a tener su departamento 00:16:22
no me va a dejar modificar esta propiedad 00:16:24
bueno, eso significa loop datable este 00:16:26
vale, pero sobre todo nos interesa 00:16:28
el momento 00:16:30
de carga del objeto, el momento 00:16:32
de carga del objeto 00:16:34
a ver donde puedo tener esto, aquí 00:16:35
el momento de carga 00:16:38
este 00:16:45
A ver, es que aquí nunca tengo muy claro 00:16:46
Si se puede poner en cualquiera de los dos lados 00:17:17
O no, pero en cualquier caso 00:17:22
Lo ponga donde lo ponga, me debería dejar 00:17:24
Importarlo 00:17:26
A ver 00:17:27
Espérate, es que no siento empleado 00:17:28
Estoy, a ver, que me estoy liando 00:17:41
Un momentito, voy a cerrarlo todo 00:17:43
ya no sé en qué clase empleado estoy a ver nuestro proyecto es este este empleados clase 00:17:45
vale vale a ver a ver es que no estaba yo no tenía que estar 00:17:53
y ahora control uve 00:18:05
si es que estoy probando a ver si me deja poner si me deja poderlo aquí 00:18:11
Ah, vale, por eso no me deja 00:18:14
Vale, es que quería probar 00:18:20
Porque tenía mis dudas 00:18:22
Sobre si por curiosidad 00:18:24
En el otro lado te dejaba 00:18:25
Pero no 00:18:27
No te deja ponerlo ahí 00:18:28
¡Hala! 00:18:32
Vale, pues entonces 00:18:35
Esto sí que es importante 00:18:36
Y esto además aparece en todo tipo de relaciones 00:18:38
Ahora lo veremos 00:18:40
Esto es en qué momento 00:18:41
carga el objeto departamento. 00:18:44
Es decir, yo recupero de la base de datos 00:18:47
un empleado 00:18:49
y ya desde el momento en que lo recupero 00:18:49
ya veremos cómo tengo ahí mi objeto persistente 00:18:52
dentro del contexto de persistencia 00:18:54
para hacer con él lo que quiera. 00:18:56
Y cualquier cosa que haga en ese objeto 00:18:58
pues en algún momento 00:18:59
Ibernate lo sincronizará con la base de datos. 00:19:01
Ya veremos en qué momento es eso. 00:19:04
Bueno, pero claro, 00:19:06
mi objeto empleado 00:19:08
en realidad tiene mucho dentro 00:19:10
porque tiene sus datos, ID y nombre 00:19:12
y tiene el objeto departamento entero 00:19:17
en este caso el objeto departamento no es tan grande 00:19:19
pero podría ser un objeto enorme 00:19:21
entonces, el lazy este significa 00:19:23
el lazy significa 00:19:27
oye tú, cuando tú me cargues el objeto empleado 00:19:30
tú, JPA y Bernate, cuando me lo cargues 00:19:35
no me rellenes el objeto departamento 00:19:38
haz el vago 00:19:41
y no me rellenes el objeto de departamento 00:19:42
rellénamelo 00:19:45
solo si yo te lo pido 00:19:47
solo si yo te lo pido 00:19:49
¿vale? si yo te lo pido, en ese caso 00:19:50
tú me haces el sellet ahí rápido, sin que yo me entere 00:19:53
y me lo 00:19:55
rellenas, entonces eso 00:19:56
optimiza memoria, porque solamente 00:19:59
va a cargar 00:20:01
lo que tiene colgando por dentro 00:20:03
si yo se lo pido 00:20:05
si no se lo pido, él carga 00:20:07
el empleado sin más 00:20:08
Forzar la carga 00:20:09
Forzarla 00:20:14
Desde el principio sería esta opción 00:20:15
Son las dos 00:20:19
Con esta, si yo cargo el objeto empleado 00:20:20
Se carga todo 00:20:23
Esto sería una forma de forzar la carga 00:20:23
Por defecto 00:20:26
No sé cuál de las dos tiene 00:20:28
Porque hay varios extremos 00:20:30
Luego lo miramos cuando tengamos todos los extremos 00:20:32
De todas las relaciones puestas 00:20:34
Cuando lo veamos 00:20:36
Por defecto no sé cuál de las dos pone 00:20:37
Pero hombre, siempre es más recomendable 00:20:40
Pero hay un matiz 00:20:42
Hay un matiz importante 00:20:45
Para que no nos salga 00:20:47
Una excepción de vagos 00:20:49
La excepción de vagos 00:20:52
Que nos puede salir 00:20:54
Antes de seguir vamos a hacer un mail rápido 00:20:55
Cuidado que no nos salga la excepción de vagos 00:20:57
Que sale mucho si no hemos gestionado bien 00:21:07
Todo el tema de las transacciones 00:21:09
De los servicios, de todo eso 00:21:11
La ley sin inicialización 00:21:13
Esta excepción 00:21:15
A ver, tú coges el empleado y haces cosas con el empleado y luego te apetece el departamento, pues accedes al departamento. 00:21:16
Entonces Ibernate, ostras, que me está diciendo que es departamento, pues sin decirte nada se va corriendo a hacer el select en ese momento, se va corriendo a hacerlo. 00:21:26
Pero claro, tiene que estar la sesión todavía abierta. 00:21:33
Si no está abierta, él ya no puede hacer el select. 00:21:38
entonces en función de como hayamos gestionado 00:21:40
las transacciones y las sesiones 00:21:43
pues si no lo hemos 00:21:45
planificado bien 00:21:46
yo tengo mi objeto empleado 00:21:48
me hago el get departamento 00:21:51
y Bernate va corriendo, corriendo 00:21:52
a escondidas a hacerme el select 00:21:55
para rellenármelo 00:21:56
y resulta que no puede porque está cerrada 00:21:58
la sesión 00:22:00
entonces nos sale esta excepción 00:22:01
luego cuidado porque esto sale 00:22:04
más de lo que parece cuando tenemos ya un diseño 00:22:07
con un montón de clases y de cosas 00:22:09
incluso cuando lo tenemos con Spring 00:22:11
sale a menudo, pero hay que tener mucho cuidado 00:22:12
los métodos de los servicios, los que 00:22:15
están metidos en transacciones, los que no 00:22:17
para que no nos salga esto 00:22:19
pero esto va a ser más fácil 00:22:21
si lo vamos 00:22:23
a la vez que vamos poniendo anotaciones, vamos viendo 00:22:25
ejemplos en un main limpio 00:22:27
todavía sin arquitectura, sin DAO 00:22:29
sin servicio y sin nada, para ver cómo funciona 00:22:31
vamos a hacernos un main patatero 00:22:33
asqueroso como si estuviéramos en primero 00:22:35
guarro cochino 00:22:37
y luego ya metemos un patrón 00:22:38
con DAO y con cosas 00:22:40
venga, vamos a hacernos un 00:22:42
main por aquí 00:22:50
vale, esto es solo para ver cómo funcionan las anotaciones 00:22:51
ya sé que es un diseño horroroso 00:23:00
pero vamos a meter todo aquí en el main 00:23:02
es muy feo todo aquí en el main 00:23:04
a mogollón, pero bueno, para ver cómo funcionan las anotaciones 00:23:06
vale, pues a ver 00:23:08
ahora queremos hacer cosas con este objeto empleado 00:23:09
insertar un empleado en la base de datos 00:23:12
recuperarlo, mirar su departamento 00:23:14
hacer cosas en general, queremos hacer cosas 00:23:16
Pues necesitamos un contexto de persistencia. 00:23:18
El contexto de persistencia en JPA es el Entity Manager. 00:23:23
¿Vale? 00:23:29
El Entity Manager. 00:23:29
Y el Entity Manager, ¿quién lo crea? 00:23:31
Lo crea un Factory. 00:23:35
¿Vale? 00:23:36
Lo crea un Factory que lo voy a copiar por aquí. 00:23:37
Tendré en algún... 00:23:40
Esto. 00:23:43
Vale. 00:23:44
A ver. 00:23:56
Vale, hay un Factory. 00:24:04
EntityManagerFactory 00:24:05
¿Vale? 00:24:07
Y ahora 00:24:14
Un segundinín que completo esta línea 00:24:15
Factory, create entity manager 00:24:17
Ahora miramos eso 00:24:19
Vale, ahora 00:24:21
Lo que va ahí entre paréntesis 00:24:25
Es string, ahora lo entramos con él 00:24:27
¡Hala! 00:24:30
Aquí ya tenemos 00:24:32
Un contexto de persistencia 00:24:33
¿Vale? 00:24:35
Si no usamos sprint 00:24:38
Que lo crea él 00:24:40
automáticamente y decide cuando 00:24:43
lo cierra y cuando lo abre según las 00:24:45
anotaciones que pongamos nosotros en transacciones 00:24:47
patatín, si no usamos 00:24:49
Spring, tenemos que gestionar 00:24:51
nosotros cuando abrir y cerrar este contexto 00:24:52
de persistencia, ¿vale? Entonces 00:24:55
este contexto de persistencia 00:24:56
cuando está abierto, ahora ya 00:24:58
a partir de aquí, me permite 00:25:03
crear objetos persistentes 00:25:05
sincronizados con la base de datos 00:25:07
a partir de aquí, ¿vale? 00:25:08
Lo que pasa es que, claro, diré, hombre, el contexto 00:25:11
de persistencia tiene que estar asociado 00:25:13
dime 00:25:15
si, es un string que ahora mismo 00:25:15
no pone nada interesante pero lo vamos a tener que poner a mano 00:25:19
vamos a ponerlo ahora 00:25:21
ahora completamos eso, entonces 00:25:22
este contexto de persistencia 00:25:28
tiene que conocer 00:25:30
tiene que saber cuál es la base de datos 00:25:33
a la que se va a conectar 00:25:34
y muchas, la url, todo eso 00:25:36
vale 00:25:39
que no lo hemos configurado en ningún momento 00:25:40
no lo hemos configurado, pues eso se configura en un archivo 00:25:42
en un archivo que se llama 00:25:45
Persistence 00:25:46
Entonces, ese archivo Persistence 00:25:48
Tiene que estar ubicado en el 00:25:50
Path, etc, etc, pues en los proyectos 00:25:52
Maven, ese archivo 00:25:55
Persistence está 00:25:56
Dentro de resources 00:25:58
En una carpeta que se llama MetaIn 00:26:00
Ahora lo abro y si vemos que es 00:26:02
Muy largo, lo subimos rápidamente a la hora virtual 00:26:05
Vale, a ver 00:26:06
Pues crea carpeta 00:26:09
Si, cread dentro de ese RCM 00:26:13
En resources, una carpeta 00:26:15
Meta-inf 00:26:17
¿Veis? Esta carpeta 00:26:19
Dentro de 00:26:27
¿Dónde estoy yo? Ah, no, estoy aquí 00:26:29
Vale 00:26:32
Ah, que la he pegado en otro 00:26:32
Ahí, no sé dónde la había pegado 00:26:40
Pero bueno, vale 00:26:44
Dentro de 00:26:45
SRC Main Resources, la carpeta 00:26:50
Metainf, y aquí 00:26:52
Tiene que estar 00:26:54
este archivo, ahora lo subo para que lo descarguéis 00:26:56
tiene que estar este archivo 00:26:58
que configura 00:27:00
el acceso a la base de datos 00:27:02
es un archivo de configuración 00:27:04
sí, sí, sí 00:27:08
entonces el archivo 00:27:08
este de aquí 00:27:11
pues tiene los datos 00:27:13
que va a necesitar el jdbc que está por debajo 00:27:15
vale 00:27:18
es siempre el mismo 00:27:19
siempre el mismo 00:27:24
Entonces, este de aquí, pues aquí configuras los datos que necesita JDBC 00:27:25
Las entidades que va a manejar este contexto de persistencia 00:27:32
Y aquí unas cositas que ahora explicamos un poco por encima 00:27:39
Pero voy a subir este a la hora virtual rápidamente 00:27:44
Sí, como un base de datos properties, como un properties de conexión 00:27:48
Sí, pero configura más cosas 00:27:56
Vale, lo subo arriba del todo 00:27:57
Lo más alto que me deje el aula virtual 00:28:13
Vale, esto, esto 00:28:15
Es que va a ser más fácil sacarlo 00:28:41
Espera, voy a pausar esto mientras 00:28:50
Se llama 00:28:59
Empleados barra baja 00:29:04
Departamentos 00:29:06
Vale 00:29:08
entonces 00:29:10
ahora, este nombrecito de aquí 00:29:11
este nombrecito 00:29:15
de aquí es el que 00:29:17
da nombre al contexto de persistencia 00:29:19
a la unidad de persistencia 00:29:21
como lo llama él 00:29:23
y este nombrecito de ahí 00:29:24
es el que tiene que aparecer aquí luego 00:29:26
aquí en nuestro main 00:29:28
ahí 00:29:33
entonces, vamos a llamarlo 00:29:36
el contexto de persistencia, pues como lo queréis llamar 00:29:39
de nuestra base de dados, empleados departamentos Persistence Unit. 00:29:41
Entonces, le damos un nombre a esa unidad de persistencia, 00:29:51
porque podría haber varios en realidad. 00:29:54
Complicaría mucho la cosa. 00:29:57
Pues, el nombre que le dais a esa unidad de persistencia es el que se pone aquí. 00:29:59
Entonces, cuando arranquemos ese contexto de persistencia, 00:30:07
se va a arrancar con 00:30:11
la configuración que haya en el 00:30:13
Persistence XML que se llame 00:30:15
así, en el que 00:30:17
se llame así, vale 00:30:19
vale, entonces 00:30:20
aquí las entidades que va a 00:30:28
gestionar, departamento y 00:30:31
empleado, entonces departamento 00:30:33
aunque nos falta por hacerle 00:30:35
cosas, vamos a ponerle que es entidad 00:30:37
para que no se vuelva loco el main 00:30:39
vamos a ponerle, ah, que ya la tiene 00:30:40
entity, ya la tiene 00:30:43
yo no entendía muy bien lo de entity 00:30:44
Entity, pues que es una tabla, ya está 00:30:47
A ver, porque 00:30:50
Os daba error, entonces os dije 00:30:58
Pues quitarlo, vamos a ver 00:31:00
Esos son parámetros 00:31:02
Estos son los parámetros 00:31:03
Que va a usar JDBC cuando lo llame 00:31:06
Hibernate 00:31:08
Entonces, esto es lo que hará 00:31:10
En su GetConnection 00:31:12
Pues esos parámetros no los hemos estado usando 00:31:13
porque no los 00:31:16
hemos necesitado. Entonces, si os dan 00:31:18
error, los quitáis y listo. 00:31:20
Que luego cuando hagamos 00:31:22
el main nos dicen, ¿necesitas configurar? 00:31:24
JBBC se ha quedado sin timezone. 00:31:26
Pues le ponemos, se lo ponemos, pero mientras no lo pida 00:31:28
hasta ahora no nos lo han pedido. 00:31:30
Bueno, ahora 00:31:32
luego hay cosas que se 00:31:34
pueden configurar y 00:31:36
de ellas, bueno, el dialecto 00:31:38
siempre lo ponemos claro que es 00:31:40
MySQL, vale, claro. 00:31:42
Y ahora 00:31:45
Esta de aquí, esta es crítica, es de hibernate a librería de datos. Aquí cuidado, porque hay varias posibilidades, que puede ser create, update, validate, entonces, si nosotros no tenemos las tablas hechas, no las tenemos hechas, en la base de datos empleados departamentos, no están hechas, y arrancamos nuestro contexto de persistencia, 00:31:45
y aquí en este hay un create 00:32:13
pues lo que va a hacer 00:32:15
él es crear las tablas 00:32:18
automáticamente 00:32:20
crearlas con la misma estructura 00:32:21
de nuestros objetos 00:32:24
entonces eso es muy cómodo cuando estamos 00:32:25
haciendo pruebas 00:32:28
porque hacemos nuestras clases 00:32:29
como nos interese, hacemos la aplicación 00:32:32
y la base de datos se crea 00:32:34
exactamente tal y como la necesitamos 00:32:36
pero en un entorno de producción jamás 00:32:37
trabajaríamos así porque la base de datos nos viene 00:32:40
hecha y la usa mucha gente 00:32:41
¿Vale? Si ponemos validar 00:32:43
Pues él nos va a validar si 00:32:46
Se corresponden nuestras anotaciones 00:32:48
Con la base de datos y si no nos va a avisar 00:32:50
Si ponemos 00:32:53
Subdate, no nos lo crea 00:32:54
Pero si ve que alguna tabla 00:32:56
No se corresponde con las anotaciones, te cambia 00:32:58
La tabla, entonces eso es peligroso 00:33:00
Útil si estamos haciendo pruebas nosotros 00:33:02
Pero peligroso en un contexto 00:33:04
En el que no queremos que se cambien las tablas de los demás 00:33:06
¿Vale? Pues eso es lo que 00:33:08
Para que sepáis lo que significa eso 00:33:10
Y esto es simplemente para mostrar un log de los SQL que él hace, que nos es muy útil que esté a true, porque así cada vez cuando hagamos el main nos hace en consola un seguimiento de los SQL que él está haciendo por debajo, de los que está haciendo por debajo. 00:33:11
Bueno, pues ahora ya con nuestro 00:33:28
Persistence este de aquí 00:33:31
Dime 00:33:32
Si, es que 00:33:34
¿En qué paquete estoy? 00:33:40
Porque claro, vamos a 00:33:42
Estoy en com.dam2.model 00:33:43
Es el paquete 00:33:45
Y aquí como lo he llamado 00:33:46
Com.dam2 00:33:47
¿Vale? 00:33:49
Esto que no está bien puesto 00:33:57
Vale 00:33:58
Yo creo que ahora estaría ya bien adaptado 00:34:02
A todo lo nuestro 00:34:04
Y nuestro main entonces 00:34:06
Lo abriría así 00:34:07
vamos simplemente, y ahora paramos 00:34:08
un par de minutos 00:34:13
a ver si este main nos funciona 00:34:14
o sea, vamos a darle al close 00:34:17
o sea, no vamos a hacer 00:34:18
nada, pero al menos a ver si la creación 00:34:21
del contexto y el jdbc 00:34:23
por debajo está bien, porque ya solo con esto 00:34:25
nos pueden faltar dependencias, podemos haber 00:34:27
hecho algo mal en el persistence 00:34:29
entonces vamos a arrancar este main 00:34:30
y si no nos da errores, es que está 00:34:33
todo bien configurado 00:34:35
bueno, a ver 00:34:36
es que como departamento le faltan 00:34:41
anotaciones 00:34:43
entonces voy a quitarle departamento 00:34:43
claro, es que 00:34:47
vamos a esperar a tener departamento 00:34:50
porque si no vamos a hacer arreglos parches 00:34:53
vamos a esperar a tener departamento bien configurada 00:34:55
y luego ya lo probamos, vale 00:34:57
vamos a parar un par de minutos 00:34:58
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Segundo Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
5
Fecha:
19 de enero de 2026 - 12:01
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
35′ 02″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
156.63 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid