Saltar navegación

20260127 JPA_8 - 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 27 de enero de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues los métodos del servicio que habíamos hecho, estos de aquí, en el contexto de ellos es donde vive el entity manager, ¿vale? El gestor de objetos, el que los maneja. En el contexto de ellos se abre y se cierra, por lo cual en el contexto de ellos es donde hacemos las transacciones. 00:00:02
porque las transacciones se tienen que hacer dentro de un entity manager 00:00:28
antes de que se cierre, entonces es lo habitual 00:00:34
que el entity manager tenga vida solamente dentro de cada caso de uso 00:00:39
o de cada método de servicio, más o menos es lo habitual 00:00:45
que cada caso de uso sea independiente de los demás 00:00:52
y tenga su propio gestor de objetos 00:00:54
Recordar la trascendencia que tenía esto 00:00:56
Porque si hacíamos que el entity manager 00:00:59
En lugar de vivir aquí 00:01:01
Y tener todo su nacimiento y muerte 00:01:03
A nivel de caso de uso 00:01:05
Si en lugar de tenerlo ahí 00:01:08
Lo tuviera 00:01:09
Lo tuviera 00:01:11
Aquí 00:01:17
Vale, si lo tuviera 00:01:19
Aquí 00:01:23
El problema que tendríamos es que por ejemplo 00:01:25
en el get, si lo tenemos 00:01:29
inicializado como lazy 00:01:33
el get de un objeto 00:01:35
no recoge todas las cosas 00:01:37
relacionadas con clave ajena 00:01:39
no las recoge, solo las recoge 00:01:41
cuando las pidamos específicamente 00:01:43
entonces si 00:01:45
tuviéramos aquí el entity manager 00:01:47
naciendo y muriéndose 00:01:49
y luego ya en el caso de uso 00:01:51
una vez recuperado el objeto 00:01:53
quisiéramos acceder a lo relacionado 00:01:55
con clave ajena, pues tendríamos 00:01:57
un LaysInitializationException, etc. 00:01:59
¿Vale? Era un poquito 00:02:02
alguna de las cosas que 00:02:03
vimos el otro día. 00:02:04
Bueno, pues entonces nos vamos aquí 00:02:07
al caso de uso que era 00:02:08
este 00:02:11
nuestro. 00:02:13
¿Vale? Como estos de aquí eran todos 00:02:16
de recuperar 00:02:17
departamento, recuperarlo 00:02:19
con todos sus empleados. 00:02:21
¿Vale? Para lo cual llamábamos a este 00:02:23
DAO que 00:02:25
implicó que hiciéramos una 00:02:27
sentencia JPQL 00:02:29
que ya sabemos que 00:02:31
más o menos es una sintaxis parecida 00:02:33
al SQL, esa es la idea que 00:02:35
nos tiene que quedar, que es parecida al SQL 00:02:37
pero que trabaja con nombres de 00:02:39
clases en lugar de nombres de tablas y con 00:02:41
nombres de propiedades en lugar de nombres de campos 00:02:43
entonces más o menos con esas dos ideas 00:02:45
y con esas dos 00:02:47
ideas y con la sintaxis general 00:02:53
de cómo se crean, pues 00:02:55
uno ya puede ubicar 00:02:57
dónde tiene eso interés 00:02:58
Y si tiene que hacer una JPQL 00:03:00
Concreta de algo 00:03:02
Pues la busca y ya está 00:03:04
No nos vamos a prender el JPQL 00:03:05
Bueno, pues estos métodos de aquí 00:03:07
Estos de aquí 00:03:11
Como no implicaban modificar 00:03:16
La base de datos 00:03:18
No estaban en una transacción 00:03:19
Aunque si se pone, pues no pasa nada 00:03:22
Y ahora ya si que teníamos estos de aquí 00:03:24
Que eran los que habéis hecho vosotros 00:03:27
Hoy vais a hacer que si implican 00:03:28
Obligatoriamente una transacción 00:03:30
Obligatorio, JPA y Bernat en particular 00:03:32
Que es el que está debajo 00:03:34
Te obliga para que se modifique 00:03:35
La base de datos 00:03:38
Entonces aquí, pues por ejemplo habréis hecho 00:03:39
Algo 00:03:42
Parecido a esto 00:03:43
Suponemos 00:03:45
Pues el 00:03:47
El entity manager 00:03:49
Lo creamos aquí 00:03:51
Vale 00:03:56
Y ahora ya, pues crear un departamento 00:03:58
con empleados. Bueno, pues primero tendremos 00:04:02
que hacer el transitorio. 00:04:04
Departamento... 00:04:14
¿Eh? 00:04:14
Sí, bueno, lo que pasa es que la transacción 00:04:16
hasta el momento de 00:04:17
no empezar a hacerlo persistente no hace falta. 00:04:18
Pero bueno, sí, por orden, por organización, la puedo 00:04:21
hacer aquí y ya está. 00:04:23
¿Qué silencio? Bueno, ha vuelto. 00:04:30
Vale. 00:04:35
Entonces, ahora mismo este objeto, 00:04:35
pues vamos a crear un departamento 00:04:37
nombre de departamento 00:04:39
el que nos han pasado por parámetro 00:04:46
se supone, claro 00:04:48
departamento con empleados 00:04:49
y ahora, ¿qué más cosas tiene 00:04:51
el departamento? 00:04:54
tiene su 00:04:55
clave, pero la clave como es autoincrement 00:04:58
no la fijamos, ya la generará la base 00:05:00
de datos, y luego tiene su 00:05:02
lista de empleados, la lista de 00:05:04
empleados nos han pasado los nombres, pues vamos 00:05:06
a crear primero esa lista 00:05:08
vale, aquí como esta lista 00:05:09
esto en realidad 00:05:33
no tiene mayor trascendencia porque 00:05:36
para, pero bueno 00:05:37
como esta lista 00:05:40
en realidad solo la voy a usar 00:05:42
para crearla 00:05:44
y meter cosas en ella, luego se la doy a alguien 00:05:46
y me olvido, no voy a usarla para 00:05:48
navegar por ella ni consultar 00:05:50
pues a mi me sale 00:05:51
de forma natural hacer una lista enlazada 00:05:53
que ya sabéis que es 00:05:56
muy poco costosa 00:05:58
Para inserciones y borrados 00:05:59
Aunque mucho para consultas 00:06:01
Y aquí como lo que vamos a hacer 00:06:04
Va a ser insertar, insertar 00:06:06
¿Vale? Sin embargo ArrayList ya sabéis 00:06:07
Que es muy costosa 00:06:10
Para inserciones y borrados 00:06:12
Porque hay que deshacer y construir el Array 00:06:13
Pero muy ligera para consultas 00:06:15
Porque vas por índice y ya está 00:06:18
Bueno, pues aquí a mí me saldría un link 00:06:19
¿Vale? 00:06:21
Detallitos y cosas 00:06:24
Que si alguien 00:06:25
Se pone muy pejiguero 00:06:26
Alguna prueba técnica de Java 00:06:29
O lo que sea 00:06:31
Le vais soltando 00:06:32
Estas cosas y parece que sabéis un montón 00:06:35
Bueno 00:06:37
Pues todo esto para que era, para añadir los empleados 00:06:40
Pues 00:06:42
Empleados 00:06:44
A empleados le vamos a añadir 00:06:46
Los que me han dado 00:06:49
Empleados.add 00:06:50
New 00:06:52
Empleado 00:06:55
Y tengo un constructor por nombre 00:06:58
de empleado porque si lo tuviera 00:07:03
sería estupendo 00:07:04
yo iría recorriendo esto 00:07:06
menor que nombres 00:07:08
empleados 00:07:14
punto size 00:07:15
pues por cada nombre de empleado 00:07:21
me creo un objeto empleado y lo añado 00:07:27
entonces empleado no sé si tenía un constructor 00:07:29
solamente con nombre de 00:07:31
adelante, no lo tiene 00:07:32
pues se lo voy a poner 00:07:46
y así me ahorro líneas 00:07:47
luego en el, le voy a crear un 00:07:50
Constructor 00:07:52
Solamente con el nombre 00:07:53
Ahora 00:07:55
Si tengo un constructor solamente con el nombre 00:07:59
Lo voy a tener más fácil aquí 00:08:01
New empleado 00:08:03
Nombres 00:08:05
Empleados 00:08:07
Nombres empleados punto 00:08:10
Get i 00:08:18
Vale y 00:08:20
Con esto estoy 00:08:26
construyendo la lista 00:08:34
de los empleados y ahora ya una vez que la 00:08:36
tengo se la fijo al departamento 00:08:38
de .set 00:08:40
empleados, la lista que acabo de hacer 00:08:42
vale 00:08:44
ahora es cuando 00:08:46
voy a hacer persistente este objeto 00:08:48
departamento que era transitorio 00:08:50
su id tampoco lo he fijado porque el id era 00:08:52
autoincrement en la base de datos 00:08:54
entonces tampoco lo he fijado 00:08:55
entonces ahora es cuando yo lo haría 00:08:57
persistente, ahora ya sí que es importante que la 00:09:00
transacción esté arrancada 00:09:02
Creo que es lo que me vas a decir 00:09:03
Eso es lo que vamos a ver 00:09:06
¿Vale? 00:09:16
Vale, entonces, a ver, aquí 00:09:18
Uno podría pensar 00:09:20
Que la relación ya está construida 00:09:22
Porque 00:09:25
Si yo le he añadido 00:09:26
Si yo le he añadido al departamento 00:09:28
Los empleados 00:09:30
Ya la he construido a nivel de objeto 00:09:31
Entonces 00:09:34
si JPA y el hibernate 00:09:35
que hay por debajo están listos 00:09:38
y nosotros lo usamos 00:09:39
porque es listo y nos facilita la vida 00:09:42
pues él ya cuando haga las 00:09:44
inserciones correspondientes a esto 00:09:46
es decir, a lo que nos tocaría 00:09:48
hacer a nosotros es 00:09:50
el persis departamento 00:09:51
¿vale? 00:09:54
esto lo, bueno pues 00:09:56
aquí hay dos cosas, en esta sentencia 00:10:00
hay dos cosas 00:10:02
en esta de aquí, vale 00:10:03
Ay, perdón, la transacción, sí, sí 00:10:09
Que se me olvida todo 00:10:11
Vale, entonces 00:10:12
.bet 00:10:14
Transaction.commit 00:10:16
Porque si no, pues es como si no hubiera hecho nada 00:10:19
Vale 00:10:21
Bueno, pues aquí en esta sentencia hay dos cosas 00:10:22
Entonces se supone que JPA 00:10:25
Hibernate es para facilitarnos la vida 00:10:27
A la hora de hacer el CRUD 00:10:29
En cualquiera de sus 00:10:31
Variantes, inserciones, modificados 00:10:33
Entonces yo aquí 00:10:35
quiero hacer la inserción de un departamento 00:10:36
con un montón de empleados 00:10:38
entonces, al haber hecho esta sentencia 00:10:39
de aquí 00:10:42
al haber hecho esta 00:10:43
jodines 00:10:54
al haber hecho 00:10:55
pues al haber hecho esa sentencia de ahí 00:11:00
nosotros en el mundo 00:11:19
de los objetos, que es el único 00:11:21
que nos interesa a nosotros 00:11:23
ahora mismo desarrollando esta aplicación 00:11:24
en el mundo de los objetos ya está toda la relación especificada 00:11:26
tengo el departamento con sus datos 00:11:30
y mi departamento tiene aquí colgando su propiedad de empleado 00:11:32
con todos los empleados 00:11:37
con lo cual el empleado está ligado al departamento 00:11:39
porque cuelga de él en su propiedad lista 00:11:43
y el departamento está ligado a los empleados 00:11:45
entonces esa relación en el mundo de los objetos estaría completa 00:11:48
¿vale? 00:11:52
eso por un lado 00:11:54
Entonces nosotros podríamos pensar que JPA debería ser tan listo para decir, vale, ahora yo de esta sentencia, perdón, de esta sentencia de aquí, en la que tú me pides que convierta este objeto persistente, yo ya hago todos los SQL necesarios para hacerlo sin ser de los empleados. 00:11:55
como yo veo que empleado está colgando 00:12:13
de aquí, fijar 00:12:16
el id de departamento para que 00:12:17
apunte a este departamento que acabo 00:12:19
de insertar, todo eso debería 00:12:22
funcionar y hacerlo, porque si no 00:12:24
no están listos 00:12:25
vamos a verlo, vale 00:12:26
pero tendría sentido según la filosofía de 00:12:29
JPA que yo construyo mis objetos 00:12:31
y las relaciones entre mis 00:12:34
objetos vienen dadas porque unos están dentro 00:12:35
de otros, por ahí vienen dadas, porque unos están 00:12:37
dentro de otros 00:12:39
entonces, este 00:12:40
Es un problema que muchas veces 00:12:43
Causa errores 00:12:45
Porque no es así 00:12:47
Para JPA en todas las relaciones 00:12:48
Uno manda 00:12:51
Que es el que se llama el propietario 00:12:53
Y otro 00:12:55
Y otro es el seguidor 00:12:56
De alguna manera 00:13:01
Entonces 00:13:01
En una relación, ¿quién manda? 00:13:03
Para 00:13:07
Manda el lado del many 00:13:08
Siempre, el que tiene la clave ajena 00:13:10
su tabla, entonces en la relación 00:13:12
departamento a empleados 00:13:14
el propietario, el que manda es el empleado 00:13:16
¿vale? 00:13:19
el que manda, entonces 00:13:20
JPA convierte 00:13:22
los SQL 00:13:25
los tiene que hacer de tal manera 00:13:26
que arranquen desde 00:13:29
empleado, entonces 00:13:30
si yo aquí estoy arrancando desde departamento 00:13:32
esto no me va a funcionar, vamos a 00:13:34
comprobarlo ahora, ¿vale? vamos a comprobarlo 00:13:36
ahora, eso por un lado 00:13:38
Y ahora ya por otro lado 00:13:41
Imaginamos que eso 00:13:45
Entonces, ¿cómo arreglaríamos eso? 00:13:46
Con lo que me habéis dicho 00:13:48
Bueno, pues voy a fijar yo 00:13:49
En el empleado 00:13:52
Su departamento 00:13:54
¿Vale? Pero lo fijamos ahora 00:13:56
Cuando nos salga el error y veamos que no funciona 00:13:58
Y luego, por otro lado 00:14:00
Vamos a suponer 00:14:02
Que eso ya lo hemos arreglado 00:14:04
Y todo eso, por otro lado 00:14:06
El que yo haga la persistencia 00:14:07
Del objeto implica 00:14:10
Que hago la persistencia también 00:14:11
De todos los que cuelgan de él 00:14:13
Sí o no 00:14:14
O depende 00:14:17
Sí, no o depende 00:14:18
¿Cuál diríais de esas tres? 00:14:21
Es un 33,3% 00:14:22
¿Alguien dice otra cosa? 00:14:24
Diferente de no 00:14:32
Bueno, pues es la opción C 00:14:33
Depende 00:14:38
Depende del atributo cascade 00:14:39
¿Vale? 00:14:43
¿Recordáis que cuando hemos puesto anotaciones 00:14:45
aquí 00:14:47
claro, el atributo 00:14:49
cascade en la relación es el que te dice 00:14:52
cuando tú haces 00:14:54
una acción con un objeto 00:14:56
si esa acción se va a trasladar a los que 00:14:58
cuelgan de él, entonces por eso 00:15:00
el atributo cascade podía ser 00:15:02
cascade persist, cascade remove 00:15:03
cascade all 00:15:06
que es todo lo que tú hagas que se transmita 00:15:08
a los hijos, entonces vamos a ver 00:15:10
aquí en departamento que cascade teníamos 00:15:12
en departamento 00:15:14
en la relación que tiene con empleado 00:15:16
que es esta 00:15:19
perdón 00:15:20
teníamos este, con lo cual 00:15:22
si yo hago la persistencia del departamento 00:15:25
debería hacerse también 00:15:28
automáticamente en cascada 00:15:30
la de todos los empleados 00:15:32
que cuelgan de él, debería hacerse en cascada 00:15:34
¿vale? porque tengo puesto eso 00:15:36
si tengo cascada 00:15:38
de remove, pues recordad 00:15:42
que mencionamos que el cascada de remove 00:15:44
es el más peligroso, porque 00:15:45
si tú eliminas un objeto y el 00:15:47
cascade está en 00:15:49
cascade.remove, eliminas 00:15:51
todos los que colgan de él, entonces 00:15:53
aquí no es tan grave, eliminar un 00:15:56
departamento te pules a todos los empleados 00:15:59
no es tan grave, lo clave sería 00:16:01
si tienes el cascade 00:16:03
el cascade 00:16:05
aquí 00:16:08
aquí lo tenemos en la opción por defecto 00:16:11
que habría que ver cuál es 00:16:15
Seguro que no es el 00:16:16
All ni el remove 00:16:19
Porque aquí sí que sería grave poner un 00:16:20
Cascade type remove 00:16:23
Porque si borro el departamento 00:16:25
Perdón, si borro 00:16:27
El empleado 00:16:29
Si lo borro, pues borro el departamento 00:16:30
Que tira de él y eso es lo que no 00:16:34
Querría 00:16:35
Entonces, vamos a preguntarle 00:16:36
A este hombre 00:16:39
¿Vale? ¿Cuáles son los valores 00:16:41
Por defecto de 00:16:43
De los cascades 00:16:45
A ver, valores por defecto 00:16:47
Valores 00:16:52
Cascade type 00:16:54
Por curiosidad 00:17:01
¿Cómo que no? 00:17:05
Bueno, vale, o sea, por defecto es que no hay ninguna 00:17:12
Vale 00:17:15
O sea, por defecto en ninguna de ellas 00:17:15
Se hace el cascade 00:17:32
¿Vale? 00:17:34
Lo curioso es 00:17:36
Lo que sí es 00:17:37
Los curiosos son los valores por defecto 00:17:39
Del fetch type, estos sí que son un caos 00:17:41
El lazy, el no sé qué 00:17:43
Depende 00:17:52
De la relación 00:17:55
De la one to one 00:17:57
Es el eager, o sea, si tienes una relación de uno a uno 00:17:59
Te lo va a cargar siempre, por defecto 00:18:02
A menos que te especifiques que no 00:18:04
Y de many to one 00:18:05
También 00:18:08
Es decir, en el empleado 00:18:10
Te carga siempre su departamento 00:18:13
Siempre, a menos que tú digas lo contrario 00:18:15
Porque claro, esta es menos pesada, es cargar un departamento 00:18:17
Pero en la one to many 00:18:19
Tiene sentido que esta sea por 00:18:21
Estas dos 00:18:23
Que tiran de muchos 00:18:24
Tiene sentido que por defecto sean lazy 00:18:26
Porque estas tiran de muchos, tendrían que cargar muchos 00:18:29
¿Vale? 00:18:31
Y esto no sé lo que es, así que da igual 00:18:33
¿Vale? 00:18:35
Bueno, pues 00:18:39
Entonces, ya sabemos que 00:18:40
Si no especificamos el elemento cascada de time 00:18:43
No se va a propagar nada 00:18:45
Si queremos que se propaga alguna cosa 00:18:46
La tenemos que hacer específicamente 00:18:48
Bueno, pues volvemos a nuestro servicio 00:18:50
Este de aquí 00:18:53
Tendríamos que hacerles persistencia 00:18:53
Uno por uno 00:19:00
Es decir, en este for de aquí 00:19:01
En lugar de ponerlo con una referencia anónima 00:19:03
Pues le damos una referencia 00:19:06
Y le hacemos el persist y ya está 00:19:08
¿Vale? 00:19:10
Y luego ya hacemos el persist del departamento 00:19:11
¿Vale? 00:19:14
Bueno, pues vamos a probar esto a ver qué nos hace. Entonces, teníamos aquí ya un main2, imagino, en el que probábamos los nuevos. Vale, entonces, los que habíamos hecho estos de aquí no se habían funcionado, supongo, porque están aquí probados. 00:19:15
Y ahora vamos a empresaservice.crearDepartamentoConEmpleados. 00:19:42
A ver, ¿dónde está este? 00:19:55
Departamento, casas, ventas, departamento, coches. 00:20:08
Que echáis de menos los coches, seguro. 00:20:13
El departamento de coches. 00:20:18
Y aquí 00:20:22
Tenemos que pasar la lista de empleados 00:20:25
Pues venga 00:20:28
No, de empleado no, de string 00:20:29
Perdón, aquí van los nombres 00:21:06
Bueno, voy a hacer un array, lo convierto a lista y se acabó 00:21:07
Si hay formas mucho más cómodas 00:21:13
Y ahora 00:21:17
Empleados 00:21:42
Lo podré pasar a una lista 00:21:45
¿No? 00:21:47
Listo 00:21:48
De empleados 00:21:51
Dos 00:21:56
Por ejemplo, vale 00:21:58
Y aquí que he hecho mal 00:22:03
Que 00:22:06
Esto, ¿verdad? 00:22:06
He hecho mal, eso, ahora sí 00:22:11
Vale 00:22:13
Ya está, vamos a ver si esto 00:22:14
Se crea, este caso de uso 00:22:20
No funciona, vale 00:22:22
Entonces, nos sale 00:22:33
Hemos 00:22:35
Vale, pues justo 00:22:38
El error que nos esperábamos 00:22:41
él ya ha anunciado, ¿vale? Cuando él trata de insertar a los empleados, te dice, oye, yo no resuelvo por mí mismo el ID de departamento, 00:22:44
que ya podría, ¿no? Jolín, ya podría, pero si dentro de este caso de uso ya hemos metido el empleado dentro del departamento, 00:22:54
pues realmente ya podría 00:23:03
pero no, alguna manera algunas reglas 00:23:05
y como el empleado es el dueño 00:23:08
de la relación 00:23:10
pues 00:23:11
el campo ID de departamento 00:23:12
que es específico suyo y que hay que hacer 00:23:16
con su propio insert, hay que fijárselo 00:23:18
no lo vamos a resolver a través del otro 00:23:20
entonces 00:23:22
esto 00:23:24
lo arreglamos 00:23:26
sin problema pues 00:23:28
aquí creamos el empleado 00:23:30
aparte y le fijamos 00:23:35
el departamento 00:23:37
entonces 00:23:39
empleado e 00:23:40
y ahora ya le hacemos 00:23:44
que e.set 00:23:56
departamento este que acabamos 00:23:58
de crear y ahora aquí 00:24:00
añadimos el e 00:24:02
esto 00:24:04
vale 00:24:12
Esto se suele resolver 00:24:16
Como esto es muy pesado 00:24:18
El acordarse, entre comillas 00:24:19
Es muy pesado el acordarse 00:24:24
Porque es una acción natural 00:24:25
Un caso de uso natural de cualquier aplicación 00:24:27
En el que hay un objeto que tiene muchos otros colgando 00:24:30
Un caso de uso natural es añadirle algo 00:24:32
Entonces como es muy pesado 00:24:34
Pues acordarse 00:24:36
Que hay que fijar la clave y todo esto 00:24:38
Esto se suele resolver normalmente 00:24:39
Poniendo ya un método 00:24:42
En la propia clase de departamento 00:24:44
¿Vale? 00:24:46
Entonces, podríamos poner un método en la propia clase de departamento para añadir empleado. 00:24:48
Entonces, en la propia clase de departamento que está aquí, cuando uno ve que tiene algo aquí colgando, 00:24:54
una colección colgando, automáticamente ya ve que aquí hay una clave ajena, ve uno a muchos. 00:25:01
Entonces, si es de uno a muchos, el propietario es la otra. 00:25:08
Entonces, la otra tiene un campo que hay que fijar directamente desde la otra clase. 00:25:11
No se puede desde aquí 00:25:17
Entonces 00:25:18
Identificando eso se suele 00:25:20
Añadir ya un método 00:25:23
Para añadir empleado 00:25:26
Que te mete eso 00:25:34
Empleado E 00:25:35
Y aquí 00:25:39
A E se le fija 00:25:41
El departamento 00:25:44
Este, el dis 00:25:46
Y ahora ya 00:25:48
a empleados.ad 00:25:49
¿vale? 00:25:57
entonces con este método ya 00:26:06
resolveríamos esto 00:26:08
entonces 00:26:11
lo digo porque es un método típico 00:26:12
en una clase en la que uno identifica 00:26:15
esto, que tiene una relación de uno a muchos 00:26:17
pues añadir este método 00:26:19
que pum, se asegura 00:26:21
de que no te olvidas 00:26:23
de fijar esta parte de aquí 00:26:25
pero bueno 00:26:27
con JP hay tropecientas mil 00:26:30
pequeñas casuísticas distintas 00:26:33
que se pueden dar, pero conociendo la base 00:26:35
que ya la sabéis 00:26:37
objetos que mapean 00:26:39
o clases que mapean tablas 00:26:41
a partir de ahí pues ya es ir probando 00:26:43
voy fijando propiedades 00:26:46
me dice que me falta esta cosa 00:26:47
no tiene más que luego 00:26:49
ir explorando las diferentes casuísticas 00:26:51
raras que pueden salir 00:26:53
Entonces 00:26:54
Vale 00:26:56
Con este método ad empleado 00:26:59
Ahora ya nuestro 00:27:01
Caso de uso 00:27:03
Este de aquí 00:27:05
Pues esto se quedaría 00:27:06
Para cada empleado 00:27:12
Voy a añadirselo al 00:27:13
Este 00:27:15
Vale 00:27:17
Voy creando los empleados 00:27:18
Y se los añado al departamento 00:27:21
Creo el empleado y se lo añado al departamento 00:27:23
Y me olvido ya del 00:27:26
Matiz, entonces 00:27:27
Vamos a ponerlo aquí, como subiremos 00:27:31
Esto, vamos a ponerlo aquí 00:27:33
La lista que tenía 00:27:35
Donde aquí 00:27:41
De atempleado E 00:27:44
Esta 00:27:46
Esto de aquí, esta me sobra 00:27:48
Y esto de aquí me sobra 00:27:51
¿Vale? O sea, esto me sobra 00:27:52
Y esto me sobraría 00:27:55
Porque se lo voy añadiendo ya aquí directamente 00:27:56
¿Vale? 00:27:59
Entonces, apartamento para que se fije el campo clave ajena desde el empleado, 00:28:01
Que es el propietario 00:28:41
De la relación 00:28:46
Vale 00:28:48
Este es un ejemplito 00:28:50
Repito, de millones de pequeñas 00:28:52
Situaciones que se dan 00:28:54
Y uno pues va resolviendo sobre la marcha 00:28:56
Es un pequeño ejemplo, pero estos son un poco 00:28:58
Los más típicos, vale 00:29:00
Por eso pues los sacamos aquí, por eso son un poco 00:29:02
Los más típicos y los 00:29:03
Básicos para tener una visión de JPA 00:29:05
También es cierto que JPA 00:29:08
recordad que es una capa por encima del hibernate puro 00:29:09
que a su vez JPA es una subcapa de luego Spring Data JPA 00:29:12
entonces JPA pone reglas un poquito más estrictas 00:29:19
que el hibernate puro 00:29:24
si usáramos hibernate puro 00:29:26
que si nos da tiempo al final 00:29:27
pues en 5, 10, 15 minutos podemos verlo 00:29:31
por curiosidad 00:29:34
el hibernate puro traga mucho 00:29:35
y con muchísima facilidad 00:29:38
es mucho más flexible 00:29:39
cuando le ponemos la especificación JPA por encima 00:29:41
para ya usar 00:29:44
los métodos de JPA 00:29:46
las reglas son más estrictas 00:29:47
y tiene sentido, porque JPA lo que trata 00:29:50
de dar es una especie de 00:29:52
paraguas que unifique 00:29:53
la forma de desarrollar de todos 00:29:55
entonces tiene sentido que fija unas reglas un poco más estrictas 00:29:57
vale, pues entonces 00:30:00
ahora ya sí que vamos a probarlo 00:30:05
A ver si hay algo 00:30:06
Por ahí todavía en la que lo hayamos 00:30:08
Cagado, que intuyo que sí 00:30:10
Intuyo que hay algo más 00:30:12
Todavía que 00:30:14
En la que lo vamos a haber cagado 00:30:15
Mi intuición 00:30:18
Era cierta 00:30:31
¿No os estaba escamando mucho 00:30:32
Algo a vosotros cuando yo lo estaba escribiendo? 00:30:34
Pues a mí no 00:30:38
Claro 00:30:38
Pero por qué 00:30:40
Claro, a vosotros os lo ha cogido 00:30:41
Pero porque igual vosotros tenéis 00:30:44
Inicializado esta 00:30:46
Yo no la tenía 00:30:48
¿Vale? 00:30:50
¿Eh? 00:30:54
Que tú tampoco la tenías inicializada 00:30:58
Y si te lo ha cogido 00:31:00
Pues no sé cuál es la diferencia 00:31:01
Pero yo según estaba añadiendo esto 00:31:05
Estaba pensando, lógicamente 00:31:08
Cuando haga la 00:31:10
Añada el primer empleado 00:31:11
Esto va a saltar un grupo interseptio 00:31:13
Pero bueno, lo he dejado así 00:31:16
Para 00:31:17
Entonces 00:31:18
¿Dónde te refieres? 00:31:22
En el link en list 00:31:42
A ver 00:31:45
Sería cuestión de verlo 00:31:48
Yo es que 00:31:52
Me sale siempre de forma natural esta 00:31:52
Porque me gusta más 00:31:55
no sé, me gusta más 00:31:56
es más flexible en el sentido 00:31:58
de que la implementación 00:32:00
linked list te habilita 00:32:02
todos los métodos de pilas, colas, listas 00:32:04
por ejemplo, que la implementación de ArrayList 00:32:06
no, entonces pues yo le tengo 00:32:08
a esa especial 00:32:10
especial querencia 00:32:11
aquí en particular la he puesto por eso 00:32:15
no porque 00:32:17
porque realmente no sé 00:32:19
el uso que luego va a hacer la aplicación 00:32:21
de esta lista, en este punto no lo puedo saber 00:32:24
entonces pues no lo sé 00:32:25
Por defecto yo que sé, cada uno tendrá su 00:32:29
Realmente no sé si hay una 00:32:32
Vale, perdonad que le pregunte tanto 00:32:34
Pero es que yo creo que todas las cosas 00:32:42
Que nos dice nos aportan en general 00:32:44
A ver si nos da 00:32:47
En general 00:32:57
A ver si nos dice algo interesante que se nos 00:32:58
Puede escapar a nosotros 00:33:03
Vaya hombre, pues 00:33:05
No lo sé, a mí siempre me gusta el otro, no sé por qué 00:33:09
Pues mira 00:33:14
Es verdad que el acceso es más rápido 00:33:17
Y bueno, mejor uso de caché 00:33:21
Pues ya está, pues nada 00:33:23
Si él lo dice, pues supongo que tendrá razón 00:33:25
Vale 00:33:29
Bueno, pues entonces 00:33:33
Vamos a volver a probar esto 00:33:35
A ver, lo que salga ahora ya no me lo espero 00:33:36
Menos mal, que no ha salido ningún error 00:33:46
Porque no me lo esperaba 00:33:49
Y sí, tiene toda la pinta de que 00:33:51
El cascá de Persis lo ha hecho 00:33:53
Porque aquí hay un montón de inserts de empleados 00:33:55
Hay tres inserts de empleados 00:33:58
Y un insert de departamento 00:33:59
Así que todo perfecto y magnífico 00:34:01
Vale 00:34:04
Aquí están los 00:34:06
Aquí está el nuevo departamento de coches 00:34:08
Y aquí están 00:34:13
Los empleados 00:34:17
Entonces realmente 00:34:18
Es muchísimo más cómodo 00:34:23
Trabajar con un ORM 00:34:25
Que con JDBC 00:34:27
Que tener que hacer los SQL 00:34:29
De todo 00:34:31
es mucho más cómodo 00:34:32
eso sí, tiene un montón de peso 00:34:35
por debajo, tarda un huevo 00:34:37
es mucho más pesado, pero bueno 00:34:38
a ver, siguiente y último 00:34:40
método de esta aplicación 00:34:43
trasladar un empleado 00:34:45
de un sitio a otro 00:34:49
este 00:34:51
lo habéis hecho, os ha salido 00:34:52
no os ha salido 00:34:55
bueno, pues 00:34:55
yo esto lo enfocaría 00:35:00
trasladar empleado, pues cogería el empleado 00:35:02
Cogería el departamento y haría el set 00:35:05
Del departamento del empleado y ya está 00:35:07
Vamos a ver 00:35:08
Cogemos esto 00:35:10
Y ahora 00:35:16
¿Qué necesito? 00:35:22
El empleado, pues venga 00:35:24
Y el empleado lo cojo 00:35:26
Del 00:35:32
Del genérico 00:35:37
De implementación DAO 00:35:40
Porque es un GET 00:35:41
Entonces lo puedo coger 00:35:42
Me voy a hacer el implementación DAO 00:35:44
Voy a copiar de aquí arriba 00:35:47
Este, pero que va a ser de empleado 00:35:50
Sí, voy a necesitar los dos, tienes razón 00:35:58
Vale 00:36:04
Voy a necesitar los dos, pues este 00:36:05
Y este 00:36:08
Pero este va a ser de 00:36:10
Empleado 00:36:12
Y esto va a ser 00:36:14
Empleado 00:36:18
Vale 00:36:21
Dao 00:36:22
De departamento 00:36:23
Y dao de empleado 00:36:25
Vale, y ahora ya sí que sí 00:36:28
Me cojo el empleado 00:36:31
A través del suyo 00:36:33
Con get 00:36:35
Empleado id 00:36:37
Empleado id 00:36:39
Me cojo el departamento 00:36:44
De a través del suyo 00:36:51
Que es dao 00:36:54
departamento get 00:36:56
nuevo departamento idea 00:36:59
vale, entonces la relación es doble, es bidireccional 00:37:03
lógicamente, en una relación bidireccional 00:37:14
las modificaciones nos ponemos en el chip de hacerla 00:37:17
siempre desde el lado propietario, desde el lado propietario 00:37:22
que en este caso es el empleado, pues al empleado le fijo como departamento 00:37:26
Ese, y ya está 00:37:30
E.set departamento 00:37:32
Este de aquí 00:37:34
Y ahora 00:37:35
Si yo hago un commit 00:37:39
Pues ya debería 00:37:42
Esto hacerse 00:37:45
O eso creo 00:37:46
No, porque aquí 00:37:51
El empleado manda 00:38:05
Es el propietario, entonces él sí que va a generar 00:38:07
Todos los SQL 00:38:09
que se deriven de ese 00:38:10
en el lado inverso es donde no se van a 00:38:12
generar todos los que se derivan, por eso 00:38:15
cuando hemos hecho el persis de departamento antes 00:38:17
que lo teníamos que hacer porque el departamento 00:38:19
había que meterlo, de ese 00:38:21
no se iba a derivar 00:38:23
la modificación del empleado 00:38:25
del ID departamento 00:38:27
entonces, creemos que esto está bien 00:38:28
vale, pues 00:38:32
vamos a 00:38:38
probarlo en nuestro 00:38:40
main2 00:38:42
y ahora 00:38:43
Yo voy a trasladar 00:39:01
Al 1 que está en el 15 00:39:03
Lo voy a trasladar al 1 00:39:09
Entonces voy a poner 1, 1 00:39:11
A ver si en esta primera línea 00:39:13
Me aparece 1, 1 00:39:14
Vamos a ver 00:39:16
1, 1 00:39:17
Dime 00:39:19
¿Puedes poner el método otra vez? 00:39:23
Uy, ¿dónde está? 00:39:26
Este es 00:39:31
Polina, ahora sí que está lloviendo 00:39:33
¿Cómo estáis tan desanimados? 00:39:37
Con la clase 00:39:47
Estamos aquí bajo mínimos 00:39:49
¿Es normal? 00:39:51
¿Tan poca asistencia? 00:39:53
Mejor más silencio 00:39:55
Bueno, vamos a ver 00:39:56
A ejecutarlo, a ver 00:39:59
A ver 00:40:01
Era demasiado bonito 00:40:03
Vale, ¿qué se nos ha olvidado aquí? 00:40:11
Ah, bueno 00:40:14
Constructor por defecto 00:40:15
Ah, esto es fácil de arreglar 00:40:17
Vale, el constructor por defecto de empleado 00:40:18
Ah, claro, es que al haber puesto yo uno 00:40:21
Así, he deshabilitado 00:40:24
El otro, que lista, yo 00:40:26
Entonces, claro, claro 00:40:27
He creado este y me lo he cagado con el otro 00:40:32
Vale 00:40:34
Siguiente problema 00:40:36
Vamos a ver si hay más problemas o no 00:40:38
Estoy por dar el verde 00:40:40
Porque estoy segura de que te da mucha rabia, Dani 00:40:42
Cuando hago esto específicamente 00:40:44
¿Verdad? Y no le doy al verde, ¿no? 00:40:46
Venga 00:40:49
Vale, pues ya está 00:40:50
tiene pinta de que sí, de que ha actualizado 00:40:55
el empleado efectivamente poniendo el ID2 00:40:58
y ha hecho su select antes 00:41:00
entonces no haría falta ni comprobarlo 00:41:02
pero 00:41:04
lo ha hecho 00:41:05
vale, pues esta es más o menos la idea 00:41:07
os voy a dar 00:41:12
otra base de datos, esta un poquito 00:41:14
más compleja, con más tablas 00:41:16
que tenga los tres tipos 00:41:18
de relaciones que hay, que aquí solamente 00:41:20
hemos visto la de uno a muchos o muchos a uno 00:41:22
que tenga también uno a uno 00:41:24
y muchos a muchos, porque la de muchos a muchos 00:41:26
no es trivial, como se mapea 00:41:28
se puede hacer de diferentes maneras 00:41:30
¿vale? entonces vamos a 00:41:32
aprovechar el cambio para subir el script 00:41:34
al aula virtual, que creo que no 00:41:36
lo subí ayer 00:41:38
y ahora 00:41:40
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:
1
Fecha:
27 de enero de 2026 - 13:01
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
41′ 45″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
191.34 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid