Saltar navegación

20260115 JPA_3 - 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.

6 visualizaciones

Más información Transcripción

Descargar la transcripción

Porque tenía un día de libre disposición 00:00:00
de los dos que tenemos al año 00:00:08
y dispuse no venir. 00:00:09
Y me perdí ese día de vacaciones 00:00:15
de libre disposición para estar todo el día 00:00:17
con un fontanero en casa. 00:00:19
¿Lo has visto? ¡Qué divertido! 00:00:20
Tú lo hacía un niño 00:00:24
y nosotros decíamos que también lo hemos visto. 00:00:26
Pues lo podía haber pensado, sí. 00:00:30
Vale, a ver. 00:00:32
Vamos a terminar con departamento. 00:00:35
Venga, pues es una entidad, está claro. 00:00:38
Las propiedades. 00:00:44
Las anotamos o todas aquí o todas en los getters. 00:00:46
Lo que no hacemos es mezclar, como en JaxB. 00:00:50
Si nos gusta más ahí, porque se ve mejor ahí. 00:00:52
Y yo, como ya he empezado con el get, 00:00:55
ya me da ahora ansiedad 00:00:57
por una clase una y otra otra 00:00:58
vale, el ID 00:01:00
era también autoincremento en departamento 00:01:01
así que vamos a copiar esto mismo 00:01:05
aquí 00:01:07
esto mismo 00:01:07
delante del ID 00:01:14
ahora, el nombre 00:01:15
como se llama nombre lo dejo 00:01:20
y podríamos dejar 00:01:22
esto así 00:01:24
y esto 00:01:25
y no pasa nada 00:01:28
Pero, hombre, perdemos una posibilidad 00:01:29
Que es, jolines 00:01:33
Ya que tengo esa clave ajena 00:01:35
A mí me encantaría, desde el departamento 00:01:37
Acceder a todos los empleados 00:01:40
Esa es la idea natural, ¿no? 00:01:42
En la vida real 00:01:44
Entonces 00:01:45
Eso implicaría que en departamento 00:01:47
Me vendría estupendo 00:01:50
Tener esta propiedad 00:01:52
¿Listo? 00:01:54
Ahí 00:02:02
Listo 00:02:02
Con su get y su set 00:02:04
Añado el get y el set 00:02:14
De esta de aquí 00:02:20
Vale, no es que sea obligatorio 00:02:21
Que yo ponga esta propiedad 00:02:31
Pero es muy útil 00:02:33
Porque entonces tengo la doble navegabilidad 00:02:34
Que se llama 00:02:37
Tengo la doble 00:02:38
Que es, desde empleado 00:02:39
Puedo llegar a su departamento 00:02:41
Magnífico 00:02:44
Y desde departamento 00:02:45
Puedo llegar a sus empleados 00:02:48
Estupendo 00:02:50
Tengo la doble navegabilidad si la quiero, pero hombre, tendré que avisar que esta propiedad se rellena porque es el otro extremo de la otra relación. Si aquí tengo un many to one, es porque en el otro lado tengo un one to many. Esa es la doble navegabilidad. 00:02:51
Pues entonces 00:03:10
Me voy aquí a departamento 00:03:12
Y digo, oye tú, cuidado 00:03:15
Que este get empleados 00:03:17
Viene 00:03:19
Porque es el extremo 00:03:20
De la otra many to one 00:03:24
¿Vale? 00:03:25
Tengo que decir, oye 00:03:29
Pero dentro de empleado 00:03:31
¿De qué otro extremo eres? 00:03:32
Pues esto lo hacemos con 00:03:34
Y aquí ponemos 00:03:36
Dentro de la clase empleado 00:03:41
Dentro de la clase empleado 00:03:43
la propiedad que mapea 00:03:45
tu otro extremo es 00:03:47
esta 00:03:49
departamento 00:03:51
pues entonces mape by 00:03:52
departamento 00:03:55
¿vale? 00:03:57
entonces con esto hemos habilitado ya 00:04:07
navegar por los dos lados 00:04:09
desde empleado podemos entrar a los departamentos 00:04:10
y desde departamento 00:04:13
podemos entrar a la lista de empleados 00:04:15
esta es, este es el extremo 00:04:16
one to many 00:04:19
¿A cuál se corresponde para que Java sepa a qué clave ajena se corresponde para tirar de ella y rellenarlo todo y hacer su magia? Pues habrá que irse a la propiedad de departamento de empleado. Si nos vamos a la propiedad de departamento de empleado, vemos que efectivamente la propiedad de departamento de empleado está aquí caracterizada. 00:04:20
entonces aquí 00:04:40
sí que el lazy 00:04:46
pues sí, porque 00:04:49
voy a bajarlo aquí abajo 00:04:57
porque aquí 00:04:58
sí que cada vez que yo trabajo 00:05:00
con un departamento, cargar 00:05:03
siempre todos los empleados 00:05:05
esto sí que es un poco pesado 00:05:06
claro 00:05:08
de esta manera, cuando nosotros 00:05:10
carguemos un departamento 00:05:14
los empleados no se quedan cargados 00:05:16
en memoria, que yo los pido 00:05:18
entonces ya hibernate 00:05:20
se va corriendo, uy, voy corriendo 00:05:22
como nos ha pedido, y ahí a escondidas los cargo 00:05:23
siempre y cuando la sesión esté abierta 00:05:25
si no esté abierta, no, y nos da el 00:05:28
leis inicializaciones excepción 00:05:29
vale 00:05:31
vamos a probar esto primero 00:05:33
antes de añadir un par de propiedades más 00:05:35
vamos a 00:05:38
probar esto en nuestro main 00:05:40
a ver 00:05:41
yo creo que no nos falta ninguna notación 00:05:42
No sé qué errores van a salir 00:05:45
No son preparados 00:05:48
Pero si nos salen, maravilloso 00:05:50
Porque los arreglaremos 00:05:51
Primero vamos a ver si el error 00:05:53
Si el contexto de persistencia se crea bien 00:05:55
Porque está todo bien configurado 00:05:57
Perfecto 00:05:59
Todo info y error 00:06:05
Ha hecho la conexión 00:06:10
¿Veis? 00:06:12
Él automáticamente se hace un pull 00:06:13
No trabaja con conexiones JDBC 00:06:14
¿Veis? 00:06:17
trabaja con JDBC desde el principio 00:06:18
se hace su conexión 00:06:20
con JDBC 00:06:22
usa un pool 00:06:23
y pipipi, lo hace todo y estupendo 00:06:25
me dice que no hace 00:06:28
falta que especifique el dialecto 00:06:30
pues bueno, podría quitar esa propiedad de ahí 00:06:32
no le he configurado gestión 00:06:34
de transacciones complejas 00:06:36
JTA que mencionábamos el otro día 00:06:38
las transacciones pueden ser 00:06:40
las que yo hago con JDBC simples 00:06:42
o una gestión 00:06:44
compleja porque tengo diferentes bases 00:06:46
de datos de cursos. No he metido eso. 00:06:48
No he metido JTA. 00:06:50
¿Ya está? 00:06:52
Pues a arreglarlo 00:06:55
todo. 00:07:02
No, parece eso. 00:07:06
¿Os da errores? ¿A quién no le 00:07:09
da error? O sea, 00:07:10
¿le da lo que a mí? 00:07:12
No. 00:07:15
¿A todo el mundo le sale error, error, 00:07:16
error? 00:07:18
Así te sale, o sea, como a mí 00:07:18
Bueno, pues nos has levantado la mano 00:07:22
Sí 00:07:24
Habéis importado todo de 00:07:27
Jakarta, ¿verdad? 00:07:37
Habéis puesto aquí el nombrecito correcto 00:07:39
Pero a ver, el error os dirá por qué 00:07:41
Os dará una explicación de por qué os da errores 00:07:43
¿Has puesto bien el nombre? 00:07:51
¿Lo has puesto en meta ahí? 00:07:55
Transitorio, no tiene nada que ver 00:07:58
con el contexto de persistencia 00:07:59
porque no lo hemos hecho persistente 00:08:01
que esté aquí metido dentro 00:08:03
no significa que sea persistente 00:08:05
hay que hacerlo persistente 00:08:06
¿Cómo conseguimos que un objeto sea persistente? 00:08:08
Pues si nosotros hacemos esto 00:08:13
tranquilamente 00:08:15
ya está, a partir de aquí 00:08:16
el objeto ya es persistente 00:08:23
de hecho si hacemos esto, veremos como 00:08:25
me aparece en la base de datos, pero 00:08:29
si yo no hago esto 00:08:31
el objeto no aparece en la base de datos 00:08:32
no le he puesto la propiedad 00:08:35
id porque es autogenerada 00:08:39
si no fuera autogenerada 00:08:40
si yo aquí no tuviera el generated value 00:08:43
el jpa me diría, me falta 00:08:45
un dato, etcétera 00:08:47
vale, entonces si yo 00:08:49
ejecuto esto 00:08:51
¿Por qué no me sale el SQL 00:08:52
Si le he puesto que me lo muestre? 00:09:06
Qué pena 00:09:09
Debería salirme 00:09:10
Pero bueno, en la base de datos me va a salir 00:09:13
Departamento 00:09:15
Ah, perdón 00:09:17
Que me he metido en transacción, vale, con razón no me lo ha hecho 00:09:23
Perdón, perdón, perdón 00:09:25
Vamos, me salto lo más importantísimo 00:09:26
Por Dios, qué horror 00:09:28
Vale 00:09:30
tenemos que trabajar 00:09:31
este es el contexto de persistencia 00:09:34
pero cuando hacemos cosas que modifican 00:09:36
la base de datos, tenemos que trabajar 00:09:38
dentro de una transacción 00:09:40
luego hay otras cosas que las gestionan en transacciones 00:09:42
esa ya es otra movida 00:09:44
pero ¿cómo las gestionamos? 00:09:45
para que hagan exactamente lo que queremos decir 00:09:49
pero hay que trabajar en una transacción 00:09:50
si no la base de datos no se entera 00:09:51
¿es obligatorio trabajar siempre en el contexto 00:09:53
de una transacción? 00:09:56
cuando hacemos solamente consultas 00:09:57
no lo es 00:10:02
¿vale? no hace falta 00:10:03
pero siempre es recomendable 00:10:05
trabajar en el contexto de una transacción 00:10:07
¿vale? entonces 00:10:09
si modificamos hay que meterlo 00:10:11
en transacción, aunque aquí es una tontería 00:10:14
porque solamente hacemos una sentencia 00:10:16
entonces la transacción es cuando hacemos muchas cosas 00:10:17
y queremos o que se hagan 00:10:20
todas a la vez o ninguna 00:10:22
aquí es una tontería, solo hacemos una 00:10:23
Pero aún así 00:10:25
Tenemos que meterlo en una transacción 00:10:27
Vale, entonces 00:10:28
¿Cómo se hace una transacción? 00:10:31
Create 00:10:41
Creo que era, si no lo miro 00:10:42
Get transaction 00:10:45
Begin 00:10:48
Vale 00:10:50
Entonces con esto empezamos una transacción 00:10:52
La transacción ya está empezada 00:10:55
Y ahora ya 00:10:57
En el momento en el que yo quiera 00:10:59
Que las cosas 00:11:03
Se actualicen en la base de datos 00:11:04
Porque aquí yo podría haber hecho un montón de cosas 00:11:06
Podría haber ahora empezado a hacer departamentos 00:11:08
El departamento ahora me cambia 00:11:11
Ahora cojo no sé cuántos, ahora cojo no sé qué 00:11:13
Cuando quiero que eso realmente 00:11:14
Se refleje en la base de datos 00:11:16
Cuando me interesa que se refleje 00:11:18
Pues ahora me hago el 00:11:19
El commit 00:11:22
Vale, entonces ahora ya 00:11:23
sí que voy a ver el 00:11:29
log del SQL ahí, suponemos. 00:11:31
¿O por qué no me aparece el insert? 00:11:39
¿Ahí? 00:11:41
Vale, pero ¿por qué no hay 00:11:46
insert? Ahí estamos. 00:11:47
Sería más cómodo que 00:11:58
el Berlin y el Comic funcionasen como 00:11:59
un bloque, ¿no? 00:12:01
¿Cómo como un bloque? 00:12:03
¿Más cómodo? 00:12:08
No, me parece, es hacer un bloque 00:12:09
todo lo que sea NIDAR y 00:12:11
hace a mí, no me sería más cómodo. 00:12:13
Bueno, pues 00:12:17
¿qué quería 00:12:18
yo hacer aquí? 00:12:23
Venga, pues vamos a hacer 00:12:25
vamos a ahora 00:12:26
coger un empleado, por ejemplo 00:12:28
¿tenemos algún empleado hecho? 00:12:31
Sí. Tenemos a 00:12:33
este que estaba en el departamento 00:12:35
Vale, tranquilos. 00:12:42
No tenéis ningún empleado 00:12:44
Pues a ver, meteos uno aquí 00:12:49
Uno, porque lo quiero sacar, no lo quiero meter 00:12:52
Yo, meteos uno 00:12:53
Que esté en cualquier departamento 00:12:54
¿No tenéis ningún departamento tampoco? 00:12:57
Vale 00:12:59
Pues 00:13:00
Venga, creaos un par de 00:13:02
Yo que sé, un par de datos de prueba 00:13:08
Añadid otro departamento más 00:13:10
El que os dé la gana 00:13:12
y un par de empleados. 00:13:13
Añadid unos datos cualquiera. 00:13:20
Bueno, pues este objeto es persistente, 00:13:35
pero los objetos pueden ser persistentes 00:13:36
no solo porque yo los he creado 00:13:39
y los he insertado en la base de datos, 00:13:42
sino porque los estoy recuperando de la base de datos. 00:13:44
Por ejemplo, vamos a recuperar un empleado 00:13:47
de la base de datos 00:13:50
¿Cómo recuperamos un empleado de la base de datos? 00:13:57
Pues lo recuperamos con find 00:14:02
Recuperar por clave primaria 00:14:04
¿Vale? Es lo que voy a hacer aquí 00:14:08
Recuperar por clave 00:14:10
Entonces, pues por ejemplo 00:14:18
Voy a recuperar el primero que tengo 00:14:21
¿Y aquí qué se pone? 00:14:23
Aquí se pone 00:14:26
El objeto clase 00:14:27
El objeto clase en el que va a caer ese empleado 00:14:30
¿qué es esto? 00:14:33
entonces, ahora ya tengo dos 00:14:45
objetos persistentes 00:14:47
conectados a la base de datos 00:14:48
el departamento que además 00:14:51
he insertado porque no estaba 00:14:53
y este empleado que lo he recogido a la base de datos 00:14:54
me he limitado a recogerlo 00:14:57
entonces los dos son persistentes 00:14:59
ahora yo ya a partir de aquí 00:15:00
me olvido de la base de datos 00:15:03
y hago con ellos lo que quiera 00:15:05
y cuando haga el commit 00:15:06
todo se reflejará, por ejemplo 00:15:09
mi empleado en este caso 00:15:11
que estaba en el departamento 00:15:13
vamos a ponerlo aquí 00:15:15
empleado está 00:15:20
vamos a poner el departamento en el que está 00:15:26
empleado.get 00:15:29
departamento 00:15:31
.get 00:15:32
nombre 00:15:35
entonces esto es mucho más cómodo 00:15:36
que jdbc porque yo recupero 00:15:39
el empleado y tengo todos los datos 00:15:41
del empleado colgando a través de él 00:15:43
del departamento, del nombre 00:15:45
ahí lo tengo todo 00:15:46
¿vale? 00:15:48
¿qué? vale 00:15:50
a ver, que voy a bajar esto aquí 00:15:52
¿vale? 00:15:55
entonces es mucho más cómodo que JDBC 00:15:57
lógicamente 00:15:59
aquí, aunque yo 00:16:00
no lo vea, Ibernati ha ido en dos 00:16:03
saltos, aquí ha recuperado 00:16:05
el empleado 00:16:07
y luego yo, como le he pedido el departamento 00:16:08
él dice, ostras, que lo que quiere es el departamento 00:16:11
pues se ha ido corriendo a hacer el select 00:16:13
del departamento, pues aquí ha hecho 00:16:15
un primer select, solo con los datos del empleado 00:16:17
sin el departamento que le cuelga 00:16:19
y aquí ha hecho un segundo select 00:16:21
porque se lo he pedido específicamente 00:16:23
y eso es así 00:16:25
porque esto está como lazy 00:16:26
si estuviera como 00:16:29
eager 00:16:31
aquí el select 00:16:31
que haría, sería un select join 00:16:35
entonces podéis probar 00:16:37
a ejecutar primero esto con lazy 00:16:39
y veréis en el show SQL que hay dos select 00:16:41
y sin embargo si lo ejecutáis 00:16:43
con eager veréis que hay un único select con el join 00:16:45
entonces se hace 00:16:47
más pesado con el eager 00:16:49
porque desde el principio 00:16:50
lo tiene todo 00:16:53
entonces puede que no lo necesitemos 00:16:55
y estamos cargando todo, haciendo los join 00:16:57
haciendo todo el rollo para luego no pedirlo 00:16:59
aquí en este caso si lo hemos pedido, pero podría ocurrir que no 00:17:01
con el eager ya 00:17:03
con el eager ya carga 00:17:05
todo lo que tenga colgando 00:17:07
Entonces 00:17:09
¿Veis? Me ha hecho dos SELs diferentes 00:17:14
El primer SEL es sencillito 00:17:22
No se ha complicado la vida 00:17:23
Y luego ya me ha hecho el resto de SEL 00:17:25
Del empleado está en informática 00:17:28
Vale 00:17:30
Aquí 00:17:30
¿Qué ocurriría? 00:17:35
Imaginaos que aquí como tengo yo 00:17:39
Un único main 00:17:40
Pues lógicamente no tendría sentido 00:17:41
aquí, pero si yo 00:17:44
imaginaos 00:17:49
que hago esto aquí 00:17:54
control 00:17:56
esto 00:17:58
en lugar de ponerlo aquí 00:18:00
lo pusiera 00:18:01
lo pongo 00:18:07
aquí 00:18:10
vale 00:18:12
entonces 00:18:15
vale, que esto aquí como estoy en un 00:18:16
unicomain todo controlado, pues 00:18:22
rápidamente veríamos que esto es un problema 00:18:23
pero cuando tenemos mil capas 00:18:26
de DAOs, implementaciones, servicios 00:18:28
DTOs, cuando tengo un montón de capas 00:18:30
esto ya no es una tontería 00:18:32
que ocurra esta situación 00:18:34
entonces yo aquí, lo que es 00:18:35
importante por supuesto es que el 00:18:38
commit y el close lo haya 00:18:40
hecho aquí después, después de 00:18:42
persistir este objeto y después de recuperar 00:18:44
el otro, pero 00:18:46
luego yo puedo estar tan tranquila 00:18:48
pensando que como ya ha recuperado el empleado 00:18:50
ya el contexto 00:18:52
de persistencia se ha cerrado porque 00:18:54
no lo necesito más y yo tengo aquí 00:18:56
mi empleado y siga haciendo cosas con él, que en este 00:18:58
caso sería, me creo que lo tengo 00:19:00
pero estoy en un DAO, lo recojo 00:19:02
patatín y ejecuto esto 00:19:04
y resulta que aquí me 00:19:06
debería salir este 00:19:08
error 00:19:15
¿vale? 00:19:16
entonces, este error 00:19:25
significa, uy 00:19:26
estás intentando acceder a una propiedad 00:19:27
que yo no te he 00:19:30
rellenado cuando recogiste el objeto 00:19:32
porque me pusiste en modo vago 00:19:34
entonces yo 00:19:36
si yo no tengo ningún problema, yo me voy a select 00:19:37
y te lo hago ahora mismo, pero me acabas 00:19:40
de cerrar el contexto de persistencia 00:19:42
con lo cual lo siento, pero no te lo puedo hacer 00:19:44
todo eso es lo que significa 00:19:45
el lazy inicialización excepto este 00:19:47
a ver, aquí si haría falta porque he puesto 00:19:49
el persist antes 00:19:54
no, podría haber hecho el commit aquí 00:19:55
antes, a ver, me lo he puesto ahí porque 00:20:02
comimos las dos juntas, pero además podría haber puesto el commit 00:20:04
aquí, vale 00:20:06
Vale, pues entonces 00:20:07
Esto no nos interesa 00:20:10
Que esté aquí 00:20:20
Sino que nos interesa ahí 00:20:21
Y aquí ponemos 00:20:23
Alguien 00:20:25
Action 00:20:43
Exception 00:20:49
Vale, pues a ver 00:20:53
Más cosas interesantes 00:20:58
Bueno, yo aquí ya en este punto 00:21:00
En el que estamos aquí 00:21:01
Estoy aquí 00:21:03
Tengo mis objetos persistentes 00:21:06
Estos, empleado que lo he recuperado 00:21:09
Y departamento que lo he hecho 00:21:11
Persistente, vale 00:21:13
Aquí tengo los dos 00:21:14
Y ahora puedo hacer un montón de cosas 00:21:16
Por ejemplo 00:21:18
¿Puedo yo actualizar 00:21:21
Desde el departamento 00:21:24
¿Puedo actualizar empleado? 00:21:28
Pues sí que puedo 00:21:31
A ver, sí o no 00:21:32
Depende de una propiedad 00:21:34
A ver, por ejemplo, tenemos nuestro departamento y vamos a todos los, vamos a hacer ahora un trocito de código que sea todos los empleados de un departamento añadirles a su nombre un guión bajo, por ejemplo, porque todos los empleados del departamento nos interesa que se llamen con su nombre guión bajo. 00:21:35
Vale, pues por ejemplo 00:21:58
Añadimos 00:22:01
A todos los 00:22:03
Todos los pelaos de frío 00:22:06
Patamento 00:22:16
Un guión bajo 00:22:18
A su nombre 00:22:22
Esto con jdbc 00:22:24
Directamente es un rollo, tengo que hacer los sql 00:22:27
Con esto es facilísimo 00:22:30
Aquí sí que importa el teléfono 00:22:32
Sí, sí, sí 00:22:33
porque íbamos a actualizar la base de datos. 00:22:35
Entonces, aquí, pues, a ver, 00:22:38
¿de qué departamento vamos a hacerlo? 00:22:42
Pues, de uno cualquiera. 00:22:46
De este, por ejemplo, que acabamos de hacer persistente de aquí. 00:22:47
Lo que pasa es que este no tiene todavía ningún empleado. 00:22:50
Pues, venga, este empleado que acabo de coger 00:22:53
le voy a pasar a ese departamento antes de nada. 00:22:56
¿Vale? 00:23:00
Entonces, el empleado que acabo de coger 00:23:01
le voy a fijar como departamento 00:23:03
el departamento que acabo de hacer 00:23:06
entonces voy a 00:23:08
poner esto antes 00:23:10
lo voy a poner aquí 00:23:11
le cambio el 00:23:13
departamento 00:23:22
vale 00:23:24
entonces todo esto 00:23:25
trabajo con objetos, estoy olvidada 00:23:29
de la base de datos, que es la ventaja 00:23:32
los objetos desde el momento en que ya están en el 00:23:33
contexto y son persistentes, yo trabajo con ellos 00:23:36
tranquilamente, yo he cambiado el departamento, no tengo que hacer 00:23:38
ningún UBDATE, 00:23:40
WEBWARE, no sé qué, 00:23:42
SETVALUES, patatín, no. 00:23:43
A este empleado, ¿quiere este departamento? 00:23:45
Pues ya está, en ese departamento este. 00:23:47
Tan ricamente. Ahora, siguiente cosa 00:23:50
que hemos dicho. ¿Vale? Entonces, 00:23:52
todos estos objetos, esto no significa 00:23:55
que en la base de datos esto se haga automáticamente, 00:23:57
no. Esto lo que significa 00:24:00
es que Hibernate 00:24:01
tiene su cajita de objetos 00:24:03
manejados. 00:24:05
Los MANAT, que se llama así, 00:24:08
lo estudiáis en inglés. 00:24:10
hibernate tiene su cajita de objetos manejados 00:24:10
entre los cuales es em 00:24:14
y departamento, los tiene ahí manejados 00:24:15
entonces él va registrando 00:24:18
todos los cambios que se les van haciendo 00:24:19
y cuando toque 00:24:21
porque hagamos un commit o porque 00:24:23
hagamos un flush, que también se 00:24:25
puede hacer, vale 00:24:27
entonces sí que se sincroniza 00:24:37
con la base de datos 00:24:39
sincronizamos base 00:24:40
de datos y 00:24:43
contexto de 00:24:45
Persistencia 00:24:47
¿Vale? Entonces, y Bernadette 00:24:49
Tiene su objeto, nosotros trabajamos con ellos 00:24:54
Y a respuestas de los fluses 00:24:55
O de los commit, se sincroniza 00:24:57
Él ya sabe cómo hacerlo, nosotros nos olvidamos 00:24:59
Vale, entonces, ahora queda lo siguiente que vamos a hacer 00:25:01
Actualizar 00:25:04
Un objeto a través de otro 00:25:05
Aquí es en, porque es el contexto de 00:25:07
Persistencia, este es el empleado, vale, no está muy bien 00:25:12
Elegido el nombre 00:25:14
Vale, a ver, vamos a todos los departamentos 00:25:14
Venga, pues por ejemplo a este 00:25:18
Podría ser otro que cojamos 00:25:20
Pero vamos a hacer este mismo, este departamento 00:25:22
Pues por ejemplo, podríamos hacer 00:25:24
Tenemos departamento 00:25:26
Punto 00:25:30
Get empleados 00:25:31
Aquí tengo todos sus empleados 00:25:33
¿Vale? 00:25:36
Él, el hibernate 00:25:39
Se va a ir corriendo a hacer el select 00:25:41
Porque como lo teníamos como lazy 00:25:42
No lo tiene cargado 00:25:44
Vale, pues entonces 00:25:47
Vamos a coger 00:25:51
Todos los empleados 00:25:53
De este departamento 00:25:55
Ahora 00:25:57
Sí, sí, sí 00:25:59
Entonces, ahora 00:26:05
Los 00:26:07
Jolines 00:26:08
Que pesado, sí, es que le pongo el punto 00:26:12
Y me lo extiende con el axe todo el rato, pero bueno 00:26:15
No quiere que haga el stream 00:26:17
vale, get empleados 00:26:19
vale, entonces ahora 00:26:21
¿qué queremos hacer con toda la lista 00:26:26
de empleados? 00:26:27
una transformación 00:26:29
de tal manera que el nombre de cada 00:26:31
uno de ellos sea 00:26:34
igual a su nombre concatenado 00:26:35
con un guión bajo 00:26:37
¿vale? entonces 00:26:39
con cada uno de esos empleados 00:26:40
queremos 00:26:44
hacer una cosa, entonces 00:26:45
Haríamos un for each 00:26:47
¿Verdad? Estoy pensando en voz alta 00:26:50
Y hablar y pensar a la vez me cuesta 00:26:52
Entonces estoy esperando que me digáis vosotros 00:26:54
No os estoy preguntando 00:26:55
¿Sí? ¿Seguro? 00:26:57
Vale, hago un for each 00:27:00
Y ahora, ¿qué hago en cada for each? 00:27:02
Para cada objeto empleado 00:27:05
De estos 00:27:06
¿Qué le hago? 00:27:08
Pues para cada objeto empleado 00:27:11
X punto 00:27:12
Get 00:27:15
nombre 00:27:17
sí, sí, sí 00:27:18
sí, pero primero lo voy a concatenar 00:27:21
x.getNombre 00:27:23
más, que ahora lo meto en el set delante 00:27:24
ahora me voy antes 00:27:27
sí, pero que voy ahora 00:27:27
al x.set 00:27:32
pongo primero el set 00:27:34
y ahora ya me voy al principio de la línea 00:27:36
setNombre 00:27:38
vale 00:27:42
vale 00:27:44
que me falta aquí 00:27:47
un punto y coma, lo que pasa es que no voy a necesitar 00:27:57
las llaves, porque solo tengo 00:27:59
una, sí, pero no me hacen 00:28:01
falta, al quitar las llaves voy a poder quitar el punto 00:28:03
y coma, porque las llaves no me hacen falta, ¿verdad? 00:28:05
Vale, como solo tengo 00:28:08
una línea, pues entonces quito 00:28:09
la llave y quito 00:28:11
el punto y coma 00:28:13
¡Hala! Más bonito así, ¿no? 00:28:14
Pues esa es la clave, depende 00:28:30
Porque hay un atributo que no hemos puesto que es el cascade 00:28:33
Entonces el cascade 00:28:36
Significa, cuando tú 00:28:37
Haces algo con un objeto 00:28:39
Eso lo llevas en cascada 00:28:41
A los que cuelgan de ti 00:28:44
Es un atributo que no hemos puesto 00:28:45
A la hora de hacer la anotación 00:28:47
¿Vale? Entonces su valor por defecto 00:28:49
Podríamos ver 00:28:52
Preguntarle a HGPT cuál es 00:28:53
Porque depende de cada extremo 00:28:55
Del one to many, many to many, many to one, tiene uno 00:28:57
¿Su valor por defecto? No sé cuál es. 00:28:59
¿Vale? 00:29:02
Entonces, aquí hay un atributo que no hemos puesto, 00:29:03
que es el cascade. 00:29:06
¿Vale? 00:29:07
Que en este... 00:29:09
Sería en empleado, ¿no? 00:29:11
Sería... No, porque estoy... 00:29:13
No, a través de 00:29:16
departamento estoy queriendo 00:29:17
cambiar empleados. Entonces, 00:29:19
yo aquí podría poner un atributo 00:29:21
cascade, a ver que lo... 00:29:23
¿Cómo se llamaba exactamente? 00:29:25
Tengo que tener por aquí 00:29:29
No, aquí tengo el por defecto 00:29:30
Cascade, vale 00:29:36
A ver 00:29:39
Cascade 00:29:42
Pongo aquí abajo 00:29:50
Cascade 00:29:59
Type. 00:30:01
Ahora estoy en empleado 00:30:08
Ah, no, estaba en departamento 00:30:09
Tienes razón 00:30:12
Bueno, puede 00:30:13
Vale, pero ya que lo tengo 00:30:15
Sí, voy, voy, voy 00:30:16
A ver 00:30:19
A ver 00:30:20
No lo he escrito bien 00:30:22
Ah, en many to one, perdón, es que siempre pongo donde no es 00:30:25
Aquí 00:30:27
Sí, sí, sí, ya la quito 00:30:30
Ya la quito 00:30:33
Vale, a ver 00:30:34
Ah, es que este estaba a medias 00:30:38
Vale, pues vamos a poner aquí 00:30:45
Este 00:30:49
No, le pones donde tú quieras 00:30:52
Ahora lo explico 00:30:55
En cada lado tiene un valor por defecto 00:30:56
Y tú lo puedes especificar 00:30:59
Vamos a ver qué significa 00:31:01
El cascade 00:31:03
Lo puedes poner o no, si no lo pones 00:31:05
Tiene un valor por defecto 00:31:07
Porque hay muchas más relaciones 00:31:08
One to many, many to one 00:31:11
Many to many 00:31:12
¿vale? en cada una de las posibilidades 00:31:14
tiene un valor por defecto 00:31:17
¿qué significa el cascade? significa 00:31:18
oye, esta entidad de departamento 00:31:21
cuando yo le haga un persist 00:31:22
cuando le haga un remove 00:31:24
que también lo puede hacer, cuando le haga algo 00:31:26
eso 00:31:29
se va a extender a esta 00:31:30
propiedad que le cuelga 00:31:33
es decir, si yo he cambiado 00:31:34
un empleado a través del 00:31:37
departamento y hago un 00:31:38
persist departamento 00:31:41
Ese persist se va a extender 00:31:43
Al empleado que está colgando 00:31:46
Depende del cascá de type 00:31:47
Porque cascá de type hay de muchos tipos 00:31:49
Si ponéis aquí un punto 00:31:52
Está el 00:31:53
Depende 00:31:56
Si pones este, sí, sí, el persist 00:31:56
Te lo va a transmitir 00:31:59
El remove te lo va a transmitir 00:32:01
El separar, porque recordad el otro día 00:32:03
Que un objeto persistente lo puedes separar 00:32:06
También te va a separar los empleados 00:32:08
El merge 00:32:10
que es cuando tenías uno separado 00:32:12
y volverlo a meterte, lo va... 00:32:13
Entonces, el cascadol es todo. 00:32:15
El cascadeol es 00:32:18
típico en pruebas, pero luego 00:32:20
tiene su peligro, porque 00:32:21
el cascaderemuf es muy peligroso. 00:32:23
Porque tú borras un empleado, 00:32:26
por ejemplo, y es que borrarías 00:32:28
el departamento. Eso no quieres 00:32:30
hacerlo. Cuando eliminas un departamento, 00:32:32
si querría, haces 00:32:35
un remove departamento, puede que no te importe 00:32:36
que se eliminen todos los empleados que tiene. 00:32:38
pero si haces un remove empleado 00:32:40
y tienes en la 00:32:42
many to one el cascá de all 00:32:44
te va a borrar el departamento también 00:32:47
es que 00:32:49
pedís mucho 00:32:54
cascá de persist 00:32:57
es típico 00:33:02
cascá de persist y ya está, es la operación habitual 00:33:03
cuando haces un refresh 00:33:06
para que... 00:33:09
Vale, entonces... 00:33:11
¿Qué? 00:33:12
Entonces, aquí, 00:33:15
la prueba que estoy 00:33:16
haciendo yo ahora, la prueba que estoy 00:33:18
haciendo yo ahora en el main, vamos a situarnos, 00:33:20
la prueba que estoy haciendo es 00:33:23
a través de departamento 00:33:25
actualizar empleado. 00:33:27
Pues para que a través de departamento pueda 00:33:29
actualizar empleado, el departamento 00:33:30
tiene que tener, el departamento, 00:33:33
el cascade, a all 00:33:35
o a persist. Esto ya como 00:33:36
uno quiera, ¿vale? Por ejemplo, 00:33:38
aquí, a Persist, ¿vale? 00:33:41
El empleado, por ahora, 00:33:43
este sería muy peligroso. 00:33:45
Poner en el empleado 00:33:47
el cascadeón a departamentos, 00:33:48
ese sí que tiene mucho peligro, porque 00:33:50
cualquier cambio en empleado se traslada. 00:33:52
Entonces, aquí, 00:33:56
lo natural 00:33:57
sería dejar el valor por defecto 00:33:59
que 00:34:01
será el Persist, supongo. 00:34:01
Luego se lo vamos a preguntar aquí al tipo este. 00:34:05
y de este persiste. 00:34:08
Muy bien. 00:34:09
Muy bien, me parece. 00:34:11
Muy bien. 00:34:12
Entonces, 00:34:13
en empleado 00:34:13
dejaríamos persiste. 00:34:14
A ver, 00:34:18
en empleado 00:34:19
dejas lo que tú quieras. 00:34:19
A ver, 00:34:21
que esto no es 00:34:21
sota caballo y rey. 00:34:23
Nosotros contamos 00:34:25
de qué va esto, 00:34:25
posibilidades, 00:34:26
herramientas. 00:34:27
Pero no es 00:34:28
esto así 00:34:29
y esto no así. 00:34:29
Depende. 00:34:30
Puede que 00:34:31
los requisitos 00:34:32
de tu aplicación 00:34:33
impliquen 00:34:33
que si tú eliminas 00:34:34
un empleado, 00:34:36
lo eliminas todo, 00:34:36
pues entonces 00:34:37
Esto depende. Yo os cuento las cositas de la vida. Entonces, en nuestro caso, a través del departamento queremos tocar los empleados. Pues, entonces, tengo que hacer el cascade type persist como mínimo para que funcione la funcionalidad que he hecho. 00:34:38
Vale, vamos a ver si esto nos funciona 00:34:57
A ver 00:35:04
Vale, aquí hay un null pointer exception 00:35:07
String departamento get empleados es null 00:35:17
Vale, porque esto es null porque no he hecho el commit de la transacción 00:35:21
Entonces getDepartamentos 00:35:28
O sea este que acabo de crear 00:35:30
Vale 00:35:31
Entonces el flush 00:35:34
Sincroniza con lo que en ese momento 00:35:36
Este 00:35:38
Ya comiteado de antes 00:35:39
Vale, entonces 00:35:41
Es que lo ideal sería coger 00:35:43
A ver 00:35:50
Es por el commit 00:35:56
Vale, vamos a 00:35:57
Vale, hacemos un commit 00:36:00
Para que el departamento tenga un empleado 00:36:09
Al menos 00:36:11
Y ahora de este mismo empleado 00:36:12
Vale, lo que pasa es que claro, hacerlo todo así 00:36:15
En un main a lo bestia, esto es una 00:36:19
Chapucilla, pero no sufráis 00:36:21
Que ahora le vamos a poner algo mucho más chulo 00:36:23
El empleado está en informática 00:36:24
Vale, entonces 00:36:33
Espera que le voy a hacer el 00:36:34
Flush, lo voy a hacer aquí abajo 00:36:41
Para que se sincronice 00:36:43
Con el nuevo departamento que tiene 00:36:49
Vale 00:36:51
A ver ahora 00:36:53
Un segundito 00:36:59
Porque nos estamos 00:37:04
Volviendo locas, vale 00:37:07
Ah, vale, que he hecho 00:37:09
El commit, pero 00:37:11
begin y no 00:37:12
él ha empezado otra vez 00:37:14
en transaction begin 00:37:15
ay que chapucilla 00:37:18
vamos a ver 00:37:21
este begin 00:37:23
aquí otra vez 00:37:28
a ver un momentito 00:37:31
a ver si 00:37:34
es que esto me pasa por no haber 00:37:35
cogido un departamento del otro sitio 00:37:38
Sí, a ver, el tema es que no 00:37:40
Digging, vale 00:37:49
Vale, espera, vamos a 00:37:51
Es que claro, tenemos aquí, a ver 00:37:55
Para empezar vamos a dejar de meter a este aquí 00:38:01
Que lo estamos creando de nuevas 00:38:03
Todo el rato, uno nuevo 00:38:04
Y esto es un desastre, entonces 00:38:06
No, no, no, no, no voy a borrar todo 00:38:08
Sí, tranquilo 00:38:11
A ver, recuperamos por clave 00:38:13
Si estuviera cerrado 00:38:16
Le cambio el departamento 00:38:18
Y ahora, todo esto de aquí está a prueba 00:38:19
Vamos a sacarla de aquí 00:38:21
Le cambio el departamento 00:38:22
Con lo cual todo esto lo vamos a sacar de aquí 00:38:25
Vale, y lo vamos a un método aparte 00:38:28
Venga, pues ya está 00:38:31
A ver, dejamos este main 00:38:32
Que lo que hacía era 00:38:36
Crear un departamento 00:38:39
Recuperar a un empleado 00:38:41
Y poner al empleado en ese departamento 00:38:42
Ya está 00:38:45
Ahora vamos a hacer un método aparte 00:38:47
Para que no tengan esos problemas 00:38:49
Un método aparte 00:38:51
Que es 00:38:54
Cambiar nombre 00:38:55
Empleados 00:38:58
Y le vamos a pasar 00:39:00
El ID del departamento 00:39:02
Del que vamos a cambiar el nombre 00:39:05
Vale, pues ahora 00:39:07
Este método limpio desde el principio 00:39:09
Tendremos que hacernos 00:39:11
Nuestro contexto de persistencia 00:39:13
Venga 00:39:15
Nos hacemos aquí nuestro contexto 00:39:17
De persistencia, vale 00:39:19
Ahora ya, vamos a recuperar el departamento 00:39:20
Bueno, vamos a hacer la transacción 00:39:23
Claro 00:39:27
En punto 00:39:27
GetTransaction.begin 00:39:31
Ahora vamos a recuperar 00:39:34
El departamento 00:39:37
departamento 00:39:38
en .find 00:39:40
departamento 00:39:44
.class 00:39:49
de este 00:39:51
objeto de aquí tenemos que hablar luego 00:39:52
muy seriamente 00:39:54
y aquí le pongo el id 00:39:55
ahora 00:40:00
nos sacamos, hacemos el stream famoso 00:40:01
de .get 00:40:04
Get empleados 00:40:06
Punto stream 00:40:12
Punto for each 00:40:14
Punto para cada x 00:40:17
¿Qué me vas a hacer? 00:40:20
Pues para cada x me vas a hacer 00:40:21
X.set nombre 00:40:23
X.get nombre 00:40:27
Más esto de aquí 00:40:30
Vale 00:40:33
Ahora ya 00:40:35
Que le hemos cambiado el nombre a los estos 00:40:36
Hacemos ya en .getTransaction.commit 00:40:38
Y ahora ya cerramos 00:40:47
¿Vale? 00:40:50
Entonces 00:40:53
El flujo no necesita ningún flujo 00:40:53
Porque no tenemos que sincronizar nada 00:40:56
Entonces, enseñanza importante que se nos olvida 00:40:57
Sobre todo cuando nos ponemos a hacer pruebas y encadenamos 00:41:01
Cuando trabajamos con bases de datos 00:41:03
Sobre todo con RM 00:41:06
atomizar cosas atómicas 00:41:07
métodos atómicos 00:41:10
que hacen las cosas, como hagamos un método 00:41:11
con un montón de cosas 00:41:13
vale, pues entonces 00:41:14
ahora ya, cambiar nombre empleados 00:41:17
lo vamos a llamar desde aquí 00:41:19
pasándole un id que tenga algún empleado 00:41:21
porque si no, no hacemos nada 00:41:23
entonces 00:41:24
vamos a darle un id 00:41:31
¿qué? 00:41:33
un segundín 00:41:38
que voy a poner un, voy a buscar un id 00:41:39
Que tenga un de 00:41:41
Javi 00:41:43
Venga, Javi, Ana y esta otra Ana 00:41:44
Están todos en el 1 00:41:50
Luego el 1 tiene varios 00:41:51
Pues voy a pasarle yo en mis pruebas el 1 00:41:53
Vosotros lo que os dé la gana 00:41:56
Y aquí el static 00:41:57
A ver, ahora 00:42:00
¿Qué había que poner? 00:42:02
Vale 00:42:15
Entonces, todo esto de arriba 00:42:16
Toda esta prueba 00:42:17
La voy a meter en un método aparte 00:42:18
Que sea pruebas iniciales 00:42:21
Control X 00:42:24
Lo voy a poner aquí 00:42:26
Private 00:42:27
Static void 00:42:30
Prueba inicial 00:42:31
Lo voy a poner aquí 00:42:34
Para que no sea un rollo 00:42:37
Y ahora ya mi main se queda solamente con 00:42:38
Prueba inicial 00:42:43
Que la voy a comentar 00:42:44
Inicial 00:42:46
Vale, pues ahora ya sí que sí 00:42:47
Vamos a probar esto, cambiar nombre empleados 00:42:54
El código que acabo de hacer 00:42:56
Este de aquí 00:42:57
Vamos a ver 00:42:58
Si hemos acertado 00:43:01
Venga 00:43:04
Vale, ya hemos acertado 00:43:06
Vamos a ver 00:43:08
Nos vamos aquí a empleados 00:43:12
Y aquí están 00:43:14
Todos los del departamento 1 00:43:16
Se les ha cambiado el nombre 00:43:19
¿Hasta dónde? 00:43:21
A ver, este es el método en el que he metido 00:43:30
La mierdecilla que tenía en el main de antes 00:43:32
Lo he metido en un método aparte 00:43:35
En prueba inicial he metido lo que tenía en el main de antes 00:43:37
Para que no esté ensuciando ahí el main 00:43:41
Me he limitado a meterlo ahí y ya está 00:43:43
Y luego me he hecho este otro 00:43:45
Con eso 00:43:46
Cada método sería cada caso de uso 00:43:48
esto es lo que llamamos caso de uso 00:43:50
lo que mi aplicación hace, cada caso de uso 00:43:52
es un método, es un caso de servicio 00:43:54
entonces un segundito 00:43:55
y ya me callo 00:43:57
como veis, aunque resistáis 00:43:59
a creerlo 00:44:02
esto es infinitamente más fácil y más cómodo 00:44:03
que JDBC 00:44:06
es los objetos 00:44:07
pero a ver 00:44:09
porque no estoy usando ningún patrón de diseño 00:44:14
entonces me he hecho un contexto de persistencia con todo a mogollón 00:44:16
así no se trabaja 00:44:19
Pero, hombre, por favor, no seáis tan, tan, tan, tan, tan quejicas. 00:44:20
Tú coges los objetos y trabajas con los objetos. 00:44:26
Cambias los empleados, le añades. 00:44:30
A través de la colección le añades un empleado, se lo quitas, lo pones. 00:44:32
Haces lo que quieras. 00:44:36
Y ya está. 00:44:37
Espera un segundito. 00:44:40
¿Cómo sería para hacer el file? 00:44:43
Pero, pues, no. 00:44:45
En vez de buscar por ID, que te busque por contenido de... 00:44:45
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:
6
Fecha:
19 de enero de 2026 - 12:02
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
44′ 50″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
202.48 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid