Saltar navegación

20260219 MongoDB_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 20 de febrero de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Si me da un error, yo reacciono rápido. 00:00:00
¿A qué me refiero muy en resumen? 00:00:03
Vosotros habéis visto programación multihiro. 00:00:07
Sí. 00:00:10
Y sois muy expertos en multihiro. 00:00:11
Pero, para variar, 00:00:13
todo eso se trabaja con capas, por ejemplo. 00:00:15
Lógicamente. 00:00:18
¿Verdad? 00:00:19
Pero hay reas, ¿no? 00:00:20
Claro. 00:00:23
Con capas. 00:00:25
Capas por encima. 00:00:26
Entonces, ya. 00:00:27
idea muy, muy, muy, muy 00:00:28
sencilla, muy sencilla 00:00:31
muy sencilla, que es la que tengo yo, porque yo tampoco 00:00:32
sé de esta 00:00:35
domino esta materia en absoluto 00:00:37
¿qué ocurre cuando tenemos 00:00:39
una base de datos? 00:00:41
sobre todo cuando tenemos una aplicación 00:00:43
web, si es una aplicación de escritorio 00:00:45
hay un tío solo que está cediendo 00:00:47
si es una aplicación web, hay millones 00:00:48
de tíos y tías 00:00:50
eso por un lado, pero eso ya 00:00:52
lo hace solo, claro 00:00:57
eso ya lo hace solo, hombre, estaría bueno 00:00:59
que hubiera un solo hilo para las 200.000 00:01:00
personas que están solicitando algo por la web 00:01:03
vale, pero no solo eso 00:01:04
sino esos hilos 00:01:07
lo normal es que quieran acceder a una base 00:01:08
de datos 00:01:11
puede ocurrir que eso tarde 00:01:11
claro, puede 00:01:15
como condiciones de carrera 00:01:16
puedes modificar la base de datos 00:01:18
y que esté devolviendo a la vez 00:01:20
y devuelva las cosas que ya han sido modificadas 00:01:21
no, bueno, pero eso ya es un tema de sincronización de los hilos 00:01:23
eso ya se hace automáticamente 00:01:26
eso no es un problema 00:01:29
a lo que voy es 00:01:30
el hilo del usuario 00:01:32
está cediendo la base de datos 00:01:35
para recuperar datos 00:01:36
eso puede tardar 00:01:37
puede tardar milisegundos incluso 00:01:39
que milisegundos es mucho cuando hablamos 00:01:42
de un servidor web, es un montón 00:01:44
entonces, si no es programación reactiva 00:01:46
el hilo ahí está parado 00:01:49
esperando que le lleguen 00:01:50
los datos 00:01:53
entonces decimos, oye, pero no podría ocurrir 00:01:53
que ese hilo, mientras está ahí 00:01:56
muerto de la risa esperando que lleguen los datos 00:01:58
se libere 00:02:00
con lo cual el recurso 00:02:02
se quede disponible para otra cosa 00:02:04
y cuando pum, el dato aparezca 00:02:06
rápidamente, ya se 00:02:08
abra un hilo para cogerlo 00:02:10
y ahí es la reacción, de ahí viene lo de reactivo 00:02:12
es reactivo a que aparezcan 00:02:14
datos en flujos que tú has abierto 00:02:16
de ahí viene la palabra reactivo 00:02:18
que tú tienes flujos de datos que te van llegando 00:02:20
Entonces, tú puedes estarte ahí esperando o puedes decir, avísame cuando llegues y yo me piro. Claro, avísame cuando llegues. Entonces, cuando ha llegado, tú reaccionas, reaccionas a la llegada, reaccionas y te enganchas. Entonces, optimizas los hilos, ¿vale? 00:02:23
entonces eso, pues lógicamente 00:02:41
hay frameworks para hacerlo automáticamente 00:02:43
el más sencillo que yo he visto, el WebFlux 00:02:45
¿vale? WebFlux 00:02:47
ya es 00:02:49
el Spring Data JPA que hemos visto 00:02:51
el Spring Data, con eso 00:02:53
ya está 00:02:55
entonces tú en lugar de 00:02:57
crear 00:02:58
creas fluxes 00:03:00
y esos fluxes ya pues se comunican entre sí 00:03:03
¿por qué te hace mal? porque se ha inventado después 00:03:05
pero el WebFlux te lo hace 00:03:07
de base, tú instancias 00:03:09
en lugar de instanciar listas 00:03:11
de tareas, en este caso 00:03:13
o listas de alumnos o listas de lo que sea 00:03:15
instancias fluxes de eso 00:03:17
y esos fluxes ya 00:03:18
se mapea 00:03:20
ya incluso Spring 00:03:23
lo mapea 00:03:24
exacto, poner eso más o menos 00:03:27
ese es un resumen muy resumido, pero tú lo 00:03:30
haces y funciona y 00:03:33
claro, para comprobar que utilidad 00:03:34
tiene eso, pues tendrías que 00:03:37
irte a un servidor 00:03:38
o 10.000 00:03:40
entonces 00:03:43
yo como no quiero contaros mil ongas 00:03:44
que hice ayer por la 00:03:47
un segundo, que hice ayer por la tarde 00:03:49
pues me puse a 00:03:50
contactar con la gente de Conozco que trabaja 00:03:53
en microservicio Java 00:03:55
por ahí, por universo, que son dos, no son más 00:03:56
y les dije, a ver 00:03:59
vosotros hacéis esto con programación 00:04:01
reactiva 00:04:03
me dijeron, pues la verdad es que en la vida 00:04:03
entonces debe ser que no se usa tantísimo 00:04:06
creo que sí 00:04:09
tú lo habilitas 00:04:10
y ya el funcionamiento se despliega 00:04:25
automáticamente 00:04:27
Pero si no necesitas 00:04:27
Backpressure, es decir, si no necesitas 00:04:41
Que los clientes puedan solicitar 00:04:43
A su ritmo los paquetes o un uso intensivo 00:04:44
De servers, elements o websockets 00:04:47
Bueno, ya me he perdido 00:04:49
Pero bueno, igual alguno te sigue 00:04:51
Servers, elements es un protocolo sobre HTTP 00:04:53
Que te permite abrir un canal en el que 00:04:54
El servidor hace entregas unidireccionales 00:04:56
O sea, existen más capas de optimización 00:04:59
Claro 00:05:19
Frameworks de eso existen un montón 00:05:20
Webflux es lo más sencillo 00:05:23
De implementar para probarlo 00:05:24
Pero sí, existe 00:05:26
aparte de muchas, pues bueno, por lo que está diciendo él 00:05:28
pues muchas más 00:05:30
lo que pasa es que a las últimas que vas a meter 00:05:31
tres llamadas de que si una base de datos 00:05:34
una API o no sé qué en un servicio 00:05:36
el método te escala a 60.000 00:05:38
entre el 00:05:40
sistema y no sé qué 00:05:42
ya, que no es tan fácil luego 00:05:43
de programar 00:05:46
ya, que es pesado 00:05:47
claro, ya, ya, ya 00:05:50
bueno, pues vamos al borrado 00:05:52
hemos dicho, entonces 00:05:54
El borrado, pues ya que estamos 00:05:56
Dani 00:06:03
Se nos ha ido 00:06:06
Le hemos perdido 00:06:08
Vale, pues ya que estamos 00:06:11
Que ese método vaya por delete 00:06:12
Vale, pues en lugar de get mapping 00:06:14
Post mapping, pues delete mapping 00:06:16
Vale 00:06:19
Entonces 00:06:25
Vale 00:06:26
Aquí, bueno, entiendo que me estáis siguiendo 00:06:43
¿No? Vale 00:06:55
Entiendo que me estáis siguiendo 00:07:01
¿No? Aquí para borrar 00:07:04
Hay que pasarle 00:07:06
¿El qué? La clave 00:07:08
La clave 00:07:09
Si yo la pongo aquí 00:07:11
En la ruta 00:07:14
La clave, pues entonces aquí pongo 00:07:16
Variable de par 00:07:18
Y ya está 00:07:19
Y ahora llamo al método del repositor 00:07:21
Del servicio que lo tenga 00:07:24
¿Tengo algún método en el servicio que me borra? 00:07:25
No, pues vamos a hacerlo 00:07:27
Yo he usado el método delete 00:07:29
¿Tienes que hacerlo por método delete? 00:07:31
No, lo puedo hacer con get 00:07:32
Claro 00:07:33
Claro 00:07:35
Pero bueno, era por probarlo 00:07:38
Delete tarea 00:07:44
Claro, pero bueno, get está 00:07:49
Pues optimizado para consultas 00:08:03
Entonces, delete y aquí 00:08:05
¿Qué haríamos? Pues repo 00:08:07
Punto y repo tendrá 00:08:09
Su delete by id 00:08:11
Y ya está 00:08:15
vale, si lo pongo por delete 00:08:19
no lo puedo pasar por el navegador 00:08:25
pero lo paso por el postman y ya está 00:08:27
y ahora, aquí he hecho algo 00:08:29
muy mal hecho 00:08:34
y no me lo habéis dicho 00:08:35
aquí he hecho 00:08:37
algo muy feo, aquí no me lo habéis dicho 00:08:40
va por ahí 00:08:42
que es confuso, porque cuando yo ponga 00:08:47
a pincelta 00:08:50
él como sabe que no es 00:08:51
borrar uno con 00:08:54
I de inserta o que es este? 00:08:56
Hay ambigüedad. 00:08:58
¿Por qué entonces anteriormente? 00:09:00
Porque antes no había ambigüedad, porque 00:09:02
antes era directamente la palabra inserta 00:09:04
o directamente la palabra tareas. 00:09:06
No hay ninguna ambigüedad. 00:09:08
Hay dos métodos distintos. Uno va en el red 00:09:09
y otro va por el telete. 00:09:10
Bueno, vale. 00:09:13
Sí. Muy bien 00:09:15
vistos y muy listos. Pero 00:09:17
si yo hubiera puesto aquí red, 00:09:18
os habríais echado 00:09:21
encima diciendo ¡No! 00:09:23
eso jamás 00:09:24
no, pero también es que 00:09:26
no le pasas la palabra inserta 00:09:30
y luego es la tarea 00:09:32
a ver, si yo pongo esto así está mal 00:09:33
y esprime a ver 00:09:38
que me va a decir, ahí tienes una ambigüedad 00:09:40
porque me dice, hay dos rutas 00:09:42
hay dos rutas 00:09:44
de método get 00:09:48
que yo no puedo distinguir 00:09:50
distinguir. Yo no puedo distinguir 00:09:52
cuándo me quieres borrar 00:09:54
un documento con clave 00:09:55
tareas o cuándo quieres 00:09:57
listar las tareas. 00:10:00
Claro, puede pensar 00:10:03
que tareas es una idea. 00:10:04
Vale, ahora está claro, ¿no? 00:10:06
¿Cómo hago que el siguiente? ¿Así va a tomar 00:10:10
esas decisiones, alegremente? 00:10:12
¿Por qué lo pones encima y no lo pones arriba en la cabeza? 00:10:13
A ver, lo he puesto así. 00:10:16
Es que... 00:10:18
Conclusión. 00:10:19
Que pienso un poquito. 00:10:21
O sea, ya no solo nos lo hace todo, sino encima queréis que piense. 00:10:22
Pero entonces, ¿para qué queréis vosotros? 00:10:29
Entonces, ahora yo le pongo aquí, delete, delete id, ¿vale? 00:10:32
Ahora ya sí no hay confusión. 00:10:50
Le tengo que pasar esta url. 00:10:53
Pues venga, vamos a borrar 00:10:54
Bueno, primero 00:10:57
No hay errores, no parece 00:11:00
Venga, me voy a coger 00:11:09
El primero de todos 00:11:12
Esto 00:11:16
Control C 00:11:17
¡Hala! 00:11:19
Ese ID tan horroroso 00:11:22
Y ahora, con el método 00:11:23
Delete 00:11:27
¿Qué quiero yo? Quiero API 00:11:28
Delete 00:11:31
Barra este ID 00:11:34
Sin body y sin nada 00:11:36
No quiero que vaya body 00:11:39
Ni que vaya nada 00:11:40
¿Vale? 00:11:41
Copié un ID de la base de datos 00:11:45
Y puse la ruta 00:11:47
API delete, puse aquí delete 00:11:48
Y a ver si me sale 00:11:50
¿Que no te lo borra? 00:11:52
No, yo no lo borro 00:11:55
¿Tú has dicho que no te lo ha borrado? 00:11:56
No lo sé. 00:11:58
Vamos a probar. 00:12:00
Me da la respuesta OK. 00:12:03
Buen rollo. 00:12:06
Que estoy siendo muy vaga 00:12:07
porque también estoy poniendo 00:12:09
que todos me den la respuesta genérica OK. 00:12:11
Esos métodos de mapping 00:12:14
se les puede configurar. 00:12:15
Yo estoy configurando de alguna manera 00:12:17
lo mínimo, pero bueno, 00:12:18
uno se pone a cotillar aquí 00:12:20
y aquí podemos configurar 00:12:22
qué tipo de respuesta quieres que te dé. 00:12:24
HTTP, response, cualquiera que sea 00:12:26
Me está dando 200 siempre 00:12:29
Pero yo le puedo decir que me dé otra 00:12:30
Entonces, en principio yo creo que me ha funcionado 00:12:32
A ver si me ha borrado 00:12:35
Este primero 00:12:36
El que acababa en 8.6.4 00:12:38
Muchacho, ¿por qué no me lo has borrado? 00:12:42
¿Te has enviado para el método delete? 00:12:48
Sí 00:12:50
No haces nada en el delete 00:12:50
No llamas a este bit 00:12:51
Acabáramos 00:12:53
Con razón me ha dado tanto ok 00:12:55
Vale, vale, vale 00:12:57
Bueno, esto pasaría a las pruebas 00:12:58
Perfectamente 00:13:08
Vale, pues entonces 00:13:09
Efectivamente mi service 00:13:11
Así 00:13:13
Es complicado que haga nada 00:13:16
Segundo intento 00:13:19
Ya decía yo que había funcionado 00:13:24
Demasiado bien a la primera 00:13:26
Y los deletes siempre dan mucha angustia 00:13:27
Sí, lo temo 00:13:29
Lo temo 00:13:33
Vale, y ahora 00:13:38
¿Algo borró? 00:13:40
Sí, sí, ha borrado 00:13:44
Ha borrado, porque antes tenía 00:13:44
15 y ya tengo 14 00:13:48
Vale, magnífico 00:13:49
Lo único es que esto va un poco contra nuestros principios 00:13:51
Realmente 00:13:54
Por el DTO, no 00:13:55
Por el DTO, no 00:13:57
Porque es que 00:13:59
Uy, no, porque me estoy 00:14:00
Bueno, no os he preguntado 00:14:04
Si queríais ir a la feria de empleo 00:14:09
Bueno, el recreo ya está aquí 00:14:11
Entonces digo que está un poquito feo 00:14:18
Porque 00:14:26
Jolines 00:14:27
Es que fijaos que ID 00:14:29
Hemos tenido que copiar y pegar 00:14:31
Me da un poco de angustia 00:14:36
No, me gustaría 00:14:38
Ni saber que esos números existen 00:14:42
Claro, o sea 00:14:45
Lo que realmente querríamos 00:14:48
Lo que estaría guay 00:14:50
Sería poner aquí un campo 00:14:51
Que fuera mi código, de verdad 00:14:55
Y que yo lo manejara por programa 00:14:56
Y todo eso, ¿vale? 00:14:58
Es decir, claro 00:15:01
Pues esto tendría más sentido, ¿no? 00:15:02
Yo me hago aquí, lo que pasa es que ahora 00:15:04
Parcheando, vete a saber, pero 00:15:06
Pues hacerme yo aquí 00:15:08
Mi código, pero todo esto lo manejaría 00:15:10
Yo por programa 00:15:13
Sí, claro, las que tengo ya 00:15:14
Esas las he dejado 00:15:21
No encontrables 00:15:22
Por ese código, pero bueno, claro 00:15:24
Pero es que claro, ¿qué estamos haciendo? 00:15:26
Estamos poniendo parches 00:15:27
Pero a ver 00:15:28
Deja, deja 00:15:31
No sé lo que es 00:15:38
A ver 00:15:39
Ah, bueno, ya, pero 00:15:40
Vale, entonces 00:15:53
Pero yo iba a otra cosa 00:15:55
¿Vale? 00:15:56
Vale 00:16:02
Entonces 00:16:02
Si este código 00:16:04
Tengo yo aquí algún constructor 00:16:08
No, ni le había puesto constructor 00:16:10
le he puesto constructor 00:16:12
no, vale 00:16:19
entonces no tengo que modificarlo 00:16:21
aquí lo único, si este es nuestro campo 00:16:22
de búsquedas, que se convertiría 00:16:25
de repente en nuestro campo de búsquedas 00:16:27
pues estaría bien 00:16:29
bueno, sí, si lo vamos a meter 00:16:31
en colecciones, pero me refería 00:16:36
a anotarlo 00:16:39
con 00:16:41
esta anotación 00:16:42
la de Mongo 00:16:43
porque 00:16:48
el IDE 00:16:49
las claves primarias 00:16:53
están indexadas automáticamente 00:16:55
las claves primarias 00:16:56
están indexadas automáticamente 00:16:59
el resto de campos no 00:17:01
entonces si yo lo indexo 00:17:02
pues automáticamente 00:17:04
el gestor de base de datos ya se habilita 00:17:06
un mecanismo para encontrarlo 00:17:09
más rápidamente 00:17:11
¿qué son números? 00:17:11
¿Qué mecanismo se habilita? 00:17:13
Pues meterlo en un árbol ordenado. 00:17:15
Entonces, si tú quieres recuperar uno, no vas uno por uno, 00:17:17
sino que vas a la zona del árbol correspondiente. 00:17:20
Entonces, siempre conviene indexar los campos 00:17:24
para los que se van a hacer muchas búsquedas. 00:17:26
Y luego, además, si le ponemos una anotación, 00:17:28
que eso también podría ser en la de fill, 00:17:30
pues podemos, al menos, sí poner alguna pequeñita. 00:17:33
Podemos ponerle este aviso a MongoDB. 00:17:40
Decir, oye, que este campo va a ser único 00:17:42
¿Vale? Entonces, bueno, algo ya 00:17:44
Sí que podemos hacer 00:17:46
Un pelinín de restricción, de lo poco que podemos hacer 00:17:47
Pero este campo es un campo mío 00:17:50
Entonces, que yo ahora quiero localizar 00:17:54
Por códigos, quiero todo por código 00:17:55
Pues me lo tengo que meter en el repositorio 00:17:57
¿Vale? 00:17:59
Pues, esa 00:18:05
Claro, me hago un índice 00:18:06
Y el gestor de base de datos 00:18:09
Ya se pone su mecanismo 00:18:11
Para encontrarlo antes 00:18:13
el que sea, ese mecanismo dependerá 00:18:15
si son booleans, si son números, si son cadenas 00:18:16
normalmente es 00:18:18
ponerles en un orden, en un arbolito 00:18:20
y así tú ya vas buscando uno, pues te quedas 00:18:22
con la mitad del árbol que se corresponde 00:18:24
y ahí te vas quedando por partes 00:18:26
si no hay un índice, pues ya sabéis que se busca 00:18:27
uno detrás de otro, uno detrás de otro 00:18:30
recorre y eso es muy pesado 00:18:32
Exacto, entonces 00:18:33
claro, es una carga 00:18:40
para el gestor de base de datos 00:18:42
Pero si vas a hacer muchas consultas por ese campo, pues el balanceo, el coste-beneficio, se supone que va hacia el beneficio. 00:18:44
Entonces, si queremos usar este para hacer consulta, para hacer lo que sea, pues eso nos obliga a irnos a nuestro repositorio. 00:18:52
Nos obliga a irnos a nuestro repositorio y ahora ya hacer métodos propios. 00:19:01
Pues bueno, métodos propios como buscar por otro campo. 00:19:06
Que esto es como el Spring JPA que hemos visto 00:19:09
Find by 00:19:12
Código 00:19:13
Claro 00:19:14
Esto ya está 00:19:19
No lo tienes que hacer 00:19:21
No, este no, porque esto es buscar 00:19:22
No, el que te viene es por ID 00:19:25
El find by código no 00:19:27
Ese lo tienes que hacer tú 00:19:29
Porque el código es un campo que has hecho tú 00:19:30
Los que te vienen 00:19:32
Si yo este no le tengo 00:19:37
Los que te vienen solos son 00:19:39
Recuperar todos, borrar por clave 00:19:43
Pero la clave por la id 00:19:46
Pero tú esta la puedes poner 00:19:47
La idea es que lo tenías que poner 00:19:50
Pero ya entiende que el código es un atributo 00:19:51
Sí, entiende 00:19:53
Claro, eso ya entiende que es un atributo 00:19:56
Entonces 00:19:57
Pues bueno, podríamos gestionarlo así 00:19:59
Hacer ya nuestro servicio 00:20:02
También en este caso 00:20:03
en el repo 00:20:10
podríamos hacer también 00:20:12
tarea delete 00:20:14
código 00:20:19
este que él no te lo ofrece por defecto 00:20:23
porque no es el campo id 00:20:28
lo podríamos hacer también 00:20:29
lo podríamos hacer también 00:20:31
y aquí ya en nuestro 00:20:33
servicio 00:20:39
pues podríamos hacer 00:20:40
nuestro deleteTarea 00:20:47
este deleteTareaId le vamos a llamar 00:20:51
y al otro deleteTareaNormal le podríamos llamar 00:20:58
deleteTarea 00:21:01
claro, deleteTareaNormal 00:21:07
¿alguien ha llamado? ¿sí o no? 00:21:09
no sé 00:21:15
Vale, pues podríamos trabajar así 00:21:16
Con nuestras propias claves 00:21:35
En el insert lo podríamos modificar, etc 00:21:36
Vale 00:21:39
Último método 00:21:40
El último método que queremos hacer 00:21:42
Imaginaos que ahora 00:21:44
Queremos añadir un ítem 00:21:47
Porque nuestro inserta 00:21:48
Añade el documento, nuestra tarea 00:21:50
Sin ítems 00:21:52
Ahora podría ser que quisiéramos añadir un ítem 00:21:53
Vale, a una tarea en concreta 00:21:56
Pues bueno, el controller 00:21:59
Nuestro controller, ¿cómo sería? 00:22:01
Bueno, pues nuestro controller 00:22:08
Aquí 00:22:09
Esto es una modificación 00:22:10
Que lleva 00:22:13
Tanto en el body datos 00:22:16
Los datos nuevos 00:22:18
Como en el id 00:22:19
Lleva también parámetros 00:22:20
Que es el id de la tarea que quiero yo borrar 00:22:21
La tarea de la que quiero añadir ítems 00:22:24
Entonces, esto en un GET 00:22:26
No debería ir 00:22:29
¿Vale? Podría ir en un POST 00:22:31
Pero para esto 00:22:33
En principio 00:22:35
Se suele usar 00:22:36
El otro protocolo de HTTP 00:22:38
Que es el PUT 00:22:41
Normalmente asociado a modificar 00:22:42
Luego, normalmente 00:22:45
GET asociado a recuperaciones 00:22:46
POST asociado a inserciones 00:22:49
DELETE asociado a borrados 00:22:51
Y PUT asociado a modificaciones 00:22:54
¿Vale? 00:22:56
Entonces 00:22:58
Put y post 00:22:59
Por ejemplo 00:23:01
Put 00:23:05
No te 00:23:08
Inserta un recurso nuevo cada vez 00:23:10
Es decir, si tu post le das a reenviar 00:23:12
Reenviar y reenviar 00:23:14
Cada vez te metería uno nuevo 00:23:15
Put no 00:23:17
¿Vale? 00:23:18
Put se sustituye solo 00:23:20
Hay diferencias entre todos los protocolos 00:23:22
hay diferencias sutiles entre los protocolos 00:23:25
entre sí. 00:23:27
¿Vale? Pero bueno, eso... 00:23:29
Independientemente de cómo funcione luego el método. 00:23:30
Claro, luego el método lo que haga dentro, 00:23:33
pero sobre todo 00:23:35
las implicaciones que tiene 00:23:37
es... 00:23:39
Es en 00:23:40
sobre el que... 00:23:43
sobre lo que tú hagas 00:23:46
con el mensajero, con el postman, 00:23:47
con el navegador, pues en función de cómo lo 00:23:49
hagas, ¿vale? Si reenvías y no sé qué, pues 00:23:51
ahí están las diferencias. Luego lo que 00:23:53
hacen, pues lo que esté en el cuerpo 00:23:55
de la petición 00:23:56
Sí, lo que pasa es que 00:23:58
uno 00:24:05
se dice que es 00:24:07
idempotente, es decir, que está haciendo 00:24:09
lo mismo una y otra vez, y el otro 00:24:11
no, el otro te está haciendo inserciones nuevas 00:24:13
cada vez 00:24:15
Entonces, aquí, ¿qué ruta querríamos poner? 00:24:17
Pues, items 00:24:20
Vamos a llamarla 00:24:21
AddItem 00:24:24
¿A quién? 00:24:27
Pues al de código, el que sea 00:24:28
Al de código, el que sea 00:24:31
Entonces, vale 00:24:34
Pues aquí 00:24:36
PutMapping 00:24:38
El método que sería 00:24:40
Public, que nos devuelva 00:24:42
La tarea 00:24:45
A ver, es que lo voy a hacer por ID 00:24:46
Porque como tengo todos los documentos 00:24:53
Con id, todo el mapeo 00:24:55
Eso lo había puesto solo 00:24:57
Pues para, pero 00:24:58
Pues 00:25:00
Si me pongo a hacer parches 00:25:02
Ahora, pero daría lo mismo 00:25:04
Por uno que por otro, pero tendrían que tener códigos 00:25:07
Vale, entonces, tarea 00:25:09
Pues add item 00:25:10
Ahora, este tiene 00:25:12
Uno de estos 00:25:14
Exacto 00:25:17
Que va a ser el string id 00:25:20
Y otro el body 00:25:22
Efectivamente 00:25:24
RequestBody que es el 00:25:25
Ítem, con que sea un ítem es suficiente 00:25:29
Ítem, ítem, el requestBody 00:25:31
Vale 00:25:35
Y ahora este que tiene que hacer 00:25:36
Tendremos que hacer un método de servicio 00:25:38
Servicio para 00:25:40
Añadir un ítem 00:25:41
Por id 00:25:45
A este 00:25:49
A añadir a este 00:25:51
Tendremos que hacer este 00:25:53
Y ahora hacemos este método aquí, este método, pues entonces, vale, a este método, rep, tareate, repo.findbyid, porque no lo he, no tengo códigos en los sitios, no tengo nada, findbyid de este. 00:25:58
Y ahora, bueno 00:26:28
Punto 00:26:33
Lo saco del optional 00:26:35
No, tan vaga no voy a ser 00:26:37
Or else throw 00:26:39
New 00:26:41
Como no tengo excepción hecha 00:26:43
Aquí lo bueno sería hacerse uno su propia excepción 00:26:44
Runtime es 00:26:47
Claro 00:26:50
Pero bueno, voy a 00:26:51
Voy a poner una genérica y ya está 00:26:54
Exception 00:26:58
vale 00:27:04
un time step 00:27:08
new 00:27:13
porque no, él se throw, una excepción 00:27:16
no, lo único que quiere, ah bueno, espérate 00:27:19
ah no, es que tengo que meterle un supplier, perdón 00:27:21
perdón, un supplier 00:27:23
ah sí, ahora sí 00:27:25
vale, vale 00:27:27
eso se llama supplier, si eres una 00:27:30
lambda que no recibe nada y te da 00:27:33
algo, vale 00:27:35
pues entonces, ahora a esta tarea 00:27:36
t.get 00:27:38
items 00:27:41
get items punto 00:27:42
add items 00:27:44
ahora ya tengo esta tarea 00:27:46
y ahora repo 00:27:48
punto save 00:27:50
tarea 00:27:52
vale 00:27:55
que el 00:27:57
exacto, te la devuelve también 00:27:58
y yo aquí 00:28:05
lo había puesto como 00:28:07
tarea, pues aquí también en el service 00:28:08
igual 00:28:11
en el service que me devuelva la tarea 00:28:11
actualizada 00:28:15
retun 00:28:17
vale, el método de servicio ya estaría 00:28:21
que me devuelva la tarea actualizada 00:28:24
lo llamo 00:28:26
desde el controller 00:28:28
que me está diciendo 00:28:29
cosas porque me falta aquí 00:28:32
retun 00:28:35
vale 00:28:38
te guarda el objeto persistente 00:28:42
O te lo sobrescribes y ya está 00:28:44
¿Vale? Te lo sobrescribes y ya está 00:28:47
Que en este caso es lo que queremos 00:28:50
Ah, si no lo harías 00:28:51
Si no lo haces en el 00:28:59
En el otro hemos hecho insert 00:29:00
En el otro método del servicio 00:29:02
Que lo insertábamos de nuevas 00:29:05
Que no estábamos hecho el insert 00:29:08
Entonces él ya te crea un id nuevo para él 00:29:09
En el save 00:29:11
No te crea un id nuevo para él 00:29:13
Sustituye el que hubiera 00:29:15
¿Vale? 00:29:16
vale, entonces yo creo 00:29:17
que está todo, creo 00:29:21
lo estamos haciendo un poco 00:29:23
a lo gorrino, porque 00:29:25
ni estamos haciendo excepciones 00:29:26
ni estamos poniendo DTOs para cada parte 00:29:28
que sería lo ideal, como hemos empezado con 00:29:30
ID, estamos tirando con ID en lugar de haber 00:29:33
hecho desde el principio un código 00:29:35
pero bueno, sabéis de que va esto 00:29:36
ya en el examen lo hacéis bien vosotros 00:29:39
y no pasa nada 00:29:41
Sí, bueno, persistente 00:29:42
lo que pasa es que como el ID 00:29:50
persistente ya es, porque lo he sacado de un find 00:29:51
Bueno, a ver, no es persistente 00:29:54
pero el contexto de persistencia 00:29:56
ya se cerró, ¿vale? 00:29:57
Entonces, lo que hace, esto no es como 00:30:00
cuando lo hacemos nosotros directamente en JPA 00:30:02
lo que hace el save, pues bueno 00:30:03
si existe un ID con este, lo modifica 00:30:05
¿vale? Que en este caso va a existir 00:30:08
pero lo he sacado con un find 00:30:10
Es que 00:30:11
Es que no sé muy bien 00:30:26
Las transacciones en MongoDB 00:30:33
Bueno, no, no es tan sencillo 00:30:35
habría que mirarlo, no lo tengo muy claro 00:30:41
claro, lo que pasa es que es cierto que como normalmente 00:30:43
no trabajas 00:30:49
de uno a otro, de uno te lleva a otro 00:30:51
está más orientado 00:30:53
a que está efectivamente todo recogido en el mismo sitio 00:30:57
lo de las transacciones pierde un poco su 00:30:59
pero no lo sé, no me he puesto a mirarlo 00:31:01
en realidad, no me he puesto a mirarlo 00:31:03
lo de las transacciones 00:31:05
normalmente se pasan bastante por alto 00:31:08
Cuando trabajas con MongoDB 00:31:13
Vamos a probarlo 00:31:14
A ver 00:31:18
Vale, entonces 00:31:19
Este era 00:31:28
Delete e id 00:31:29
No, delete e id no 00:31:32
Add item e id 00:31:34
Pues voy a añadirle yo un item a este 00:31:35
Y los item 00:31:38
Tienen 00:31:45
Que tienen los ítems 00:31:46
Descripción y completado 00:31:51
¿Verdad? 00:31:53
Ítem tienen nombre y completado 00:31:58
Tienen los ítems 00:32:00
Nombre y completado 00:32:01
Pues a ver 00:32:03
Esto sería 00:32:06
Add item 00:32:10
Control V 00:32:13
Esto sería put 00:32:16
Y aquí hay que poner un cuerpo 00:32:17
Además 00:32:19
Que el cuerpo sería 00:32:20
El cuerpo sería 00:32:25
Nombre y completado 00:32:37
Hemos dicho 00:32:40
Completado 00:32:41
True 00:32:55
Vamos a ver esto 00:32:57
Lo veo yo muy raro, pero bueno 00:32:59
Nombre 00:33:01
Dice ok 00:33:02
Y aquí estamos 00:33:07
El código null, efectivamente 00:33:10
Este es el id 00:33:12
Completado y los que tenía 00:33:13
Más este, participantes, primera prueba 00:33:16
Pues sí 00:33:19
Aquí está, me lo ha modificado con el barra class 00:33:20
Y aquí tengo 00:33:30
El nuevo ítem 00:33:34
Que ya he añadido 00:33:35
Pues muy bien, me he apañado, ¿no? 00:33:37
¿Ya sabéis hacer un montón de cosas? 00:33:49
Que va a entrar a la sala 00:33:56
Sí, por favor 00:33:57
Que... 00:33:59
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:
20 de febrero de 2026 - 13:17
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
34′
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
140.04 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid