Saltar navegación

20260226 Repaso_4 - 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

Repasito. Vamos a acabar 00:00:00
el repasito. 00:00:01
Venga. Bueno, pues 00:00:04
las anotaciones 00:00:05
que nos interesan, pues ya están. 00:00:08
Esto era lo más retorcido, en realidad. 00:00:10
Una clave ajena 00:00:12
que tenía una clave primaria 00:00:13
que es compuesta y entonces la sacamos 00:00:15
a lo más retorcido. Por lo demás 00:00:17
ya está. Y ahora ya 00:00:19
aquí, como no tenemos a Spring, 00:00:21
que 00:00:24
nos lo haga todo, que es el sueño 00:00:25
de Ana de toda la vida. 00:00:27
un botoncito y pin, todo hecho 00:00:28
pero entonces tú no vas a tener trabajo 00:00:30
si hay un botoncito, pin y todo hecho 00:00:32
yo también 00:00:34
cuando digo tú, tú ni nadie 00:00:34
no nos interesa tanto 00:00:37
pero no tiene nada que ver 00:00:39
la clave compuesta es para la tabla intermedia 00:00:45
claro, la clave compuesta es para la tabla intermedia 00:00:48
que tiene los dos one to many 00:00:50
los dos many to one, one to many 00:00:51
lo que no entra es el many to many 00:00:53
que es precisamente cuando no hay 00:00:55
Claro, la tabla intermedia 00:00:57
si hay una relación de muchos a muchos, la tabla siempre 00:01:09
tiene que estar, siempre, porque 00:01:11
el modelo relacional no puede funcionar a muchos 00:01:13
sin tabla, entonces, eso lo puedes 00:01:15
mapear con entidad intermedia o no 00:01:18
si lo mapeas con entidad intermedia 00:01:19
entonces ahí no hay many to many 00:01:22
hay dos one to many 00:01:23
y ese es lo que hemos usado 00:01:24
nosotros y en ese caso es cuando está 00:01:27
la clave compuesta y todo eso 00:01:28
entonces, si no hay entidad 00:01:30
intermedia, que tabla sí 00:01:32
pero entidad no, porque no hay 00:01:34
campos 00:01:37
adicionales, si no hay campos adicionales 00:01:38
no tiene por qué haber entidad intermedia 00:01:41
dos one to many, perdón 00:01:43
esta una lista de esta 00:01:45
y esta una lista de esta, entonces ahí es donde 00:01:46
está el many to many, vale 00:01:48
pero eso como tal, como ejemplo 00:01:50
no lo hemos visto en un proyecto que lo hayamos graficado 00:01:52
por eso la anotación many to many 00:01:55
que es la que se usa en ese caso 00:01:57
cuando no usamos la entidad intermedia 00:01:58
esa es la que no 00:02:01
voy a poner, ¿vale? 00:02:02
eso es la que no 00:02:04
que en realidad hace la aplicación mucho más sencilla 00:02:05
hay el único matiz 00:02:09
porque tienes dos listas o ya está 00:02:10
hay el único matiz 00:02:13
que hay que tener en cuenta es lo que le comentaba él antes 00:02:14
que en la many to many tú puedes elegir 00:02:16
he quitado ya este 00:02:18
lo que hemos comentado antes 00:02:20
En la many to many tú puedes elegir 00:02:22
Lo que estábamos diciendo 00:02:25
¿Dónde pones esto? 00:02:26
Y esa es la que conviertes 00:02:29
En propietaria 00:02:31
Y entonces tienes que ser consciente de eso 00:02:32
Para que luego si no te actualiza desde el otro sitio 00:02:34
Que entiendas por qué es 00:02:37
¿Vale? Eso es lo único 00:02:38
No, un jointable lo pones solo en un sitio 00:02:39
En el otro pones el mape 00:02:45
Los dos sitios 00:02:46
Bueno, pues la anotación 00:02:48
many to many, pero ¿qué hacéis? 00:02:56
Pues el panorama 00:02:59
No, ni quiero verlo, me lo tapa 00:03:00
el monitor y no quiero verlo porque 00:03:06
Anda, se ha sacado una 00:03:08
No, no, ha sacado 00:03:10
O sea, has hecho así y de una palmera 00:03:11
has convertido en todo eso 00:03:14
si es capaz de hacer eso 00:03:16
deja el ciclo porque no te hace ninguna falta 00:03:21
bueno 00:03:22
entonces, y además se ha quedado grabado 00:03:24
las anotaciones ya están 00:03:27
las que entran y lo que vamos a ver y más o menos 00:03:30
todo entendido, ya está 00:03:32
ahora, ¿qué tenemos que hacer aquí? 00:03:34
pues como no tenemos a Spring 00:03:36
que es el del botoncito 00:03:38
que pum, ya tengo el repositorio 00:03:39
tengo prácticamente todo hecho, lo tengo todo 00:03:42
pues hacemos 00:03:44
aquí en una arquitectura de esta 00:03:45
sí que habría un DAO hecho por nosotros 00:03:48
pero aún así ya 00:03:50
respecto a JDBC 00:03:52
esta primera capa nos facilita 00:03:56
las cosas un montón, ¿por qué? 00:03:58
por el mapeo objeto relacional 00:04:00
que es la ventaja del JPA 00:04:02
el mapeo objeto relacional 00:04:04
ya está, pues entonces nuestro DAO 00:04:06
nuestro find all 00:04:08
que en el otro caso era 00:04:10
un verdadero galimatías por el 00:04:12
mapeo, ResultSet 00:04:14
a objeto, aquí se 00:04:16
queda en un 00:04:18
query de JPQL y ya está. 00:04:19
¿Vale? Entonces aquí 00:04:23
he escrito esto para que no se nos olvide. 00:04:24
Entonces, la query, JPQL, 00:04:26
lo mismo. No 00:04:29
sabemos de qué va el JPQL, 00:04:30
pero lo conocemos en profundidad. 00:04:32
Lo que sí que sabemos más o menos 00:04:35
de memoria, que eso sí es, 00:04:36
pues, ¡cállate el ruido! 00:04:38
Lo que sí que sabemos más o menos 00:04:41
de memoria es hacer 00:04:42
select de entidades enteras 00:04:44
de entidades enteras 00:04:47
pues olvidados del list 00:04:48
select de la entidad entera 00:04:49
¿vale? 00:04:52
eso sí 00:04:53
dices que no pueden ser list 00:04:54
y luego devuelves una list 00:04:58
¿cómo que no pueden ser list? 00:04:59
cuando he dicho que no pueden ser list 00:05:02
o sea este findol es el del DAO 00:05:03
que me devuelve muchas sedes 00:05:05
porque es un findol 00:05:07
que tiene que ser set 00:05:08
no, pero ¿por qué tiene que ser set esto? 00:05:09
o sea no, tú dices que cuando haces 00:05:12
Sí, pero es que leéis antes de tiempo 00:05:13
os he dicho yo que leáis 00:05:18
Pues lo he puesto aquí para que no se me olvide 00:05:20
lo que tengo que decir ahora 00:05:25
pero no he dicho a nadie que lea estos comentarios 00:05:26
Vale 00:05:29
El último día de clase me cargo la pizarra 00:05:30
Vale 00:05:37
Entonces, estábamos conceptualmente todavía en un paso anterior 00:05:38
y es que el find all se queda muy fácil 00:05:43
porque la JPQL 00:05:44
ya me da el objeto entero 00:05:46
no tengo que hacer las resources 00:05:49
de ahí mapear y estábamos diciendo 00:05:50
de JPQL pues 00:05:53
uno puede hacer millones de consultas 00:05:54
super chachis 00:05:57
pero pues necesitamos a alguien que nos ayude 00:05:57
¿no? como 00:06:01
Gemini o GPT o alguien 00:06:02
pero hombre lo básico si sabemos 00:06:04
que es coger un objeto enterito 00:06:06
¿vale? 00:06:09
un objeto enterito, que recordad que la alias 00:06:10
es obligatoria, recoger 00:06:12
un objeto enterito 00:06:14
con un web, la condición 00:06:15
que sea 00:06:18
y que ocurre, que si ese 00:06:18
objeto 00:06:22
como en este caso que estoy cogiendo la sede 00:06:22
si ese objeto tiene 00:06:26
cosas colgando 00:06:28
y yo las quiero 00:06:29
tengo que hacer el left join 00:06:31
porque si no hago el left join es casi 00:06:33
de las poquitas cosas que si se nos han quedado 00:06:36
en la cabeza 00:06:38
vale, entonces 00:06:38
si yo hiciera aquí 00:06:40
aquí, gracias 00:06:42
si yo quito estos left join 00:06:44
este objeto 00:06:46
ese que me devuelve en el let result list 00:06:50
no tendría los 00:06:52
departamentos y los proyectos 00:06:54
claro 00:06:55
si, si, si, claro, vale 00:06:56
entonces 00:07:04
si yo quiero 00:07:05
que los cargue todos, aquí hay dos 00:07:08
cosas. Podría 00:07:10
ser el left join sin el fetch y con el 00:07:12
fetch. Vale. 00:07:14
En el left join, si yo 00:07:16
no pongo el fetch, es simplemente 00:07:17
no me lo carga, porque yo 00:07:19
quiera usar los campitos 00:07:22
de aquí para los web, 00:07:24
para ponerlo aquí dentro de la JPQL. 00:07:26
Entonces, si yo aquí dentro de la JPQL 00:07:28
quiero poner también 00:07:30
pues campos de aquí 00:07:32
para la búsqueda, para lo que sea, 00:07:33
pues hago el left join para incluir 00:07:36
todo esto. Pero 00:07:38
si además quiero que me lo cargue 00:07:39
en el resultado, si además quiero que 00:07:41
me lo cargue y este 00:07:43
es un list de sedes, tenga la sede 00:07:45
con todo lo que le cuelga 00:07:47
pues si además quiero eso 00:07:49
era por 00:07:51
lo que poníamos el fetch, porque si no 00:07:53
no, entonces me fuerza la carga 00:07:55
independientemente del lazy, del eager, de lo 00:07:57
que sea, ¿vale? 00:07:59
Y ya está 00:08:04
eso es más o menos lo básico de 00:08:05
JPQL que tenemos en la cabeza 00:08:07
que luego queremos hacer otras cosas 00:08:09
podemos hacer mil cosas, por ejemplo 00:08:11
pues vimos, cuando yo quiero coger 00:08:13
no solamente una entidad 00:08:15
sino campos sueltos de muchos sitios 00:08:17
pues ahí 00:08:19
la entidad de retorno 00:08:20
no era 00:08:23
sede.class o la que fuera 00:08:25
sino la lista de object 00:08:26
¿recordáis? una lista de objetos 00:08:28
object, que está en uno de los ejemplos 00:08:31
subidos 00:08:33
ese es un caso más retorcido 00:08:33
pero bueno, y luego yo ya esa lista de 00:08:37
objetos, la mapearía 00:08:39
donde yo quisiera 00:08:41
entonces el find all 00:08:41
aún teniendo lo que hacer a mano, porque esto no es sprint 00:08:54
entonces como no es sprint, lo tengo que hacer a mano 00:08:56
pues es mucho más sencillo 00:08:58
porque ya la parte del mapeo se queda hecha 00:09:00
y ya está, y aquí yo me saco todas las sedes 00:09:02
y ya lo tendría, dime 00:09:05
Sí 00:09:06
Sí, porque está en Fetch 00:09:11
¿Vale? 00:09:13
Vale 00:09:15
Que arrastra 00:09:16
O sea, no solamente 00:09:20
Únemelo para las consultas 00:09:22
Sino además 00:09:23
Fetch no es 00:09:24
Pégamelo 00:09:27
Póngamelo encima, no es algo así 00:09:29
Ah, sí 00:09:31
Estaba pensando que te referías a eso 00:09:34
Depende 00:09:36
Del Lazy 00:09:38
O del líder 00:09:39
Pero a la sede 00:09:40
Pero a la sede 00:09:47
Luego cuando cargan los departamentos que cuelgan de la sede 00:09:48
Pues lo que carga de él 00:09:51
Dependerá 00:09:54
Pero bueno, de todas formas 00:09:54
Aquí hay un montón de 00:09:57
Casuísticas extrañas 00:09:59
Que realmente es muy complicado 00:10:02
Tenerlas en la cabeza 00:10:04
Más o menos sabemos 00:10:05
pues qué significa el lazy, qué significa 00:10:08
el ledger in face, más o menos lo sabemos 00:10:10
luego cuando uno hace algo en concreto 00:10:12
luego tiene que comprobar, ah, sí me lo ha hecho bien 00:10:14
no me lo ha hecho bien, ah, pues voy a cambiarle 00:10:16
esto, que son muchas casuísticas 00:10:18
que no las tiene uno en la cabeza 00:10:20
todas de, para que me funcione así 00:10:21
no tengo que hacer así, más o menos las ideas 00:10:24
¿vale? 00:10:26
entonces, respondiendo a tu pregunta 00:10:29
pues lo que tenga 00:10:30
cada uno de los departamentos 00:10:32
que cuelgan de sede, ¿qué es lo que habrá cargado? 00:10:34
Pues, entiendo que eso ya viene regido por la propiedad Fetch Type. Pero se podría probar, a ver, se podría, pero recordad, recordad que ese Lazy, ese Eager, ese de ahí, si tú estás dentro del contexto de persistencia, da igual, no afecta nada. 00:10:36
Porque dentro del contexto de persistencia, aunque tengas un lazy, si luego tú no pides, te lo va a cargar. El lazy significa en qué momento te lo cargo, al principio o después. Luego, en el contexto de persistencia, es que en realidad te da igual el lazy o el libre. El problema es si lo has cerrado. Y el contexto de persistencia lo cierras luego en el servicio, aquí no. 00:11:04
porque bueno, esa arquitectura 00:11:23
claro, aquí que es lo que 00:11:26
era la arquitectura que usábamos, más o menos lo estándar 00:11:28
el DAO 00:11:30
no se ocupa de las transacciones 00:11:31
no decide qué cosas se hacen 00:11:34
juntas y qué cosas se hacen 00:11:36
separadas, no lo decide 00:11:38
el qué cosas se hacen 00:11:39
juntas, qué consultas juntas y qué consultas 00:11:42
pueden ir por libre, eso lo decide 00:11:44
el caso de uso, la funcionalidad 00:11:46
el requisito, el DAO te hace 00:11:48
cosas atómicas, al DAO le dan 00:11:50
igual las transacciones, el DAO te dice 00:11:52
tú pásame 00:11:54
un contexto de persistencia 00:11:56
que se lo pasábamos como propiedad 00:11:58
al DAO 00:12:00
que está aquí por constructor 00:12:02
porque esto no es Spring 00:12:04
y aquí él dice 00:12:05
vale, pues yo 00:12:08
en este contexto de persistencia que tú me has pasado 00:12:09
que no sé si antes había hecho 00:12:12
mil cosas y después hará mil 00:12:14
no lo sé, en este que me has pasado 00:12:15
yo te hago esto, luego 00:12:18
el servicio ya decide 00:12:20
como ese contexto de persistencia 00:12:21
cuando lo abre y cuando lo cierra 00:12:24
y cuando el contexto de persistencia 00:12:26
esté cerrado 00:12:29
ahí es donde todo lo que tú hayas cargado 00:12:29
como lazy 00:12:32
es irrecuperable 00:12:33
dentro del contexto de persistencia da igual 00:12:35
el lazy, el eager, es que da igual 00:12:38
pero bueno, vamos a lo sencillo 00:12:40
entonces 00:12:42
esta la entendemos, es un find all 00:12:43
para devolver todas las sedes con todas sus cosas 00:12:46
ya está 00:12:49
Devolverla 00:12:50
Hombre 00:12:51
O sea, que de aquí solo 00:13:03
Te cogiera 00:13:05
Hombre, pues entonces 00:13:07
Claro, cambiarías aquí 00:13:14
Lo que obtienes 00:13:15
Podrías poner comas con cosas 00:13:17
Entonces claro, desde el momento en que lo que hay en el from 00:13:19
Ya no es una única entidad completa 00:13:22
Una única entidad completa 00:13:24
Sino que tienes campos sueltos 00:13:25
es cuando ya 00:13:27
lo que devuelves 00:13:28
se convierte en esto 00:13:30
en un object.class 00:13:32
en esto 00:13:36
se convierte en esto 00:13:38
y cada posición de este array 00:13:44
es cada una de las cositas 00:13:46
que estén aquí 00:13:49
a ver, es que la sede 00:13:49
teniendo un objeto de departamento. 00:13:59
Entonces, ¿tú cómo 00:14:01
fijas ahí 00:14:02
pero del departamento solo consultame 00:14:03
esto? 00:14:07
Hombre, puedes encadenar consulta, 00:14:08
pero es que 00:14:10
estarías devolviendo un objeto. Entonces, ¿devolver un objeto 00:14:14
a medias? ¿Eso para qué? 00:14:16
Claro. 00:14:19
Otra cosa sería esa, que yo quiero 00:14:20
consultar un nombre, pero no un 00:14:22
objeto que solo tiene el nombre. Son dos cosas 00:14:24
diferentes. Hacer un select del nombre 00:14:26
o hacer un select de un objeto, pero 00:14:28
de ese objeto solo me interesa que rellenes el nombre. 00:14:30
Eso segundo es más raro. 00:14:32
Bueno, sí, pero el DTO 00:14:36
en cualquier caso se llena con 00:14:38
lo que te pongas aquí. 00:14:40
Claro. 00:14:41
Bueno, pues entonces, 00:14:46
¿qué ocurre con esta consulta? Que es por lo que viene 00:14:47
esto de aquí. Entonces, 00:14:50
que si ejecutáis, 00:14:53
¿vale? Si en la misma query 00:14:55
ponéis varios de estos, 00:14:57
no admite que sea en list 00:15:00
a ver, admitiría que sea en list 00:15:02
pero entonces hay que hacer la query de otra manera 00:15:06
hacer otras cosas 00:15:08
entonces lo más sencillo, si hacéis varios de estos 00:15:09
no admite que sea en list 00:15:12
entonces no pasa nada, se cambian a set 00:15:14
y se acabó 00:15:16
es decir 00:15:17
sede 00:15:19
no puede tener una lista de departamentos 00:15:21
una lista de proyectos sede 00:15:25
poder puede 00:15:26
pero si tú los tratas de cargar 00:15:27
con dos left join 00:15:30
simultáneamente en la misma query 00:15:31
no puedes, si son los dos listas 00:15:34
si lo hacemos en consulta 00:15:37
JPQL consecutiva, sí 00:15:38
pero en la misma query 00:15:40
pues no se puede 00:15:42
en verdad no te afecta tenerlo listo 00:15:43
porque los datos de cada tabla son distintos 00:15:46
claro, es que te da igual 00:15:48
te da lo mismo 00:15:50
claro 00:15:52
te da lo mismo porque 00:15:54
no va a haber duplicados 00:15:56
porque como el criterio de igualdad es la clave primaria 00:15:58
no va a haber duplicados, que es la única ventaja de la list 00:16:00
que puede haber duplicados 00:16:03
y bueno, pues 00:16:04
que puedas tú jugar con las posiciones 00:16:05
si te interesa 00:16:09
entonces sí, pero si no nos interesa jugar con las posiciones 00:16:10
pues nos da igual que sea 00:16:13
set que no, vale, pues entonces 00:16:14
en este caso, automáticamente 00:16:16
ya esto se queda más sencillo 00:16:19
le metemos el entity manager y el servicio 00:16:20
es el que ya 00:16:23
decide cómo hace las cosas 00:16:24
ya lo que sea 00:16:26
pues en este caso, pues 00:16:28
se quedaría igualito que el otro 00:16:30
¿vale? copia y pegada, el servicio sería el mismo 00:16:32
pero el servicio 00:16:34
el método servicio 00:16:36
es el que coge aquí el contexto de 00:16:37
persistencia 00:16:40
¿vale? aquí no he empezado una transacción 00:16:41
porque como es consulta 00:16:44
no hace falta 00:16:46
¿vale? si fuera un método de actualización 00:16:47
siempre haríamos una transacción 00:16:50
y aquí el servicio pues ya decide 00:16:51
en qué momento cero la transacción, lo que sea 00:16:54
pues bueno, esta es la arquitectura que usábamos 00:16:56
con el JPA puro 00:16:58
¿vale? pues eso 00:16:59
pues como estudiaría yo 00:17:01
esto, pues lo mismo 00:17:03
o con este 00:17:06
o con otra base de datos, la de videojuegos 00:17:07
otra que tenéis subida ahí, no me acuerdo 00:17:09
que bases de datos subía al principio cuando puse 00:17:11
bases de datos de repaso 00:17:13
pues lo mismo 00:17:15
me haría aquí daos 00:17:17
que hagan cosas varias que se os ocurran 00:17:19
pues 00:17:22
dame proyectos por 00:17:22
sede 00:17:25
pues dame empleados 00:17:26
por departamento, un find de empleado 00:17:29
by departamento, que te dé un list de empleado 00:17:31
ya está, hacéis unos cuantos de esos 00:17:33
algunos 00:17:35
no hace falta que los hagáis con JPQL 00:17:36
porque con el get ya es suficiente 00:17:39
o con el save si es modificar 00:17:41
o con el remove si es borrar 00:17:43
borrar los datos profesionales 00:17:45
de un empleado 00:17:48
por ejemplo, pues 00:17:48
ponéis algunos de esos 00:17:50
y los hacéis 00:17:53
o sea, me refiero 00:17:54
que JPQL solo hace falta 00:17:57
cuando no es recuperar por clave primaria 00:17:59
actualizar 00:18:02
que ya es el save 00:18:04
o el merge 00:18:06
o borrar, que es el remove 00:18:07
claro, claro 00:18:09
el contexto de persistencia ya tiene el get 00:18:11
para recuperar por clave primaria 00:18:13
y luego ya el remove para borrar 00:18:15
o el delete era, creo, que fuera 00:18:17
y ya está, pero si quiero hacer consultas extrañas 00:18:19
o cosas raras 00:18:22
por otras cosas que nos han quedado, pues JPQL 00:18:22
Sí, efectivamente 00:18:25
Si lo quieres cargar con empleados 00:18:30
Para que estén ahí fuera del contexto 00:18:32
De persistencia AM 00:18:34
Entonces sí, te lo tienes que hacer con la JPT 00:18:36
Pues eso 00:18:38
Pues me haría uno de esos 00:18:40
Daos de empleado 00:18:43
De departamento algunos servicios 00:18:46
Y lo probaría y ya está 00:18:48
Y bueno, esta misma así tal y como está 00:18:49
Funciona, porque no tiene más 00:18:51
Entonces esto ya es un poco más fácil 00:18:54
Que JDBC 00:18:57
Porque 00:18:59
O sea un poquito 00:19:00
Porque aquí no tenemos que hacer el mapeo 00:19:03
Tú haces tu JPQL o lo que sea 00:19:05
Y ya tienes el objeto entero 00:19:07
Bueno 00:19:08
Tienes que anotar 00:19:12
Pero bueno las anotaciones al final 00:19:14
Acaban siendo las mismas más o menos 00:19:17
Vale 00:19:19
Y luego ya que 00:19:21
Salto dimos 00:19:23
Después de esto 00:19:25
pues que lo hiciera 00:19:26
sprint, que eso ya sí 00:19:28
que ahí hay poco que 00:19:30
poca duda que tendréis 00:19:31
porque el modelo es el mismo 00:19:34
el modelo con las anotaciones, tal cual 00:19:35
me da igual que lo esté haciendo con sprint 00:19:38
que sin sprint, me da lo mismo 00:19:40
ahí lo que salta es que me olvido 00:19:41
del contexto de persistencia 00:19:44
me olvido de todo eso 00:19:46
eso sí, me hago un fichero 00:19:47
de propiedades 00:19:50
con todas las propiedades para que sprint tire de ellas 00:19:51
La url 00:19:54
Si quiero que se muestre 00:19:56
Pues todo lo que tenía el persisten 00:19:58
Este de aquí 00:19:59
Para este 00:20:00
Para examen 00:20:04
Copiamos por ejemplo este tal cual 00:20:06
Y lo que tenemos que cambiar es las clases 00:20:08
Y el nombre de la unidad de persistencia 00:20:09
Claro 00:20:12
Entrar aquí para cambiar estas 00:20:13
Lógicamente lo que haga falta cambiar 00:20:16
Claro 00:20:19
Y en sprint 00:20:19
Pues sería 00:20:23
ahí no hay persiste, lo que hay es un fichero 00:20:23
de propiedades con las propiedades 00:20:26
de la base de datos, si quiero que se muestre 00:20:28
se muestre, lo que sea 00:20:30
y el repositorio 00:20:32
y ya está, y luego ya 00:20:34
el repositorio con métodos propios o no 00:20:35
métodos propios 00:20:38
de poner alguno, pues 00:20:40
tenemos 00:20:42
buscar por otros campos que no sean la clave primaria 00:20:43
y alguno 00:20:46
en el que a lo mejor hay que poner alguna query 00:20:48
una query sencilla 00:20:49
un método de repositorio que hacíamos 00:20:51
asociado a una query nuestra propia 00:20:53
y luego ya el service 00:20:55
que ese ya sí que se anota como service 00:20:57
obligatoriamente y todo eso 00:20:59
lo que le toque hacer 00:21:00
y nada más, si es Spring Boot 00:21:02
nos acordamos de que todos los paquetes 00:21:05
cuelgan de donde esté 00:21:08
el arranque, donde esté la clase anotada 00:21:09
con Spring Boot Application 00:21:11
y si no es Spring Boot 00:21:12
pues lo que pasa es que hay que hacer la clase de configuración 00:21:14
que esa es la diferencia 00:21:18
si no era Spring Boot 00:21:19
había que hacer 00:21:21
aquí, alguno de estos tendrá ese 00:21:22
pero este no es Spring Boot 00:21:24
no, este no 00:21:26
pero estamos haciendo lo de Spring Boot 00:21:28
o sea, si pasamos a Spring 00:21:30
que era este modelo, pues 00:21:32
el modelo igual 00:21:34
pero 00:21:36
necesitamos 00:21:38
claro 00:21:40
el repositorio, todo 00:21:42
aquí vimos en este proyecto 00:21:44
que subimos, vimos algunos ejemplos de 00:21:46
métodos propios y ya está 00:21:48
y luego 00:21:50
si no es sprint boot, si no es sprint normal 00:21:51
hay que configurarlo en esta clase 00:21:55
que era un rollo, vale 00:21:56
hay que configurarlo, donde están 00:21:58
los paquetes a partir de los cuales 00:22:00
cojo bin, donde están 00:22:02
los repositorios 00:22:04
vale 00:22:06
las transacciones, hay que configurar todo esto 00:22:07
hay que decirle de donde 00:22:11
saca el 00:22:12
de donde saca el 00:22:14
la fuente 00:22:16
de datos 00:22:19
vale, había que configurar 00:22:19
todo esto de aquí 00:22:22
que estés usando 00:22:24
Spring pero no Spring Boot 00:22:28
que no es lo habitual, si estás usando 00:22:30
Spring Boot esta clase de configuración 00:22:32
desaparece porque lo único que tienes que 00:22:34
hacer es 00:22:36
Spring Boot era, lo he trasladado 00:22:37
aquí, si usas 00:22:40
con Spring Boot lo único que tienes que hacer es 00:22:42
meterlo en un fichero de propiedades 00:22:44
y ya Spring Boot cuando arranque 00:22:48
a partir de la clase base 00:22:51
del paquete base 00:22:55
ahí ya sí que obligatorio 00:22:56
claro, pues cuando arranque ya la aplicación 00:22:57
esta de aquí 00:23:00
pues ya del fichero de propiedades 00:23:01
lo saca todo y ya está 00:23:03
y ya por eso esto nos queda más sencillo 00:23:05
el modelo, el repositorio y el servicio 00:23:07
y ya está 00:23:09
sí, pero 00:23:10
luego, un segundo 00:23:13
ahora ya, ¿desde dónde podemos llamar 00:23:15
a esos servicios? pues igual los podemos 00:23:20
llamar desde un controller 00:23:22
¿vale? puede ser una aplicación 00:23:24
que sea un 00:23:25
API REST 00:23:27
¿vale? que esta es la arquitectura 00:23:28
para hacer nuestros servicios 00:23:32
nosotros, ¿desde dónde 00:23:34
los podemos llamar? hombre, pues podemos hacer 00:23:36
un main o otra cosa 00:23:38
para hacer llamar a los servicios 00:23:40
o lo podemos llamar desde un 00:23:41
API REST y ya está 00:23:43
con su controlador que llama al servicio 00:23:45
y se acabó, el controlador correctamente 00:23:47
anotado con sus 00:23:49
métodos, si es get mapping 00:23:51
post mapping, el que sea, anotado 00:23:53
como 00:23:55
controller, rest controller 00:23:55
su ruta de mapeo 00:23:58
y ya está, no 00:24:00
vamos a hacer nada más, si es desde un 00:24:03
controller, repito, pues tu controller correctamente 00:24:05
anotado, como que 00:24:07
bin, controller, rest controller 00:24:09
ruta de mapeo y los métodos que sean 00:24:11
get y post 00:24:13
y ahí ya vamos a los servicios 00:24:14
y se acabó, ya está 00:24:17
vale, un segundo 00:24:18
eso no lo sé 00:24:19
hombre, cuatro 00:24:25
a ver 00:24:26
claro, a ver, no puede ir junto 00:24:29
una aplicación que tenga 00:24:31
el JPA, que esté estirando 00:24:33
JPA puro y Spring 00:24:35
porque una vez que el problema es que tú lo hayas arrancado 00:24:36
y te puedas hacer pruebas, ya la has liado 00:24:39
entonces ahí ya 00:24:41
a ver 00:24:42
pero yo podría mezclar 00:24:45
JDBC con JPA 00:24:47
eso si puedo 00:24:48
y luego en otro proyecto aparte 00:24:50
Spring 00:24:52
Spring JP 00:24:54
o la meta también 00:24:57
buena pregunta 00:25:01
me acabas de recordar 00:25:03
¿me hacéis un trabajito? 00:25:04
100% 00:25:12
preferís hacerme un trabajo 00:25:14
a ver, quita alguno 00:25:17
no, no, no, de quitar quito 00:25:23
MongoDB 00:25:25
lo otro no, porque lo otro forma 00:25:25
parte del mismo cuerpo de conocimientos 00:25:35
y quiero yo pues 00:25:37
hacerme la ilusión de que lo tenemos 00:25:39
todo en la cabeza ligado una cosa con otra 00:25:41
¿Qué es lo que va a hacer Juanfi? 00:25:43
Bueno, MongoDB 00:25:54
lo quitamos para el examen 00:25:55
¿Qué voy a hacer? 00:25:57
No, no, no 00:26:05
Yo voy a confiar en que 00:26:06
sabéis lo que es MongoDB 00:26:10
que lo habéis aprendido y que sabéis hacer 00:26:12
que me mentís 00:26:14
y no sabéis 00:26:23
el destino os pasará factura 00:26:24
porque 00:26:27
nada es gratis en esta vida 00:26:30
no me entero 00:26:42
Bueno, tú no te agobies 00:26:43
No te estreses 00:26:48
No te estreses 00:26:50
Ya, pero a ver, si es que 00:26:52
De contenido 00:26:58
He quitado ya una burrada 00:26:59
Una barbaridad 00:27:02
Para poder ver todo 00:27:03
Aunque sea un poquitín por encima 00:27:06
He quitado una barbaridad 00:27:07
Vale 00:27:09
Entonces, ¿ya he quitado mucho? 00:27:10
¿En el examen ya quito más? 00:27:18
Pero bueno. 00:27:21
A ver, dudas, cosas. 00:27:23
Algo que queráis que hagamos aquí en este rato 00:27:25
maravilloso que tengamos. 00:27:27
Lo tuyo lo vamos a mirar ahora. 00:27:29
Voy a subir los... 00:27:30
Si me hablas de Postman, me estás hablando de consumir 00:27:40
el API REST 00:27:51
JSON es su lenguaje 00:27:52
de comunicación 00:27:55
Si lo hicimos 00:27:56
No, no, no, a ver, hay dos partes 00:27:58
Aquí tenemos 00:28:03
el API REST 00:28:05
Sería jolazo 00:28:06
¿Qué es el dato más feo? 00:28:09
Un dato. 00:28:14
Un dato es un dato feo, porque era un dato. 00:28:15
Vale, entonces, el API REST. 00:28:19
El API REST se comunica con su consumidor, con el que le consuma. 00:28:24
Puede ser una operación Java o una corriente, quien le consuma, 00:28:31
Aquí eso no lo hemos hecho, que sería muy interesante. 00:28:37
Esto no lo hemos hecho. 00:28:41
Aquí habría que hacer un cliente de API REST. 00:28:42
Pero eso no lo hemos hecho. 00:28:44
Pero en cualquier caso da igual. 00:28:46
Las comunicaciones con él son iguales. 00:28:48
Aquí, o puede ser el navegador, que es lo que hemos usado cuando... 00:28:51
O puede ser POS. 00:28:55
Estas dos son las opciones que hemos puesto. 00:29:01
Entonces, el API REST se consume dentro de estos meses. 00:29:03
Ya sabemos el API REST, el arte, pues lógicamente, 00:29:07
el API REST llama al servicio, patatín, patatán, 00:29:12
a la string data en última instancia. 00:29:15
Y ahora, la parte que tú me preguntabas, 00:29:18
¿cómo le llega la información al API REST y cómo la devuelve? 00:29:21
Es a partir de JSON. 00:29:25
Y esto se tendrá que mapear a entidad Java. 00:29:27
Entonces, ¿quién lo mapea? 00:29:33
Jackson, la librería Jackson 00:29:37
Por eso Sprint 00:29:38
Incluye la dependencia de Jackson 00:29:43
Cuando tú pones la dependencia de Sprint 00:29:44
Y luego te abres en el Mave 00:29:47
En referencias 00:29:49
Lo que te ha puesto ahí la hostia en botes 00:29:49
Pues madre, ya se es Jackson 00:29:52
¿Vale? Entonces 00:29:54
Sprint 00:29:55
Te convierte el JSON en la entidad Java 00:29:57
Que sea 00:30:00
y ahora ya esto 00:30:01
se va ya a las tablas 00:30:03
¿vale? 00:30:06
si esto fuera 00:30:09
MongoDB 00:30:10
esta parte es igual, es JSON 00:30:10
que te transforma del JSON 00:30:13
a las entidades 00:30:15
y ahora ya las entidades 00:30:16
pasan a MongoDB 00:30:19
que sería como pasar a JSON otra vez 00:30:20
entonces han venido en JSON, van a Java 00:30:23
y se van a JSON otra vez 00:30:25
en nuestro caso se cambian 00:30:27
a base de datos 00:30:32
claro 00:30:34
y eso todo lo hace el repositorio 00:30:34
el repositorio 00:30:37
como lo haces con el postman 00:30:42
pues así 00:30:50
como vamos a abrirlo 00:30:52
como lo hemos hecho, tú invocas al controller 00:30:53
a ver, vamos a abrir postman 00:30:56
Nuestro postman 00:30:57
Estaba 00:31:00
Aquí 00:31:02
Vale 00:31:04
¿U? 00:31:06
No, no, no 00:31:10
Vale 00:31:13
Este es nuestro postman 00:31:16
Entonces, voy a abrir rápidamente 00:31:20
Este de aquí 00:31:23
A ver, un segundito 00:31:24
que se abra este. 00:31:34
Porque luego todo esto que hemos hecho con 00:31:40
o sea, por ejemplo, con 00:31:42
JPA, utilizamos el ADO 00:31:44
y con JDBT. 00:31:46
O sea, hacemos un package 00:31:50
que es con tanto, es con todo. 00:31:51
Y ahí tenemos un main. 00:31:53
Efectivamente 00:31:54
Al controller en realidad 00:31:59
Le da igual si ese servicio 00:32:01
Se ha hecho con sprint también 00:32:03
O lo que pasa es que normalmente 00:32:06
Ya, pero que tú puedes hacer 00:32:07
Puedes usar sprint 00:32:15
Que es lo que normalmente hacemos 00:32:16
Para hacer el controlador 00:32:18
Pero luego el controller no es obligatorio 00:32:19
que en sus métodos llame a un servicio hecho con 00:32:23
Spring, puede llamar a quien le dé la gana. 00:32:24
Puede llamar a quien quiera. 00:32:28
No es que... 00:32:29
¿Vale? 00:32:30
A lo mejor le faltaría por el vendeo o lo que sea. 00:32:31
No. 00:32:34
Puede llamar a quien quiera. 00:32:35
Claro, no deja de ser código Java. 00:32:36
Puede llamar a cualquier cosa. 00:32:38
Vale, a ver, Ana, por ejemplo, 00:32:40
este 00:32:42
controller de aquí. 00:32:43
Pues este controller de aquí, pues por ejemplo, 00:32:46
tiene este método. 00:32:49
inserta al que hay que pasarle 00:32:49
este objeto 00:32:53
vale 00:32:55
entonces, este objeto se lo pasamos 00:32:56
en el cuerpo de la petición HTTP 00:32:59
claro, entonces 00:33:01
ese cuerpo no lo podemos construir en el navegador 00:33:04
lógicamente, por eso es lo que usábamos postman 00:33:07
vale, pues entonces para consumir 00:33:09
este servicio que está colgando 00:33:11
de API 00:33:13
y a su vez después 00:33:14
de API tiene inserta 00:33:17
Para consumirlo. 00:33:18
O lo hago desde una aplicación que construyo yo, 00:33:20
que hace su cliente y lo consume, que podríamos, 00:33:22
que no lo hemos hecho. 00:33:25
O me abro Postman y aquí era donde poníamos el método con el 00:33:26
que yo quiero y la URL que sea. 00:33:32
Y ahora, body, rellénate. 00:33:34
¿Con qué relleno el body? 00:33:35
Pues lo voy a rellenar no con texto en claro, 00:33:37
sino con texto JSON, que es el que, el que, ¿vale? 00:33:38
entonces, esto va en el body 00:33:45
del HTTP, esto viaja 00:33:48
claro, esto viaja y llega 00:33:51
aquí a este 00:33:54
punto, entonces 00:33:56
el controller saca 00:33:58
ese JSON y lo 00:34:01
mapea según las anotaciones 00:34:02
de Jackson a crear 00:34:04
tarea DTO, entonces crear tarea 00:34:07
DTO puede tener anotaciones 00:34:09
Jackson o no, las tendrá 00:34:10
si algún nombre de propiedad cambia o no 00:34:12
cambia, ¿vale? Pues lo mapea, según 00:34:14
Jackson, lo mapea a este. 00:34:17
Y ya está. Y ahora este 00:34:18
ya llama al servicio, al repositorio 00:34:20
y esto ya va a SQL. 00:34:22
Claro, claro, claro. 00:34:28
MongoDB empieza a existir 00:34:30
en el repositorio. 00:34:33
Y para eso ha habido unos pasos antes. 00:34:35
Ha llegado al control en un JSON. ¿Qué tiene que ver con 00:34:36
MongoDB? Ese JSON se ha mapeado 00:34:38
según Jackson a este objeto. 00:34:41
Este objeto se ha pasado al servicio. 00:34:43
El servicio llama al repositorio. 00:34:44
Ahí ya entra. 00:34:47
O SQL o MongoDB. 00:34:48
El que sea. 00:34:50
¿Vale? 00:34:52
Vale. 00:34:55
Más dudas. 00:34:56
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:09
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
35′ 04″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
147.50 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid