Saltar navegación

20260226 Repaso_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 3 de marzo de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues entonces 00:00:00
¿Qué? 00:00:01
Esta va a ser muy cortita, tenía que haber pausado 00:00:05
Y se me ha olvidado 00:00:07
Vale, pues ya está, y nos hicimos este 00:00:08
Que nos creaba 00:00:11
El entity manager 00:00:16
Y ya está, ¿vale? 00:00:17
El entity manager no es el singleton 00:00:19
Es aparece y desaparece, el que lo es es este 00:00:21
Este sí 00:00:23
El factor 00:00:25
Vale, pues ya está 00:00:27
Entonces, nuestro JPA utilera este y ahora, ahora aquí la importancia está en dos sitios, en el modelo y en el DAO, porque ahí tenemos que hacerlo nosotros, no nos lo da Spring, ¿vale? 00:00:28
entonces, en el modelo 00:00:50
pues el modelo ya bien hecho, vamos a revisarlo 00:00:53
porque con este revisamos más o menos todas las 00:00:55
anotaciones que hemos visto 00:00:57
la entidad sede 00:00:58
pues bueno, la entidad sede 00:01:00
estas 00:01:03
anotaciones, no las sabemos de memoria 00:01:05
¿vale? una por tabla 00:01:06
las sabemos de memoria 00:01:09
clave primaria 00:01:10
clave primaria id 00:01:11
si es autoincrement 00:01:13
y si hay algún cambio que queramos 00:01:16
modificar, si hay algún cambio que queramos 00:01:18
modificar en esa propiedad 00:01:20
o columna, anotación 00:01:23
column, en este caso 00:01:24
el nombre porque en SQL 00:01:27
se estilan mucho las barras 00:01:28
bajas y en Java no, entonces 00:01:30
pues ahí 00:01:32
vale 00:01:33
esto lo mismo, column 00:01:36
claro, si puede ser nulo o no puede ser 00:01:38
nul, pero bueno, estas cosas están así 00:01:45
puestas porque 00:01:47
que es la que te ofrece esa cacha GPT y al no quitarlas, 00:01:48
es interesante así que las veamos, ¿vale? 00:01:54
Esto lo podríamos quitar directamente, no os da igual. 00:01:56
El tamaño, claro, el tamaño que fija para la columna. 00:02:00
Vale, ahora ya sí, la sede tiene, ¿vale? 00:02:03
La sede tiene un montón de departamentos gracias a esta clave ajena. 00:02:08
Entonces, al tener un montón de departamentos, 00:02:12
una sede, muchos departamentos, 00:02:14
aquí es donde tendremos 00:02:16
una lista 00:02:18
o conjunto de proyectos 00:02:21
¿por qué lo he cambiado 00:02:23
yo a conjuntos? luego lo vamos a entender 00:02:25
porque lo he cambiado a conjuntos 00:02:27
¿vale? pero podría ser una lista 00:02:29
da igual 00:02:31
entonces, como esto viene 00:02:31
de que hay una clave ajena de departamento 00:02:35
a sede, pues one to many 00:02:37
¿dónde se indica el 00:02:38
campo 00:02:41
que 00:02:41
representa la clave ajena? 00:02:43
se indica en la entidad correspondiente a la tabla donde está la clave ajena. 00:02:46
En este caso es, estoy aquí arriba, perdón, estoy aquí, es en departamento donde está la clave ajena. 00:02:52
Pues entonces decimos, oye, cuidado, que el campo columna que es la clave ajena de la que tienes que tirar 00:03:00
se mapea en la propiedad sede de la clase departamento, que es donde se tiene que mapear, 00:03:07
en la propietaria de la relación 00:03:14
en la entidad 00:03:17
a partir de la cual se pueden hacer modificaciones 00:03:19
etcétera, y ya está 00:03:21
esto era el one to many 00:03:23
claro, esto significa que 00:03:24
automáticamente en la clase de departamento 00:03:29
tiene que haber una propiedad 00:03:31
sede, tiene que haberla 00:03:33
y ahí tiene que estar especificada la clave 00:03:34
ajena, la hay, vamos a ver 00:03:37
pues 00:03:38
si la hay 00:03:40
hay una propiedad sede 00:03:43
en la clase departamento 00:03:46
y justo en ella 00:03:47
se está indicando ahora ya sí 00:03:49
cuál es la clave ajena 00:03:52
mediante el yo en columna, ¿vale? 00:03:53
Aquí es donde se indica. 00:03:55
Es esto, tal cual. 00:03:59
Este nombrecito. 00:04:01
No, este es este. 00:04:07
Este es este. 00:04:09
Este de aquí. 00:04:11
y de sede, la clave ajena 00:04:12
el que solo sede es 00:04:14
claro, el que solo sede 00:04:19
este de aquí 00:04:22
esto es el nombre 00:04:23
de la propiedad 00:04:27
dentro de la clase 00:04:28
esta de aquí 00:04:30
en esta clase tiene que haber una propiedad 00:04:31
con este nombre 00:04:35
vale 00:04:35
vale 00:04:37
vale, entonces cascada 00:04:39
pues ya sabéis que esto 00:04:42
las propiedades estas, pues bueno, estas si que 00:04:44
no es el objetivo 00:04:46
tampoco de nuestra evaluación 00:04:48
el que os hagáis de memoria estas propiedades 00:04:51
pero nos suenan, sabemos lo que significan 00:04:52
entonces como nos suenan 00:04:55
podría ocurrir 00:04:57
que a lo mejor alguna cosa 00:04:59
no esté funcionando como debería 00:05:00
porque a lo mejor alguna de estas cosas 00:05:02
no es como apuestan en el curso de cascada 00:05:04
ya sabéis que significa 00:05:06
cascada que es, cuando yo hago 00:05:08
una operación en sede 00:05:10
si esa operación 00:05:13
se transmite a 00:05:14
departamento o no 00:05:16
aquí como es all, se transmite 00:05:17
todo, si hago un persist 00:05:20
un save, un 00:05:22
remove, se transmite todo 00:05:24
pero entonces 00:05:26
dentro del departamento, dentro del proyecto sede 00:05:27
tiene que haber una variable sede 00:05:30
dentro del departamento tiene que haber una variable 00:05:32
que se llame sede y aquí también 00:05:34
dentro del proyecto sede tiene que haber una que se llame sede 00:05:36
Se va a mapear siempre el extremo de many, es decir, se va a mapear en la entidad correspondiente a la tabla que tenga la clave ajena. 00:05:38
Es decir, aquí es departamento quien tiene la clave ajena y de sede. 00:05:55
Y aquí proyecto sede es quien tiene la clave ajena y de sede a sede. 00:06:00
Con lo cual será en la entidad departamento y en la entidad proyecto sede donde se indica cuál es la columna. Por eso aquí hay un MAPED BY, esto está mapeado en departamento, la propiedad sede. Y aquí hay un MAPED BY, esto está mapeado en proyecto sede, en la propiedad sede. Ahí está. 00:06:05
Claro, pero la propiedad sede tiene su id sede 00:06:26
Entonces, ¿por qué? 00:06:28
La propiedad sede es la propiedad sede 00:06:30
O sea, id sede luego lo tiene 00:06:32
La entidad sede 00:06:33
Proyecto sede tiene su 00:06:35
Proyecto sede 00:06:40
Tiene su propiedad 00:06:41
Sede, que es 00:06:44
Esta 00:06:46
Tiene su propiedad sede que te dice 00:06:47
La clave ajena, ¿cuál es? 00:06:50
Tiene ahí 00:06:54
¿Vale? Ahora vamos 00:06:54
¿Vale? Si esto al final son cuatro 00:06:58
cosas, son cuatro cosas y lo mismo 00:07:00
todo el rato 00:07:02
no, porque 00:07:03
es que no tenemos 00:07:08
tiempo, pero 00:07:10
vale, pero el 00:07:11
claro, pero 00:07:14
bueno, ahora cuando lleguemos al 00:07:16
claro, porque 00:07:18
hay una entidad intermedia 00:07:20
pero podría no haberla, ahora cuando vayamos a ella 00:07:22
mencionamos ese caso, vale 00:07:24
no, no, no 00:07:26
porque no hemos hecho ningún ejemplo por falta 00:07:28
de tiempo, lo ideal habría sido que 00:07:30
tuviéramos tenido tiempo para hacer 00:07:32
muchos ejemplos con diferentes bases de datos 00:07:34
diferentes tablas, diferentes cosas 00:07:36
pero bueno, sabéis de que va el rollo y ya está 00:07:38
ahora de todas formas mencionamos 00:07:40
como sería ese caso cuando 00:07:42
estemos ya en proyecto sede, entonces 00:07:44
las anotaciones de sede 00:07:46
pues están claras, el one to many 00:07:48
porque lo hemos puesto aquí 00:07:50
y las propiedades que tiene 00:07:51
este era, oye 00:07:53
que pasa si se queda 00:07:56
alguno de estos 00:07:58
si alguno de estos objetos 00:08:00
departamentos resulta 00:08:02
que ha perdido la sede a la que 00:08:05
pertenece, porque esa sede 00:08:06
ha dejado de ser persistente, ¿qué pasa 00:08:08
con ese departamento? Pues el 00:08:10
true significa fuera al departamento. 00:08:12
¿Vale? 00:08:15
Se elimina. 00:08:16
Pero el cascade, si tú haces específicamente 00:08:19
un remove al departamento, 00:08:22
pero el departamento puede haber desaparecido 00:08:25
por otras razones. 00:08:26
Puede haber 00:08:29
O sea, perdón, la sede 00:08:29
Claro, la sede puede haber desaparecido 00:08:32
De la aplicación por otras razones 00:08:36
Puede haberse quedado sin referencia 00:08:37
Por otras cosas propias de Java 00:08:39
Que no sean específicamente por hacer 00:08:40
Una sentencia con el entity manager 00:08:43
O sea, el cascade significa 00:08:45
Cómo se 00:08:47
Si tú haces un 00:08:48
Si el entity manager hace una sentencia 00:08:50
Sobre la sede 00:08:53
Si esa misma sentencia se traslada al departamento 00:08:54
si es la misma sentencia 00:08:57
y Orphan Removal 00:08:59
en particular en remove 00:09:01
si tú haces remove de la sede 00:09:02
se hace en remove del departamento 00:09:04
y esto es algo más amplio 00:09:06
es decir, si la sede ha desaparecido 00:09:08
por la razón que sea 00:09:10
por razones de Java 00:09:12
no tiene que ser porque el entity manager la haya hecho 00:09:14
pues si ha desaparecido, ¿qué pasa con el departamento? 00:09:16
que se ha quedado ahí 00:09:19
por ejemplo, el cascabel puede ser 00:09:20
que si 00:09:22
tú cambias el ID de la sede 00:09:23
ese cambio en todos los abanicos 00:09:26
tú nunca cambiarías una idea de una sede 00:09:27
jamás 00:09:30
por ejemplo poner un mes así 00:09:31
pues un ejemplo horrible 00:09:33
nunca toques claves primarias, por dios 00:09:35
nunca 00:09:37
pues cambias una 00:09:38
segundo de la sede 00:09:40
no, si no, a ver no 00:09:44
si tú cambias algo de la sede, cambia algo de la sede 00:09:46
vamos a, si tú eliminas 00:09:48
la sede, pues eliminas todos los departamentos 00:09:50
que cuelgan de ella 00:09:52
haces persistente una sede, pues haces 00:09:53
persistente también en todos los departamentos 00:09:56
que colgan de ella, eso es lo que significa 00:09:58
pero bueno, no te enredes mucho en ello tampoco 00:10:00
pero, pero entendida 00:10:01
la idea, ¿no? 00:10:04
vale, pues estas 00:10:09
dos estarían y ya no hay más anotaciones en sede 00:10:11
entonces vamos a las 00:10:13
otras sencillitas que serían 00:10:14
departamento lo mismo, no tiene 00:10:16
nada distinto, clave 00:10:18
primaria, entonces 00:10:20
departamento es el otro extremo de la sede 00:10:22
por eso tiene el many to one 00:10:25
¿vale? entonces como tiene el many to one 00:10:26
el many to one tiene que tener 00:10:28
ahí así el join column 00:10:30
que diga cuál es el campo de la tabla 00:10:31
que ejerce de clave ajena 00:10:34
¿vale? 00:10:35
que si 00:10:39
un many to one es el extremo 00:10:40
de un one to many 00:10:42
entonces 00:10:43
aquí sí que tiene 00:10:45
que acompañar ya la información 00:10:48
de cuál es el campo clave ajena 00:10:50
de la tabla 00:10:52
no, no, lo puedes poner en el getter 00:10:53
Todo esto lo puedes poner en el getter 00:10:58
¿Vale? 00:11:00
Sí, lo puedes poner en el getter 00:11:01
Vale 00:11:04
Entonces aquí ese es el campo clave ajena 00:11:05
Y luego está 00:11:08
La que sí que 00:11:09
Tiene un poco más de trascendencia 00:11:11
Y nos hemos enfrentado un poquito más a ella 00:11:14
Siempre que tenemos 00:11:16
Un objeto o una colección 00:11:18
Que se carga a través de un join 00:11:20
Que esta se va a cargar a través de un join 00:11:22
Porque viene con una clave ajena 00:11:25
Pues o lazy o eager 00:11:26
¿Dejamos la opción por defecto? 00:11:28
Pues en esta por defecto es el líder 00:11:31
Cuando tenemos una colección 00:11:33
Por defecto es Lazy 00:11:36
¿Vale? 00:11:37
¿Que queremos ponerla específica Lazy? 00:11:38
Pues lo ponemos, que no nada 00:11:41
Aquí por ejemplo en sede 00:11:42
No se la hemos puesto 00:11:44
Porque por defecto ya es Lazy, ¿verdad? 00:11:46
Sí, un HASHET 00:11:53
¿Vale? Que he implementado ya 00:11:55
He implementado ya, podrían haberlo puesto 00:11:56
Y no pasa nada, todo funciona 00:11:59
pero bueno, lo he puesto 00:12:00
para asegurarme 00:12:02
de que no va a haber null pointer exception extraños 00:12:04
por ahí 00:12:06
pero claro, todo tiene su precio 00:12:06
en realidad, todo tiene su coste 00:12:10
por la tranquilidad 00:12:12
de no haber un null pointer exception 00:12:14
pero ¿qué coste? 00:12:15
comprometer la implementación 00:12:18
¿vale? comprometerla 00:12:20
¿vela? vale 00:12:22
cuando es una colección entonces 00:12:23
por efecto es lazy 00:12:25
cuando es una colección por efecto es lazy 00:12:26
Cuando es un único objeto, porque es el many to one, por defecto es eager, ¿vale? 00:12:29
Bueno, pues entonces departamento, pues estas de aquí, que no tienen nada. 00:12:34
Departamento a su vez tiene lista de empleados, one to many, todo igual, ya está. 00:12:38
Aquí empleado. 00:12:43
Empleado, pues nada, empleado no tiene nada. 00:12:46
Muchos departamentos, perdón, un empleado, un departamento, por eso este es el extremo many to one, 00:12:50
con la columna y de departamento, esta no tiene nada raro 00:12:57
y ahora ya la relación esta, que esta es la más rara 00:13:00
de mapear, la relación de muchos a muchos 00:13:05
que es esta de aquí, la relación de muchos 00:13:09
a muchos es la de estas tres tablas, ¿vale? 00:13:13
Entonces, la relación de muchos a muchos 00:13:18
en SQL ya sabéis que es a través 00:13:21
de una tabla aparte 00:13:25
pero puede ocurrir 00:13:27
que no haya información 00:13:29
más allá de la relación 00:13:31
que no la haya 00:13:33
no es el caso de este 00:13:34
entonces 00:13:37
cuando no es el caso 00:13:39
es decir, cuando sí que hay 00:13:41
cuando sí que hay 00:13:43
propiedades 00:13:45
que caracterizan a la relación 00:13:47
en sí 00:13:49
necesitamos una entidad específica 00:13:50
para esta tabla 00:13:53
porque en esa entidad es donde irán 00:13:54
estas propiedades, necesitamos una entidad específica 00:13:56
¿vale? que es el modelo que está aquí 00:13:59
ahora miramos un poquito 00:14:01
pues como sería si no 00:14:02
tuviéramos esto, que se simplifica mucho el modelo 00:14:04
se simplifica mucho, que es el many to many 00:14:06
que dices tú, vale 00:14:08
pues entonces, al haber una entidad 00:14:10
intermedia, ese many to many 00:14:12
en realidad se ha convertido 00:14:15
en dos one to many 00:14:16
¿vale? dos one to many 00:14:17
que... claro, entonces 00:14:20
Entonces vemos esta situación, pues tiene que haber una entidad proyecto sede, entonces proyecto sede que tiene dos claves, una clave primaria compuesta, entonces proyecto sede es esta. 00:14:23
entonces proyecto sede 00:14:41
tiene 00:14:43
un proyecto por un lado 00:14:45
y otra sede por otro 00:14:48
que son los extremos 00:14:50
many to one 00:14:52
de las dos relaciones 00:14:53
de uno a muchos 00:14:56
de las dos relaciones de uno a muchos 00:14:57
los extremos many to one 00:14:59
al ser los extremos many to one 00:15:00
de esa relación tienen que tener la columna 00:15:04
que los une 00:15:06
que está clara y de prot y de sede 00:15:07
que sería esta, y de proyecto y de sede, estos dos, pues son estos dos de aquí, este y este, vale, entonces, esto lo dejamos aparcado, ahora un momentito, este MAPSID y este MAPSID, pero las dos primeras líneas estarían claras, vale, 00:15:10
toda entidad 00:15:30
JPA tiene que tener una clave primaria 00:15:33
sí o sí obligatoria 00:15:35
bueno, pues en realidad 00:15:37
podríamos, opción sencilla 00:15:39
pero que en 00:15:41
proyectos muy complicados con muchas cosas 00:15:43
que le haces, puede acabar 00:15:45
dando terrores e historias chungas 00:15:47
pero se podría, y en la mayoría 00:15:49
de los contextos funciona 00:15:51
pasar de esto 00:15:52
ID e ID 00:15:54
y tirando, y ya está y no pasa nada 00:15:56
A JPA, de hecho lo hemos hecho así 00:15:59
¿Vale? Y a JPA 00:16:01
Pues le parece estupendo 00:16:02
Bueno, no sé lo que le parece 00:16:05
Porque no es humano por ahora 00:16:06
Pero ya está, tiras 00:16:08
La mayoría de los casos tira 00:16:10
¿Vale? Pero 00:16:11
No, no tiene nada que ver con eso 00:16:13
Pero 00:16:17
Es mucho más recomendable 00:16:18
Que la clave primaria esté en un único campo 00:16:21
¿Vale? Para asegurar el manejo 00:16:23
De esas entidades 00:16:25
No a través de dos propiedades 00:16:26
A través solo de una 00:16:28
Para ciertas situaciones 00:16:29
De hecho, te puede dar hasta error 00:16:30
Bueno, pues si queremos que la clave primaria 00:16:33
Esté en un solo campo 00:16:35
Vamos a hacer una ID 00:16:36
¿De qué tipo? 00:16:38
Tiene que tener dos cosas 00:16:39
Pues no me queda más remedio 00:16:40
Que hacer una clase aparte 00:16:41
Para que tenga esas dos cosas 00:16:42
Vale, pues entonces 00:16:43
Este es un tipo clave 00:16:45
Que nos tenemos que hacer 00:16:47
No nos queda más remedio que hacerlo 00:16:48
Un tipo clave que nos tenemos que hacer 00:16:50
Porque contiene dos cosas 00:16:51
Pues ese tipo clave sería este 00:16:52
y este tipo clave tiene 00:16:55
y de proyecto 00:16:58
las dos claves, los dos enteros 00:17:00
este y este, que hay que decirle 00:17:03
como he cambiado el nombre 00:17:05
hay que ponérselo aquí porque he cambiado el nombre 00:17:06
si no este column no haría ni falta 00:17:09
¿vale? entonces un segundinín 00:17:11
este tipo clave 00:17:13
no necesita anotarle nada más 00:17:14
ni hacerle nada más 00:17:17
pero resulta que como este tipo clave 00:17:18
va a formar, va a ser 00:17:21
la clave primaria de otra 00:17:23
entidad 00:17:25
para que JPA lo entienda 00:17:26
hay que poner esta 00:17:29
anotación, ya está, aunque nos quedemos con eso 00:17:31
suficiente, hay que poner esta 00:17:33
anotación, pues se planta esta anotación 00:17:35
y ahora en proyecto sede 00:17:37
yo digo, ojo 00:17:39
que esta es de una entidad 00:17:40
embedable, es una clave primaria 00:17:43
embebida, aquí metida 00:17:45
en todo esto, vale 00:17:47
y ahora vamos con esto 00:17:48
dime 00:17:50
¿Por qué le pones luego también 00:17:52
id proyecto y id sea a la otra clase 00:18:08
si ya lo tienes dentro de la id? 00:18:09
No se lo he puesto, le he puesto el propio objeto 00:18:12
Claro, le he puesto el objeto para que tenga 00:18:14
todos los datos, esto es para poner una clave 00:18:16
Es que 00:18:18
donde tienen que estar los objetos 00:18:20
por pura semántica es aquí, en la relación proyecto-sede 00:18:23
tienen que estar aquí, entonces esto es solo para la clave 00:18:27
entonces la clave en cualquier otra entidad 00:18:30
siempre es el tipo de dato, ¿qué es un entero? 00:18:33
pues es un entero, es decir, tú aquí en id-sede no te has planteado 00:18:36
decir esto que sea de tipo sede 00:18:39
tú ahí tienes la información de la clave porque tiras de ella para búsquedas 00:18:41
para lo que sea, pues aquí igual 00:18:45
proyecto sede 00:18:47
esta es 00:18:49
la clave, entonces tú quieres los valores 00:18:51
de la clave, no pienses que como son dos 00:18:53
los hemos metido en otro sitio, pero tienen que ser 00:18:56
los propios valores de la clave, luego ya los datos 00:18:58
los datos ya van ahí 00:19:00
los datos ya van ahí 00:19:01
y luego también 00:19:02
hace falta un hipo, es un fast food 00:19:05
porque no hay hipo 00:19:07
claro, pero porque he puesto sets 00:19:09
he hecho que las colecciones 00:19:11
fueran hard set 00:19:14
la clase de líder 00:19:14
En la clase del ID 00:19:17
Por amas ID sería 00:19:19
Yo lo pongo 00:19:23
¿Dónde está? 00:19:31
Aquí está 00:19:32
Siempre es recomendable 00:19:32
En cualquier entidad ponerlo 00:19:36
Los dos, jasco de equals 00:19:38
Porque es que si no nunca sabes 00:19:40
Cuando va a petar por ahí 00:19:42
¿Y en proyectos? 00:19:43
En proyecto sede tengo, claro, de la ID. 00:19:44
Todos por clave primaria. 00:19:53
¿Vale? 00:19:54
Bueno, esto en cuanto a la clave. 00:19:58
Y ahora, nosotros ya podríamos tirar con esto. 00:20:02
Imaginaos que nos olvidamos de este maps ID. 00:20:06
O sea, lo de que la clave sean dos parámetros. 00:20:09
Por tanto, sea un tipo que nos hemos hecho nuevo. 00:20:12
que ese tipo tenga que tener el 00:20:14
embedable y aquí decirle que es en bebidas 00:20:16
o ya está, es que es eso, es sota caballo y rey 00:20:18
ya está, no hace falta saber más que eso 00:20:20
ahora, lo único es que aquí 00:20:21
JPA 00:20:24
luego se puede volver un poco loco 00:20:25
si no ponemos este mapsid 00:20:28
si no ponemos este mapsid 00:20:30
pero porque se vuelve un poco loco 00:20:34
porque ve que tiene 00:20:36
una información en dos sitios, duplicada 00:20:38
ve que tiene aquí 00:20:40
y de proyecto 00:20:42
ID sede y luego la tiene 00:20:44
aquí dentro también 00:20:46
entonces 00:20:47
para decirle 00:20:49
a JPA, son siempre la misma 00:20:52
cuidado, no te estoy dando la clave 00:20:54
primaria dos veces 00:20:56
aunque tengas dos ID pro 00:20:57
son el mismo, no te líes 00:21:00
le ponemos el maps, que le decimos 00:21:02
oye, esta sede 00:21:04
de aquí, su ID de sede 00:21:05
no es un ID de sede que 00:21:08
pueda ser otro diferente a este 00:21:10
que pueda ser otro 00:21:12
es como si tuviera dos referencias 00:21:13
que se llamaran IDS 00:21:15
JPA dice 00:21:17
tengo dos cosas que se llaman IDS 00:21:18
lo que está aquí dentro 00:21:21
y lo que está aquí dentro 00:21:22
y tengo dos cosas que se llaman IDPROJ 00:21:24
el que está aquí dentro y el que está aquí dentro 00:21:26
entonces 00:21:29
pues 00:21:31
dos cosas que se llaman igual 00:21:32
no me mola, no me gusta 00:21:34
entonces 00:21:37
si no le ponemos esto 00:21:38
nos peta y le decimos 00:21:40
Cuidado que están perfectamente conectados 00:21:42
Este idprox 00:21:45
Arrastra siempre 00:21:46
Al de aquí 00:21:48
Y este idcd arrastra siempre 00:21:49
Al de ahí, ya está 00:21:52
Con esas notaciones estaríamos 00:21:53
Si arrastra al de ahí 00:21:55
¿Por qué lo llamo idcd en el map? 00:21:57
Porque se llama idcd aquí 00:22:00
Ahí 00:22:03
Exacto 00:22:04
¿Y te lo mapea con el 00:22:08
No te entiendo 00:22:10
Sí, lo que le estoy diciendo 00:22:21
Es que esta ID de aquí 00:22:25
O sea, la ID de aquí 00:22:27
Es el mismo campo 00:22:29
ID prot que está aquí dentro 00:22:32
Que se refiere al mismo 00:22:33
Bueno, no te lo sobreentiendes 00:22:35
Si tú no le pones 00:22:40
o sea, en el momento 00:22:41
de hacer un get proyecto sede 00:22:44
sí, en el momento de hacer un get 00:22:46
proyecto sede, de hacer 00:22:48
un get con JPA 00:22:50
él al hacer el get ya te lo mapea y te lo hace todo 00:22:51
pero luego, pero ¿cuál es el 00:22:54
problema? que ese objeto se queda con 00:22:56
una información en dos sitios 00:22:58
guardada, una vez que ya está 00:23:00
mapeado, el problema no es hacer el get, ahí no hay 00:23:02
problema, el problema es que él se queda con la 00:23:04
información guardada en dos sitios, la misma 00:23:06
aquí dentro y aquí dentro 00:23:08
entonces le indicamos 00:23:10
que esa es la misma, nos referimos a la misma 00:23:12
que no tiene dos propiedades idprox 00:23:14
nos referimos a eso simplemente 00:23:16
porque te obliga 00:23:18
si es que no sé mucho más que esto que te estoy diciendo 00:23:20
claro, tú al poner aquí 00:23:22
maps id, él dice 00:23:38
ah, vale, que esto en la clave 00:23:40
también lo tengo, y ah, que lo tengo 00:23:42
duplicado, dice, ah, vale 00:23:44
o sea, que esta es una dúplica 00:23:46
y se va a la clave y dice, ¿es una dúplica de quién? 00:23:47
de este 00:23:50
¿vale? 00:23:50
el error sería, o sea 00:23:53
la idea del error es como si tú declaras 00:23:56
una variable dos veces, si no pones 00:23:58
maps id, sería como declarar 00:24:00
algo dos veces, que Java no te deja 00:24:02
¿vale? pues es la idea 00:24:04
vale, entonces, ahora, antes 00:24:05
de irnos al recreo 00:24:08
¿qué ocurriría 00:24:09
si aquí, 00:24:11
esperemos, 00:24:15
dime, 00:24:16
sobre el código este? 00:24:16
Sí. 00:24:21
Ah, ahora cuando paremos, ¿vale? 00:24:24
Digo esto y, vale. 00:24:26
Entonces, ¿qué ocurre 00:24:28
si esto no tiene estas dos 00:24:30
de aquí? 00:24:32
Si no tiene estas dos, ¿vale? 00:24:34
No hace falta proyecto 00:24:36
No hace falta. El modelo sería más fácil. Sede tendría list proyecto, punto pelota. Y proyecto tendría list sede, punto pelota. ¿Qué cambian? Las anotaciones. Ahora, en ambas listas, en ambos lados, tendría que haber un many to many en los dos. 00:24:38
many to many, y ahora en uno 00:25:00
de los dos, solo en uno 00:25:02
¿en cuál? en el que queramos 00:25:03
ahí sí que podemos elegir 00:25:06
solo en uno de los dos, ahora ya sí habría 00:25:07
que mapear 00:25:10
cuáles son las dos claves 00:25:10
ajenas 00:25:13
¿vale? entonces quedaría algo como esto 00:25:15
¿la tabla seguirá viendo? 00:25:17
no, esta no, la tabla sí, claro 00:25:19
lo que no existe es la entidad 00:25:21
entonces 00:25:22
nos quedaría 00:25:24
una notación tipo esta 00:25:28
Ejemplo 00:25:29
No, eso no lo voy a poner en el examen 00:25:33
Porque no hemos hecho ningún ejemplo 00:25:34
Joder, mayúsculas no, que se cree que estoy enfadada 00:25:35
Ejemplo 00:25:38
No, no es un tochaco 00:25:40
En realidad son 00:25:46
Yo, el referes y el inverse 00:25:47
Tú tienes que poner dos campos 00:25:50
El inverse y el otro, y ya está 00:25:52
Nada más, y la tabla 00:25:54
Tienes que poner la tabla y las dos columnas 00:25:55
No tienes que poner más 00:25:58
puede ser 00:25:59
pero vale, entonces vámonos directamente a la anotación 00:26:03
vale, ya está, es esta, no tiene más 00:26:06
entonces esto sería, por ejemplo 00:26:09
estudiante cursos, un estudiante muchos cursos 00:26:12
un curso muchos estudiantes, una many to many 00:26:15
entonces, estudiante tendría 00:26:18
¿dónde estamos? estudiante tiene 00:26:21
por tanto muchos cursos 00:26:24
y curso tendría que estar 00:26:26
por abajo muchos estudiantes 00:26:28
entonces la tabla estudiante 00:26:30
la entidad estudiante curso no existe, esa no existe 00:26:32
entonces aquí 00:26:34
anotamos que esto es un 00:26:36
many to many 00:26:38
que es un many to many 00:26:39
y ahora ya hay que decir simplemente 00:26:41
tabla que tiene 00:26:44
la relación, tabla, que la tabla 00:26:46
sí existe lógicamente 00:26:48
y las dos columnas 00:26:49
esta que sería la columna 00:26:51
la que pones aquí 00:26:54
es la columna, la clave ajena 00:26:55
de la tabla en la que estás 00:26:58
de estudiante, ahora estamos en estudiante 00:26:59
y la que pones en inverse 00:27:02
es la clave ajena referencia 00:27:04
al otro extremo, a curso 00:27:06
y ya está, con poner esto 00:27:08
luego tienes más propiedades que podrías poner 00:27:10
de fetch 00:27:12
de no sé qué, pero esto es lo básico 00:27:14
No, no, no, estás haciendo referencia al tuyo, estás estudiante. 00:27:16
Claro, tú eres estudiante, pero es que, sí, pero, a ver, pero estas son de la tabla estudiante-curso, 00:27:31
entonces esta es, yo como estudiante, ¿cuál es la clave ajena en la que me adhiero? A esta, yo en columna. 00:27:39
Pero es que el otro es el otro para los dos 00:27:46
Porque el otro es la tabla estudiante curso 00:27:51
Tienes estudiante, estudiante curso 00:27:54
Y curso 00:27:57
Vale, pues ya está 00:27:58
Claro, esto es de la tabla intermedia 00:28:01
Y ahora, estudiante 00:28:05
Tendrá un Muppet By 00:28:09
Estudiante, que estará por aquí abajo 00:28:10
Many to Many tiene un map 00:28:13
porque esto ya está mapeado 00:28:16
en la propiedad 00:28:18
cursos de la clase estudiante 00:28:20
lo haces en uno de los dos 00:28:22
¿en cuál? en el que quieras 00:28:25
pero eso sí 00:28:26
en el que lo hagas 00:28:27
lo has convertido en propietario 00:28:29
¿qué significa? que en esto que ha hecho 00:28:31
CharGPT, el propietario 00:28:34
es el estudiante 00:28:36
el propietario de la relación, con lo cual el estudiante 00:28:38
a través del estudiante 00:28:40
puedes cambiar los cursos, los datos 00:28:42
de los cursos. Pero a través 00:28:44
de curso no puedes cambiarlos de los estudiantes. 00:28:46
¿Vale? Porque eso sí que tiene trascendencia. 00:28:50
El que tenga el 00:28:52
joint column y todo esto, 00:28:54
en este caso este, 00:28:57
este a partir 00:28:59
de estudiantes, que tú agregas 00:29:00
un curso, lo puedes hacer sin 00:29:02
ningún problema. Que borras un curso, 00:29:04
lo puedes hacer. JPA te lo hace, 00:29:06
porque estás propietario. 00:29:08
Pero, desde aquí, 00:29:10
desde curso 00:29:12
tú no puedes cargarte un estudiante 00:29:14
no puedes añadir estudiantes 00:29:16
a la colección, quitarlos, no puedes 00:29:18
no te deja 00:29:20
bueno, es que no te deja, tú lo haces pero luego ves que no te lo ha hecho 00:29:20
¿vale? porque la que manda 00:29:23
es la otra 00:29:26
que tiene sentido 00:29:26
tiene sentido que un estudiante pueda cambiar 00:29:29
sus cursos, pero tiene todo el sentido 00:29:32
del mundo que a través 00:29:34
de un curso tú no puedas eliminar estudiantes 00:29:36
¿vale? entonces siempre se elige 00:29:38
el propietario con el que 00:29:40
tenga sentido, ¿vale? 00:29:42
No. 00:29:47
Según esto, tú no puedes eliminar 00:29:49
de un curso, no puedes eliminar a un estudiante, 00:29:51
efectivamente. O modificar sus propiedades. 00:29:52
O sea, a través de un curso, esto 00:29:55
sobre todo se ve a través de modificar 00:29:57
por ejemplo, el estudiante tiene una edad. 00:29:59
A través del curso no puedes 00:30:02
cambiar su edad, no te lo va a coger. 00:30:03
Pero el 00:30:05
estudiante tiene un curso. 00:30:06
A través del estudiante puedes cambiar el nombre del curso. 00:30:09
Eso sí podrías, por ejemplo. 00:30:11
Porque el estudiante es el que tiene la propia... 00:30:13
Entonces, a través de aquí tú puedes cambiar de cursos lo que quieras. 00:30:17
Su nombre, lo que te dé la gana. 00:30:21
Pruébalo. 00:30:22
Sí, sí. 00:30:23
Dime. 00:30:27
Justo. 00:30:32
Entonces, no hace falta esa tabla. 00:30:33
Pero si hay propiedades, hace falta, que es lo habitual normalmente. 00:30:36
¿Vale? 00:30:40
Pero bueno, el many-to-many lo vamos a poner en el examen 00:30:41
No, porque lo hemos mencionado ahora 00:30:43
No hemos hecho ningún ejemplo antes 00:30:49
Si lo he dicho antes 00:30:50
Es que no me escucháis, me escucháis como en zig-zag 00:30:53
O sea, una vez de cada 10 minutos 00:30:55
Al igual que tú, que tenemos que decir la que escucha 00:30:56
Exacto 00:30:58
Es que ni un chico se escucha 00:31:00
¿Eh? 00:31:01
Hombre, sí, porque de eso sí que es de lo que hemos visto 00:31:03
Ejemplo, ¿vale? 00:31:06
Vale 00:31:09
Ahora miro lo tuyo, Cristina 00:31:10
Venga, pues paramos aquí 00:31:12
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:
3 de marzo de 2026 - 17:08
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
31′ 15″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
132.71 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid