Saltar navegación

20260129 JPA_13 - 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 1 de febrero de 2026 por Raquel G.

5 visualizaciones

Más información Transcripción

Descargar la transcripción

no pasa nada 00:00:00
y al final se trata de jugar con los objetos 00:00:02
acceder a las propiedades 00:00:05
cambiarlas y ya está 00:00:06
y tener en cuenta en mente 00:00:08
las cuatro cosas básicas 00:00:10
el lazy, el cascade 00:00:12
el actualizar siempre por propietario 00:00:14
teniendo esas cuatro cosas básicas 00:00:20
luego se trata de navegar y todo eso 00:00:22
pero aún así este código 00:00:23
es un código horrible, o sea, tener que haber 00:00:26
cogido yo la colección, haber sacado la colección 00:00:28
haber borrado, es un poco horrible 00:00:30
¿vale? claro 00:00:32
porque hemos 00:00:34
el que esto haya tenido que ser 00:00:35
tan feo para hacerlo, bueno habría sido 00:00:38
más bonito con una JPQL 00:00:40
me hago yo un delete from 00:00:41
jugador videojuego y ya está 00:00:43
¿vale? hubiera sido más bonito con una JPQL 00:00:45
pero bueno, hacer JPQL 00:00:48
entonces el que esto al final 00:00:49
nos haya complicado tanto la vida 00:00:52
para borrar una única 00:00:53
único objeto, que es lo único que he querido 00:00:55
borrar un objeto, pues para borrar un objeto 00:00:58
hemos tenido que hacer aquí 00:01:00
la leche 00:01:01
pues esto ha sido 00:01:02
porque ese objeto no lo podíamos sacar 00:01:05
por clave 00:01:08
porque la clave era compuesta 00:01:08
y el find 00:01:11
necesita un único elemento 00:01:13
lo ideal habría sido 00:01:16
que pudiéramos haber hecho un find 00:01:18
de jugador videojuego por su clave 00:01:19
y no podemos, porque el find 00:01:21
Tiene solamente un campo para poner la clave 00:01:24
Y aquí tenemos dos 00:01:27
Entonces hemos tenido que ir 00:01:29
A través de jugador de videojuego 00:01:31
Que es un rollo 00:01:33
Bueno, pues lo natural sería 00:01:34
Poder mapear esto 00:01:36
Con un único objeto clave 00:01:38
Pues vamos a inventárnoslo 00:01:40
Que es la forma normal de hacer esto 00:01:43
Entonces, para no enguarrar esto 00:01:45
Voy a renombrar este como 00:01:47
Old 00:01:49
Jugador videojuego 00:01:49
Claro, un objeto clave 00:01:51
Que contenga los otros dos 00:01:54
Pues a este lo voy a 00:01:56
Copiar con versión all 00:01:57
Y lo retoco 00:02:01
Venga, paste 00:02:03
Bueno, feo 00:02:06
Que seguro que si pongo feo 00:02:11
Entendéis mejor a qué me refiero 00:02:12
Feo porque tiene dos claves 00:02:13
Esta y esta que no pasa nada 00:02:24
Tiramos así 00:02:27
Vale, cuando yo digo no pasa nada 00:02:28
En general, que lo digo muchas veces 00:02:30
No es que no pase nada 00:02:32
Siempre acaban pasando cosas 00:02:33
Ay, por Dios 00:02:36
Porque es feo, bache 00:02:37
Porque ya hemos perdido el control 00:02:39
Desde el momento en que es el entity manager 00:02:42
El que maneja los objetos, los marca 00:02:44
Decide cuando sincroniza con la base de datos 00:02:46
Recupera 00:02:48
Ahí ya él se hace sus cachés de objetos 00:02:49
Coge uno, coge el otro 00:02:52
Pues hay veces que nuestra arquitectura 00:02:53
las anotaciones y cosas funcionan, pero 00:02:56
hay veces que si ya estamos haciendo servicios 00:02:58
muy complicados, pues 00:03:01
podemos tener unos efectos secundarios muy 00:03:03
extraños. Y para arreglarlos 00:03:04
tenemos a lo mejor que cambiar el diseño, 00:03:06
cambiar no sé qué, pero es imposible contemplar 00:03:08
todas esas cosas. Bueno, 00:03:10
pues en este caso, esto de 00:03:12
aquí, esto claro que funciona, 00:03:14
funciona en la mayoría 00:03:17
de las situaciones, pero es una forma 00:03:18
de anotar la clave fea. Primero por lo que os he 00:03:20
dicho, porque nos complica el 00:03:22
sacar un objeto jugador videojuego, nos lo 00:03:24
complica, porque el find no aplica. 00:03:26
Tenemos que tirarlo de los otros 00:03:29
y meternos en la colección. Menudo rollo. 00:03:30
Y luego, pues, 00:03:33
porque al ser dos objetos, 00:03:34
el entity manager puede llegar 00:03:36
a un momento en que colapse y haga cosas extrañas 00:03:38
y los servicios son complicados. 00:03:40
Luego, vamos a 00:03:42
hacerlo bonito. 00:03:44
Me voy ya a este. 00:03:46
Esto de que las dos sean 00:03:48
claves, no. Esto es muy feo. 00:03:50
Una única clave. 00:03:52
Y así puedo hacer el find. 00:03:54
Vale, pues esa clave, como tiene que tener dos cosas dentro, no tiene solamente un long, un string, tiene que tener dos, tiene que ser un objeto, no hay tutía, pues este objeto de qué clase va a ser, pues jugador, videojuego, id, esta es la clase, jugador, videojuego, id, vale 00:03:56
Y esta ya si es 00:04:23
La clave 00:04:25
¿Vale? 00:04:27
Esta si va a ser la clave 00:04:29
Vale, pero tenemos que hacer esta clase 00:04:30
Tenemos que hacer esta clase 00:04:33
Jugador, videojuego, id 00:04:36
Vale 00:04:37
Esto no es una entidad 00:04:43
Entonces no tiene sentido que lo anote con entity 00:04:45
Porque esto no es una tabla de la base de datos 00:04:47
Esto no lo puedo anotar con entity 00:04:50
¿Vale? 00:04:51
Esto que es una clase que se corresponde a una clave 00:04:53
Que está 00:04:56
metida, introducida 00:04:57
dentro de esto 00:04:59
entonces, ¿cómo se anota esta clase para decirle 00:05:00
a JPA que esto es una clave 00:05:03
que está metida dentro de otra cosa? 00:05:05
pues se anota con esta 00:05:08
anotación 00:05:09
embedable 00:05:10
pero con dos des juraría 00:05:15
si no, lo miro 00:05:17
vale, así se anota 00:05:19
vale, esta es una clave 00:05:21
que está embebida 00:05:25
es una clase 00:05:26
que está 00:05:28
embebida dentro de esta otra 00:05:29
aquí 00:05:32
¿qué significa 00:05:33
embebida? 00:05:38
en castellano 00:05:39
embebido en castellano 00:05:40
no es estar como insertado 00:05:44
hay que hacer una carrera que tiene ese nombre 00:05:48
¿cómo va a dar una carrera que se llama embebida? 00:05:50
ingeniería de servicios embebidos 00:05:53
o algo así 00:05:54
A ver, embebido 00:05:55
A mí me suena, pero no sé si me suena por el contexto 00:05:57
De programación, pues que está incorporado 00:05:59
En otra cosa, que va adentro 00:06:01
Que va a incorporar otra cosa 00:06:03
Me suena a eso 00:06:04
Vale, pues esto 00:06:06
Está incorporado, esta clase 00:06:09
Es porque mapea una clave 00:06:11
Que está incorporada 00:06:13
En otro, que es aquí 00:06:15
Entonces, vale, pues esta clave 00:06:17
Esta clave de aquí 00:06:20
Jugador videojuego ID 00:06:24
Que es esta de aquí 00:06:27
Tiene dos elementos 00:06:28
Claro 00:06:31
Jugador ID 00:06:34
Videojuego ID 00:06:38
Vale 00:06:48
Y aquí ponemos 00:06:50
La columna de la tabla 00:06:51
De la que salen estas 00:06:54
Name 00:06:56
Vamos aquí a 00:07:02
Jugador videojuego 00:07:05
Es jugador id videojuego barra baja id 00:07:07
Esto sería 00:07:09
No, no, no 00:07:12
No porque esta no es 00:07:15
Esta no es una 00:07:22
Esto no es una relación 00:07:24
Con esto no estoy expresando una relación 00:07:26
Videojuego 00:07:28
Barra baja y D 00:07:41
Entonces yo con esto estoy describiendo 00:07:42
Mi clave, que está formada por dos cositas 00:07:45
Estas dos cositas en la base 00:07:47
De datos 00:07:49
Se corresponden con estas columnas 00:07:50
Voy a hacer 00:07:54
Los get y set 00:07:55
Vamos a hacer un constructor sin parámetros 00:07:56
Porque lo del constructor, bueno, aunque ya lo tiene 00:08:03
Porque, vale, si hiciera otro 00:08:05
Con parámetros, entonces sí que le tendría que hacer 00:08:07
sin parámetros, voy a dejarla 00:08:09
así simple y si me dan errores 00:08:11
y me empiezan a dar errores 00:08:12
pues ya me complico la vida 00:08:14
vale, entonces 00:08:16
en esta, en esta creo recordar 00:08:18
que no hay que anotarla de ninguna otra manera 00:08:20
vamos a 00:08:23
repasarlo por aquí 00:08:25
porque ya no sé ni donde lo tengo 00:08:26
aquí tengo una versión, vale 00:08:28
vale 00:08:30
no, no tengo que 00:08:34
Aquí he puesto un constructor sin parámetros 00:08:38
Porque he hecho uno con parámetros 00:08:41
Entonces, vale 00:08:42
A ver 00:08:44
¿Dónde estamos? Jugador, videojuego 00:08:46
ID, pero no es de aquí 00:08:48
Estamos en 00:08:50
Esta 00:08:53
Esta es 00:08:55
Vale, aquí 00:08:58
Lo normal, pero es que tampoco hace 00:08:59
En realidad no hace falta, las cosas a veces 00:09:02
Funcionan por defecto 00:09:04
Pues JPA te dice 00:09:06
o incluso otra GPT te dice 00:09:08
cuidado 00:09:11
esta que sea serializable 00:09:13
esta sí, las otras he dicho que no 00:09:15
esta sí, ¿por qué? 00:09:17
porque el entity manager 00:09:19
va a tener que pasar este objeto 00:09:21
como idea única 00:09:23
como una clave un montón de veces para el find 00:09:25
para no sé qué, entonces 00:09:26
contiene dos cosas, va a tener que serializarla 00:09:27
¿vale? entonces 00:09:31
en los otros contextos la clave suelen ser 00:09:32
long, suelen ser otras cosas que son 00:09:35
ya serializables por naturaleza 00:09:37
el long ya es serializable, el string ya es serializable 00:09:39
todos son serializables 00:09:41
todos se implementan serializables, este me lo he inventado yo 00:09:43
que implemente serializable 00:09:45
pues yo nunca me he encontrado esto en una situación 00:09:47
en la cual por no ponerlo me de un error 00:09:49
pero bueno 00:09:51
la orden oficial 00:09:53
es ponerlo 00:09:54
¿eh? 00:09:56
si long 00:09:57
¿como? 00:09:58
long si, string tambien 00:10:00
pero este me lo he inventado yo 00:10:03
claro, este es otro, este me lo he inventado yo 00:10:05
entonces, pues 00:10:08
si queremos hacer las cosas 00:10:09
en plan, vamos a seguir estándares 00:10:12
vamos a hacer, pues ponemos simplemente serializando 00:10:13
pero 00:10:15
si no lo ponemos, no pasa nada 00:10:16
o al menos a mí no me ha pasado, bueno, la situación es la que sí 00:10:19
hay todos seguros 00:10:22
que le ha pasado 00:10:23
sí 00:10:24
espera, espera, es que no 00:10:30
cuidado que no oigo 00:10:33
Callados 00:10:34
Callados 00:10:36
Pero las otras 00:10:37
Sí, o sea, por ejemplo, equipo 00:10:44
También está utilizando clave primaria 00:10:46
Y tampoco 00:10:48
El clave compuesta 00:10:51
Creo que estaba compuesta por 00:10:54
Otro objeto propio tuyo 00:10:56
Ahí es cuando creo que te puede petar 00:10:58
¿Cómo? ¿Cómo? Repite tú 00:11:00
Que en vez de tener un log y un log 00:11:03
hubiera de alguna forma 00:11:04
otra clase 00:11:07
que no fuera serializable 00:11:07
Puede ser, sí 00:11:10
Es verdad que son 00:11:17
situaciones, yo no sé 00:11:19
si alguna vez habré trabajado 00:11:21
con una situación en que una clave 00:11:23
sea un objeto 00:11:25
que no sea un log, un string 00:11:27
una clave compuesta 00:11:28
seguramente no 00:11:31
Y por eso nunca he conseguido que me petara 00:11:32
Sin poner aquí serializable 00:11:35
Pero no perdemos nada por poner serializable 00:11:36
No solo en esta, sino incluso en las demás 00:11:39
Si es que no molesta 00:11:41
Tampoco molesta 00:11:42
Podrías llegar a usar esta clase como otra cosa más 00:11:43
Y meter un objeto que no fuera column 00:11:46
Que no lo usases para la clave 00:11:48
Realmente tuviera otra propiedad más que no fuera serializable 00:11:49
Uy, pero eso sí que no debería hacerlo 00:11:52
Porque entonces ya sí que estoy mezclando cosas 00:11:55
Esta es la clave, esos dos objetos 00:11:57
Y ya está 00:11:58
¿Vale? 00:11:59
Entonces, bueno, como se supone que todo el mundo te dice que lo hagas y es el estándar y en la situación en la que dice él, pues efectivamente puede que te pete, pues no pasa nada porque lo pongamos. Serializable. Vale, entonces, yo creo que aquí no hay que poner más cosas. 00:12:01
también 00:12:28
te hablan mucho 00:12:29
de, claro, el problema de este objeto 00:12:31
es que especialmente se empaqueta 00:12:34
y tú lo pasas al find 00:12:35
lo tienes ahí como marca de las claves 00:12:37
el entity manager tiene ahí en sus marquitas 00:12:39
sus objetos marcados con esta su clave 00:12:42
entonces 00:12:44
si no hay un hasco 00:12:45
de equals, también en alguna situación 00:12:48
podrías tener algún efecto extraño 00:12:50
porque él tenga que comparar las claves 00:12:52
y como no hay un hasco de equals 00:12:54
por estos dos 00:12:56
pues el funcionamiento 00:12:57
no es el esperado 00:12:59
yo tampoco me he encontrado una situación 00:13:00
en la cual eso haya hecho que algo 00:13:03
funcione mal, el no poner 00:13:05
el jasco de equas, pero eso no 00:13:07
significa que si lo pones 00:13:09
casi mejor 00:13:10
casi mejor, porque así 00:13:12
si alguien va a tener que comparar 00:13:14
dos claves, que eso sí que es una cosa 00:13:17
muy natural, comparar dos claves 00:13:19
pues no va a petar, quien, entity manager, 00:13:21
sprint, quien sea, si alguien tiene que comparar dos 00:13:23
claves, casi mejor vamos 00:13:25
a dárselo por si acaso. 00:13:27
En el servicio que estamos haciendo aquí 00:13:31
y en muchos de los 00:13:33
que hay en la lista, 00:13:35
le quitas serializable y no 00:13:37
va a pasar absolutamente nada, pero bueno. 00:13:39
El año pasado, de hecho, 00:13:47
cuando programábamos decíamos, 00:13:48
cuando hacemos una entidad, aparte 00:13:50
de las propiedades Getty Set, 00:13:52
es bueno que nos acostumbremos a hacer siempre 00:13:54
por defecto. Constructor con y sin parámetros. 00:13:56
El sin parámetros siempre, porque es la forma que nos instancia por defecto de por ahí, del mundo. Constructor con sin parámetros. Hombre, tu stream para pruebas, claro. Y Hasco de Equals. Era un poco el hábito que habíamos cogido porque no perdemos nada por ponerlo ahí y podemos facilitar la vida cuando empezamos a poner capas una tras otra, una tras otra, que ya no sabemos ni lo que hacen con nosotros. 00:13:58
Vale, pues yo creo que esta ya 00:14:18
Ya estaría, y ahora ya 00:14:21
La otra, jugador videojuego 00:14:23
Que es esta 00:14:26
Jugador videojuego, que es esta de aquí 00:14:27
Esto de aquí 00:14:31
Aquí, hay que empezar a ponerle 00:14:33
Cositas que no me acuerdo muy bien 00:14:36
Me voy a tener que mirar en la chuleta 00:14:38
Esto hay que decir 00:14:39
Este objeto hay que ponerlo porque es el de la relación 00:14:41
Es el 00:14:44
Claro, como no lo voy a poner 00:14:45
Este objeto tiene que estar 00:14:47
esta es la tabla, jugador videojuego 00:14:48
que tiene estos dos elementos 00:14:53
son los de la relación, los tengo que poner, vale 00:14:54
pero tengo que poner que esto mapea 00:14:56
esto 00:14:59
este objeto viene mapeado desde una clave 00:14:59
viene mapeado desde una clave 00:15:03
que está aquí 00:15:05
entonces, maps id 00:15:05
y aquí 00:15:08
no me acuerdo que atributo 00:15:09
se le pone 00:15:13
si, yo creo que directamente jugador id 00:15:15
Pero déjame que lo mire para no ponerlo mal 00:15:20
Desde el principio 00:15:23
Eh, puede que esté aquí 00:15:23
Sí, aquí hay algo 00:15:26
Vale 00:15:28
Ah, no, no, no 00:15:30
Aquí, vale 00:15:32
Efectivamente 00:15:34
Directamente el elemento 00:15:36
Jugador, videojuego y de 00:15:39
Vale 00:15:42
A este 00:15:44
Vale 00:15:46
Y ya está, y lo demás está todo 00:15:47
A ver 00:15:49
Un segundito 00:15:52
Espérate que encuentre la clase 00:15:56
Para no perderme 00:15:57
Porque tengo aquí mil rollos 00:16:00
Aquí 00:16:02
Vale, entonces 00:16:04
Este es jugador ID 00:16:06
Déjame que las termine de poner 00:16:08
Videojuego ID 00:16:09
Vale 00:16:15
Y ahora, la última 00:16:22
Esto hay que decir que es una clave que está embebida 00:16:28
¿Vale? Entonces la anotación id a palo seco 00:16:32
¿No? 00:16:34
Ah, que me he dejado un paréntesis doble 00:16:39
Jugador id 00:16:41
Videojuego id, vale 00:16:43
Y ahora esta hay que decirle que es una clave 00:16:44
No es una clave normal y corriente 00:16:47
Autoasignada, que venga de ahí 00:16:49
O es una clave embebida 00:16:51
Entonces 00:16:52
Embed 00:16:53
Vale, entonces una de estas creo que sobra 00:16:56
Lo que pasa es que siempre la ponemos 00:17:03
Y la dejamos 00:17:04
esto pues que significa 00:17:05
esto cambiamos id por mdid 00:17:08
porque es una clave en bebida, ya está 00:17:10
con lo cual tiene que haber java 00:17:11
jpa para montar su entity manager 00:17:13
cuando se crea el contexto 00:17:16
de persistencia 00:17:18
lo primero, bueno entre muchas otras cosas 00:17:19
lo que hace jpa aparte de verificar que la conexión 00:17:21
los parámetros de la conexión son correctos 00:17:24
el persisten y todo eso, pues verifica 00:17:25
todas las entidades, verifica que están todas bien 00:17:27
entonces 00:17:30
el verificará, ah vale realmente 00:17:31
hay una clase 00:17:33
Esta es una clase que has hecho tú 00:17:34
Una clave que has hecho tú 00:17:37
Hay una clase aquí en vedable entonces que se corresponde 00:17:39
Si realmente la hay 00:17:42
Pues 00:17:43
Si, si que la hay, es esta, estupendo 00:17:44
Vale, entonces, son, tiene dos campos 00:17:47
Vale, entonces 00:17:50
Estos dos campos son 00:17:51
Vale, estos dos campos 00:17:53
Son 00:18:05
Son dos long 00:18:06
Vale, se van a corresponder 00:18:10
Con claves, con relaciones 00:18:12
Lógicamente 00:18:13
Que me dan estos dos objetos 00:18:14
Entonces 00:18:16
Esta de aquí 00:18:18
Es la que nunca he probado a quitarla 00:18:21
Pero es probable 00:18:24
Que quitándola funcionara igualmente 00:18:26
Porque aquí ya tienes 00:18:28
A qué columna se mapea ese objeto 00:18:30
¿Vale? 00:18:33
Pero siempre se pone 00:18:34
Porque es una relación, tú pones la columna y ya está 00:18:35
Entonces, pues la relación es poder quitarle dos 00:18:37
No, hombre, las dos no 00:18:40
Porque entonces el nombre de la columna, ¿dónde lo dejo? 00:18:42
el nombre de la columna tiene que estar indicado en algún sitio 00:18:44
entonces está redundante 00:18:49
si lo quito de aquí 00:18:51
sí que no me funciona 00:18:54
pero nunca he probado 00:18:56
a quitarlo del otro lado 00:18:58
pero porque esto siempre se pone por defecto 00:18:59
tienes una relación, pones la columna que lo unes 00:19:02
¿vale? entonces como aquí 00:19:05
estás poniendo que este objeto 00:19:06
se mapea a través de clave 00:19:08
entonces él se va a videojuego id 00:19:10
y en videojuego id ya tiene 00:19:12
la columna, de ahí viene 00:19:14
mi duda de si este 00:19:16
en realidad no le hace falta porque 00:19:18
a través de maps id que le dice 00:19:20
que este objeto videojuego 00:19:22
se mapea a través de la clave, entonces 00:19:24
él se va a la clave y ve que aquí está 00:19:26
la columna, pues entonces 00:19:28
ese join column no le hiciera falta 00:19:30
no lo sé, podemos probar 00:19:32
a quitarlo y sigue funcionando 00:19:34
pero, claro, gracias a los dos 00:19:35
pero hombre 00:19:38
que ganas, vamos a anotar las cosas bien 00:19:39
en realidad cuanto más redundancia 00:19:42
O sea, controlada 00:19:44
Pues mejor 00:19:46
¿Vale? Entonces 00:19:47
Y ya estaría 00:19:50
Ahora, esto al hacer una clave única 00:19:52
Esto ya, el servicio 00:19:55
De eliminar la asociación es mucho más sencillo 00:19:56
Espérate un momento 00:19:59
Que ya no sé que las tengo abiertas 00:20:04
Vámonos aquí, voy a repasar las que las he cambiado 00:20:06
En el sitio bueno 00:20:08
Videojuego ID 00:20:09
Esta está bien 00:20:11
Con su Hasco de Equals 00:20:13
Vale 00:20:16
Ahora 00:20:16
Sí, lo que te refieres 00:20:18
Ahora, esta otra 00:20:20
Esta de aquí 00:20:22
Jugador videojuego 00:20:25
Efectivamente, su Hasco de Equals 00:20:27
A ver, los dos 00:20:29
Funcionan como Hasco de Equals 00:20:30
Porque es que son lo mismo, en realidad 00:20:33
Es decir, si es igual esta clave 00:20:34
Es porque son iguales simultáneamente estos dos 00:20:36
Pero es un Hasco de Equals más feo 00:20:38
Tirar de esos dos objetos 00:20:40
Hay que tirar del de arriba, efectivamente 00:20:42
Entonces 00:20:44
Este está bien completo 00:20:46
Él tiene la tabla, la clave 00:20:48
Esto de donde sale 00:20:50
Y lo demás está 00:20:54
Entonces este Hasco de Equals 00:20:55
Yo de hecho 00:20:58
Casi creo que 00:21:04
Que lo dejaría así 00:21:06
Porque 00:21:08
En un contexto 00:21:10
fuera de JPA, 00:21:12
estas entidades no tienen 00:21:14
por qué formar parte siempre 00:21:16
de un contexto JPA. Estarán en mi aplicación 00:21:18
haciendo cosas 00:21:20
y en mi aplicación, cuando yo trabajo 00:21:21
al margen de JPA, esto 00:21:24
pierde su sentido. Lo que importa 00:21:26
es este objeto y este otro. 00:21:28
Entonces, si yo trabajo con colecciones, con map, 00:21:30
con sets, pues esos maps y sets 00:21:32
necesitan el equals de estos dos, 00:21:34
no del otro, 00:21:36
que puede ser null perfectamente. Si yo estoy fuera de JPA, 00:21:38
el objeto de arriba podría ser null. 00:21:40
entonces yo casi 00:21:42
preferiría dejar el Hasco de Equals 00:21:44
así, el objeto del Hasco 00:21:47
de Equals es, como bien sabéis 00:21:49
si me trabajan 00:21:51
metido en colecciones 00:21:53
cuando yo controlo toda la aplicación sé si trabajo 00:21:54
con colecciones o no, si alguien me 00:21:57
controla a mí, como Entity Manager 00:21:59
Spring, quien sea 00:22:01
pues como no lo sé, si me van a meter en colecciones 00:22:02
o no, lo pongo y ya está 00:22:05
entonces yo casi creo que dejaría la versión 00:22:06
con esos dos 00:22:09
Y se acabó 00:22:10
Entonces, ahora el método este del servicio 00:22:11
Famoso 00:22:14
Este, la versión 2 00:22:16
Se queda mucho más sencillo 00:22:19
Entonces 00:22:32
Este 00:22:33
Me falta la llave 00:22:34
Ahora ya, pues cogemos el objeto 00:22:40
Y lo mandamos a la porra 00:22:53
Y ya está 00:22:54
El juego 00:22:55
Y de 00:23:02
Jugador 00:23:06
Videojuego 00:23:14
Con los dos 00:23:16
No sé cuál tengo primero 00:23:17
Tengo primero 00:23:19
No tengo constructor 00:23:22
Con los dos parámetros 00:23:25
Entonces se lo voy a poner 00:23:26
Jugador primero y videojuego después 00:23:28
Entonces 00:23:40
Jugador primero 00:23:41
Y videojuego después 00:23:43
Y de jugador 00:23:50
Y de videojuego, ¿cuál es el problema? 00:24:02
Ah, jugador, videojuego y de 00:24:05
Perdón, perdón 00:24:06
Vale 00:24:07
Y ahora ya sí puedo hacer en .find 00:24:08
Jugador videojuego.class 00:24:15
La clave 00:24:25
Y ahora en .remove 00:24:27
Esto 00:24:33
Sería guardarte el find 00:24:34
En un jugador videojuego 00:24:44
Sí, sí, sí, sí 00:24:47
Jugador videojuego 00:24:49
El juego que estoy 00:24:54
Aquí haciendo 00:24:57
Sí, que he hecho una tontería, he borrado una cosa 00:24:58
Que ni siquiera es un objeto 00:25:03
Vale, pues ahora ya 00:25:06
Voy a borrar el 3-3 00:25:12
Desde el main 00:25:16
3-3 00:25:21
Uy, que bien, que bien 00:25:29
Esto nos viene magnífico 00:25:36
No ha encontrado 00:25:38
El constructor para 00:25:43
Jugador, videojuego 00:25:45
ID, tu con el 00:25:48
Enredable, a ver 00:25:49
Ah, es que al poner constructor con parámetros 00:25:52
He inhabilitado el otro 00:25:55
Claro, he inhabilitado el vacío 00:25:57
Vale, magnífico 00:25:59
Sí 00:26:04
Vale, entonces yo creo que es esto 00:26:06
Pero que normalmente 00:26:14
Te dice, no constructor, no sé qué 00:26:15
Y este lo he puesto más complicado 00:26:17
Porque dice 00:26:20
No encuentro el constructor 00:26:20
Pero no te dice que el que necesita es el otro 00:26:23
Pero a ver, yo entiendo que es eso 00:26:24
Vamos a ver 00:26:26
Pues era eso, efectivamente 00:26:27
Ala, ya está quitado 00:26:34
¿Cuál? 00:26:37
Este 00:26:40
Bueno, pues bien para todo el mundo, ¿no? 00:26:41
Bueno, y así podríamos llamar 00:27:17
A un montón de métodos 00:27:19
O sea, hacer un montón de servicios 00:27:20
y al final 00:27:22
acaban siendo todos muy fáciles 00:27:23
recuperar, coger un objeto 00:27:26
toquetearlo, cuando hay relaciones 00:27:28
es más complicado, etc. 00:27:30
pero quería yo 00:27:32
este en particular 00:27:33
para 00:27:36
quería yo este en particular 00:27:37
para cuando 00:27:40
se hace una JPQL 00:27:42
que no te devuelve 00:27:44
una entidad concreta 00:27:46
este método 00:27:47
Este, era uno de los servicios que estaban en la lista. 00:27:49
Entonces, voy a comentarlo todo para que… 00:27:54
No, no, no, a ver, si lo que os he dicho es JPQL, 00:27:59
la clave es que uno tenga la noción de que es como SQL más o menos, 00:28:07
salvo que en lugar de tablas trabajas con nombres de clases 00:28:13
Y en lugar de campos de tablas 00:28:16
Trabajas con nombres de propiedades 00:28:19
La sintaxis es similar 00:28:21
¿Vale? 00:28:23
Pero bueno, un join es de SQL 00:28:25
A ver, se usa mucho, ¿eh? 00:28:27
El join es... 00:28:33
Es el periódico que no lo usaba 00:28:34
Porque escribíamos 00:28:35
O algo así, ¿no? 00:28:38
A ver, puede ser 00:28:40
No lo sé 00:28:42
a mí el join, pues yo qué sé, si me gusta 00:28:46
entre que no lo vimos 00:28:48
y que no me acuerdo casi nada de ese culo de algo 00:28:50
pero 00:28:52
no tenemos que aprender 00:28:53
nosotros nada, por eso lo que os he 00:28:58
dicho siempre es, teniendo las nociones 00:29:00
básicas, cuando uno tiene que hacer una consulta 00:29:02
más compleja 00:29:04
pues la pide a alguien que se la haga 00:29:05
si es que trabajamos así, por qué vamos 00:29:08
a negarnos 00:29:10
a eso, eso sí, hay que 00:29:12
tener las nociones básicas 00:29:14
¿Vale? Y hombre, la noción básica del join 00:29:15
Aunque no lo vierais 00:29:18
El año pasado, pues más o menos 00:29:20
Si ChaGPT os hace una consulta con un join 00:29:21
La entendéis 00:29:24
Está ligando una tabla con otra a través de un campo 00:29:25
¿Vale? Entonces 00:29:27
Vamos a hacer este método 00:29:29
Este servicio 00:29:34
En nuestra clase de servicios 00:29:38
Vale 00:29:40
Este servicio de aquí era 00:29:50
A mí me había gustado 00:29:52
Y por eso lo había cogido 00:29:55
Porque te devuelve 00:29:56
Datos que pertenecen a diferentes 00:29:58
Tablas y clases 00:30:01
Porque JPQL cuando recuperas 00:30:02
Una lista de equipos 00:30:05
Por ejemplo, o un jugador 00:30:07
Pues es muy fácil porque pones 00:30:09
Select, jugador 00:30:11
O select equipo 00:30:13
Y ya está 00:30:14
Y nada más 00:30:15
Pero cuando quieres coger datos de diferentes clases 00:30:17
Ya se complica un pelinín 00:30:21
Vale, pues este método 00:30:23
que queremos que haga, tiene que coger 00:30:25
el ranking 00:30:27
que tiene 00:30:29
¿por qué entiende esto? 00:30:30
tiene que 00:30:34
coger de un jugador 00:30:35
no, a ver 00:30:37
tú le das un videojuego 00:30:40
y te devuelven los jugadores que juegan 00:30:42
a ese videojuego 00:30:46
su nombre y su nivel 00:30:47
y su puntuación 00:30:48
nombre, nivel, puntuaciones, por ejemplo 00:30:50
lo que queramos nosotros que devuelva 00:30:53
pero en cualquier caso 00:30:55
Van a ser datos que están en diferentes clases 00:30:56
Nivel 00:30:59
No sé dónde está 00:31:00
Nivel está en jugador videojuego 00:31:02
Pero el nombre del jugador 00:31:05
Está en jugador 00:31:07
Con lo cual aquí 00:31:08
Se nos plantea la primera duda 00:31:10
Que es el select, ¿qué hace? 00:31:11
Select jugador, select jugador videojuego 00:31:13
Select, tiene que hacer un select 00:31:16
De diferentes clases, distintas 00:31:18
Bueno, entonces 00:31:20
¿Nosotros qué hacemos aquí? 00:31:22
Pues se la pedimos obviamente 00:31:25
HGPT, o a Gemini o a la Q6 00:31:26
¿Vale? No en el examen 00:31:28
Pero yo en el examen no os pongo consultas difíciles 00:31:30
Pero en vuestra vida, pues lógicamente 00:31:32
Es lo que hacéis, ¿no? 00:31:34
Vale, entonces 00:31:36
Aquí os daría 00:31:37
Una consulta, bueno, pero vamos a hacer la consulta 00:31:42
Transact, bueno, aquí no haría 00:31:48
Falta porque es una consulta, pero bueno 00:31:51
Claro, es una query, entonces no haría 00:31:53
Falta, pero bueno, vale, entonces aquí 00:31:57
Hay que hacer una query 00:31:59
Create 00:32:01
Create query 00:32:04
Porque esto no lo puedo hacer por find ni por nada 00:32:08
Vale 00:32:11
Y aquí en create query 00:32:14
Pues ya tengo que poner todo lo que 00:32:17
Tengo que poner aquí y luego ya 00:32:19
El get results, etcétera 00:32:21
Y ahora es cuando tengo el rollo de la query 00:32:22
Vale, entonces, de la query yo que quiero 00:32:24
Quiero el nick del jugador 00:32:27
El equipo al que pertenece 00:32:29
El nivel al que está jugando 00:32:31
Y en qué posición 00:32:33
O sea, cosas que pertenecen 00:32:34
A diferentes entidades 00:32:37
¿Vale? ¿A cuántas? 00:32:39
A jugador videojuego 00:32:41
A jugador videojuego pertenece la posición 00:32:42
A jugador normal 00:32:45
Pertenece 00:32:48
El nick 00:32:50
A equipo pertenece el nombre 00:32:52
Es decir 00:32:56
Yo voy a seleccionar de varias tablas 00:32:57
esto es lo que Manoli, digo yo que lo haría 00:32:59
multitabla entonces, haría un front 00:33:01
con todas las tablas a mogollón 00:33:03
bueno, a ver 00:33:04
no sé, a mí me parece más cómodo escribir con el join 00:33:09
pero vamos, que viene a ser un poco lo mismo 00:33:11
entonces aquí 00:33:13
en nuestro select 00:33:17
pues haríamos, para hacer el 00:33:19
multilínea este de aquí 00:33:21
el multilínea de aquí 00:33:23
recordad que tenéis que tenerlo 00:33:25
Habilitado por encima 00:33:27
Porque como hay veces en función de 00:33:29
El plugin de Maven, si uno no se da cuenta 00:33:31
Igual te lo pone en la versión 1.8 00:33:33
Vete a saber en cuál 00:33:35
Porque la 1.8 00:33:36
Tuvo mucho 00:33:38
Mucho poder 00:33:40
Si en el POM 00:33:43
Tú en el POM puedes configurar 00:33:46
En el Eclipse 00:33:50
A ver, en el Eclipse 00:33:51
Pues no lo sé 00:33:52
A mí no sé, a mí me lo crea 00:33:55
creo que en la 17, ah no, en la 17 00:33:57
cuando lo hago con Spring Boot, claro 00:33:59
pero 00:34:01
pero a mí me lo crea en la 1.8 00:34:02
pero yo mi Eclipse llevo sin actualizarla 00:34:05
no sé si un año por ahí 00:34:07
en la 1.8, entonces cuidado porque en la 1.8 00:34:08
hay cosas que no funcionan 00:34:11
pero a ver, son cosas chorras 00:34:13
vale, pues aquí entonces 00:34:15
a ver, te da error porque igual 00:34:16
no tienes la versión de 00:34:21
es que puedes haber cambiado la máquina virtual 00:34:23
pero haber cambiado el nivel de compilación, ten cuidado 00:34:25
Eso importa del nivel de compilación 00:34:27
Pero a mí se me cambia 00:34:29
Se me cambia los dos 00:34:30
O sea, cuando yo en el 00:34:33
En el POM 00:34:35
En el JRE System Error y cambio la versión 00:34:37
Arriba en el proyecto también me la cambia 00:34:39
¿El nivel de compilación te lo cambia también? 00:34:41
¿Tú te metes en Compiler y te cambia el nivel? 00:34:44
Sí, sí, sí, pone 21 00:34:46
Ah, pues la primera vez que lo veo 00:34:46
Yo lo tengo que cambiar siempre a mano 00:34:48
A menos que lo tenga especificado en el POM 00:34:50
No sé 00:34:53
Bueno, pues si tu nivel de compilación está 00:34:54
Del bla bla bla hacia arriba 00:34:56
Que no se cual es 00:34:58
Que debería funcionar 00:34:59
Vale pues entonces aquí vamos a seleccionar un montón de cosas 00:35:01
Vamos a seleccionar el nick 00:35:04
Hemos dicho 00:35:06
Vamos a seleccionar 00:35:07
El nombre 00:35:09
El nombre 00:35:12
Equipo 00:35:18
Equipo 00:35:19
Entonces equipo 00:35:20
Nombre, nivel 00:35:21
Y posición en la que juega 00:35:24
O sea, el nombre del tío, nick del videojugador 00:35:26
Equipo en el que juega 00:35:29
Nivel en el que está jugando 00:35:31
Y la posición 00:35:33
Ahora tendremos que complementar esto 00:35:33
¿De dónde? Pues de varios sitios 00:35:36
Entonces, nivel y posición de jugador videojuego 00:35:38
¿No? 00:35:41
Jugador videojuego 00:35:42
Recordad que aquí es obligatorio un alias 00:35:44
Siempre 00:35:47
Entonces, nivel viene de jugador videojuego 00:35:47
Y posición viene de jugador videojuego 00:35:50
Vale 00:35:53
Pero no solo de jugador videojuego 00:35:53
Habrá que hacer un join 00:35:56
¿Verdad? 00:35:58
Habrá que hacer un join ¿Con quién? 00:35:59
Con jugador 00:36:02
Nick viene de 00:36:05
El jugador, es una propiedad de jugador 00:36:07
Join 00:36:10
Y aquí hazme también 00:36:11
Un join de 00:36:14
Equipo 00:36:16
Equipo 00:36:17
Le tengo que poner el alias 00:36:19
obligatorio y ahora me queda así 00:36:22
vale, a ver 00:36:24
bueno, me falta el web 00:36:26
no, no, en los joins 00:36:37
en los jv.jugadores 00:36:38
ah, jv 00:36:41
join, ah, vale, vale, vale 00:36:45
sí, sí, sí, sí 00:36:47
sí, sí, sí, unerjoin, sí, sí, perdón 00:36:48
estoy poniendo la 00:36:51
JV jugador 00:36:52
Sí, sí, sí 00:36:54
Join 00:36:56
Lo estoy poniendo porque va a multitabla 00:37:02
Estoy mezclando las dos cosas, vale 00:37:04
Join con 00:37:06
Punto 00:37:11
Es jugador, ¿verdad? 00:37:12
Porque 00:37:16
¿Eh? 00:37:18
Poniéndole el alias 00:37:21
Y ahora aquí sería 00:37:22
J.equipo 00:37:25
Alias 00:37:30
Vale 00:37:32
Y ahora, where 00:37:33
Jugador 00:37:35
Le voy a coger de aquí, pero si no me voy a equivocar seguro 00:37:37
Que hay que escribir mucho 00:37:39
Donde el id de videojuego 00:37:41
Sea el parámetro 00:37:48
Que me están pasando a mí 00:37:50
Recordad que dos puntos y el nombre 00:37:52
Que a uno le dé la gana, cualquier nombre 00:37:54
Es como la interrogación 00:37:56
Entonces, el jugador videojuego 00:37:57
O sea, el id es este 00:38:00
El id es este 00:38:04
Entonces a través de este id ya me voy arriba 00:38:06
Con los join 00:38:08
Y voy cogiendo 00:38:09
El nombre de equipo 00:38:12
El nombre de jugador 00:38:14
El nick 00:38:16
Del jugador 00:38:18
Y el 00:38:19
Y estos dos de jugador videojuego 00:38:21
Vale, esta es la que manda en la cadena 00:38:23
El jugador videojuego 00:38:25
Y ahora, aquí había puesto además 00:38:26
ordenar por posición, pero 00:38:29
bueno, podemos ordenar o no. 00:38:32
Venga, vamos a ponerle el order 00:38:34
que está puesto aquí. 00:38:35
Y aquí 00:38:39
esto siempre hay que pensar con 00:38:39
nombres de clases. 00:38:41
Claro. 00:38:44
No, no, no. Esto 00:38:45
es ciego para el SQL completamente. 00:38:47
O sea, es SQL 00:38:49
pero piensa nombre de 00:38:51
propiedad, nombre de clase. 00:38:53
SQL está 00:38:55
vale. 00:38:57
Y ahora, esta es la clave. Vale, esta es la sentencia, creemos que está bien. Bueno, no sé si lo he adaptado al... Sí, se llaman así, ¿no? Nivel, W, videojuego, jugador. Si no, me va a decir, no encuentro el campo, no encuentro algo. 00:38:59
y ahora aquí viene la clave 00:39:15
que es recordar que en la query 00:39:17
después de la coma hay que poner 00:39:19
la clase a la que va a pertenecer 00:39:20
lo que me devuelva 00:39:23
pero lo que me devuelve no pertenece 00:39:24
a ninguna clase 00:39:27
no es jugador, no es un equipo 00:39:28
entonces aquí no puedo poner jugador.class 00:39:30
o equipo.class 00:39:32
entonces para Java 00:39:34
esto que es 00:39:37
o para JPA esto que va a ser entonces 00:39:38
un array de objetos 00:39:40
como no hay una clase que case con esto 00:39:42
Esto no son las propiedades de un jugador 00:39:45
Esto no son las propiedades de un equipo 00:39:47
Esto no es, como no hay una clase que case con esto 00:39:48
Esto para mí va a ser un array de objetos 00:39:51
¿No te gustan los arrays? 00:39:53
¿Vale? 00:40:02
No, hazlo 00:40:05
Vale, a ver 00:40:06
Sí, sin paréntesis, ¿verdad? 00:40:13
Ah, sí, me he puesto el paréntesis ahí que no me gusta. 00:40:14
Vale, entonces. 00:40:25
Y ahora, el resultado es una lista de todos estos. 00:40:32
Es una lista de todos estos. 00:40:37
Una lista de a raíz de objetos. 00:40:42
y me falta el get result list 00:40:46
ahí 00:40:58
vale 00:41:00
y ahora ya los muestro 00:41:01
y el return, me falta el return 00:41:04
el para 00:41:06
ah si, el fijar el parámetro, me falta el set 00:41:08
parameter 00:41:11
la posición 00:41:13
Lo voy a llamar por el nombre 00:41:15
Que me gusta más 00:41:17
El parameter este 00:41:18
Videojuego 00:41:20
Vale 00:41:24
Y get result 00:41:25
Return result 00:41:28
Por no ponerlo arriba y ya está 00:41:31
Vale, entonces 00:41:32
Ahora ya yo entro en el main 00:41:38
Entro dentro de aquí 00:41:39
Y se acabó, no pasa nada 00:41:41
Pero 00:41:43
Entonces 00:41:46
cada objeto de esta lista 00:41:49
es todo un paquete 00:41:51
es todo un paquete de NIC equipo a nivel y posición 00:41:52
cada uno de ellos 00:41:55
es un objeto 00:41:59
a ver, esto como es un SELE te da una lista de registros 00:42:00
cada registro 00:42:05
es un array de objetos 00:42:07
un registro es un array de objetos 00:42:09
y que tiene ese array de objetos 00:42:13
NIC equipo a nivel y posición 00:42:15
vale 00:42:17
Bueno, a ver, claro 00:42:20
Es un array de objetos 00:42:29
Es decir 00:42:30
Cada resultado de este select 00:42:33
Que tendrá muchos, por eso es una lista 00:42:35
Es un array 00:42:37
De objetos 00:42:39
Él lo mete en object 00:42:40
Porque lo que tú hayas hecho aquí 00:42:42
No sabe qué es, puede ser un string, puede ser un int 00:42:44
Puede ser a través de un objeto 00:42:47
Nick, por ejemplo 00:42:48
Es un string 00:42:49
Pero equipo es un objeto entero 00:42:51
Nivel es unid 00:42:54
Y posición es unid 00:42:56
Entonces dice, pues una raíz de objetos 00:42:58
Para cada 00:43:00
Elemento de la lista 00:43:01
Una raíz de object, porque lo que va a caer 00:43:03
Ahí dentro no lo sabe 00:43:07
Podrías poner equipo.class 00:43:07
O jugador.class 00:43:10
Claro, es lo que pondríamos 00:43:11
Y entonces aquí pondrías 00:43:13
Select equipo 00:43:15
pero 00:43:16
a ver es que igual 00:43:24
hemos puesto mal 00:43:29
quiero parar esto 00:43:31
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Segundo Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
5
Fecha:
1 de febrero de 2026 - 19:08
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
43′ 34″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
192.61 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid