Saltar navegación

20260203 JPA-SPRING_2 - 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 7 de febrero de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale. A ver, aquí aparte de indicar cómo construir los bins que Spring va a necesitar, que estas cosas, repito, en mi caso y en el de la gama de los humanos son copias y pegas, lógicamente. 00:00:02
Yo voy ahí mirando, cotilleando, solucionando y ¿qué funciona? Pues ahí lo dejo. Pero podréis ver más formas de construir estos bins, lógicamente. ¿Vale? Más formas. Esto es lo que yo voy copieteando por ahí. Vale. 00:00:16
Hay que decirle a Spring 00:00:32
Que es un fichero de configuración 00:00:35
Claro, vale, pues venga 00:00:36
Es un fichero de configuración 00:00:38
¿Vale? 00:00:40
También hay que decirle a Spring 00:00:42
Que puede que haya más bins 00:00:43
Que los que hay aquí 00:00:45
Puede que los haya, búscalos 00:00:48
En este caso los hay, el repositorio y el service 00:00:50
Pues entonces hay que decirle 00:00:52
A partir de qué 00:00:54
Punto del árbol de paquetes 00:00:56
Tiene que empezar a buscarlos 00:00:58
Oye, búscalos a partir de este 00:00:59
vale, esta anotación 00:01:01
para que él infiera 00:01:06
para que él infiera 00:01:08
la de repository 00:01:10
de aquí, vale 00:01:12
si la quitamos 00:01:14
no va a 00:01:16
inferirla y no va a 00:01:19
funcionar, va a decir, no consigo 00:01:20
el binrepositorio, me falta 00:01:22
¿dónde está? no me has dicho que lo maneje 00:01:24
vale, pues poniendo esta 00:01:27
anotación 00:01:28
Spring ya extrae de aquí 00:01:29
Que esto es un bin repositorio 00:01:33
Que tiene que gestionar él 00:01:35
Y esto es para que funcionen 00:01:37
Las anotaciones transaccionales 00:01:40
Ya está 00:01:42
Con toda la implicación que tienen las transaccionales 00:01:42
¿Vale? 00:01:46
Que es que todo ese método en transacción 00:01:47
Rollback si no funciona 00:01:49
Contexto de persistencia abierto todo el rato 00:01:52
Si no está abierto 00:01:55
Tenemos problemas con las cargas 00:01:56
Lazy, etc 00:01:58
Vale, pues entonces 00:02:00
Ahora ya con este fichero de configuración 00:02:02
Ya podemos hacer un main rápido 00:02:04
Que ya 00:02:06
Será nuestro último proyecto 00:02:08
Espero en 00:02:10
Arquitectura esta, porque como ya 00:02:12
Más o menos controlamos 00:02:14
Más o menos 00:02:16
Ya podemos cambiar arquitectura 00:02:18
O bien a esa web que os gustó tanto al principio 00:02:20
A un API REST, me da lo mismo 00:02:22
son controller igualmente, me da igual 00:02:24
que te consulte una máquina, que te consulte una web 00:02:26
a ver, no me da igual, cuando te consulta 00:02:28
una web tienes que construir toda la vista, que es un rollo 00:02:30
si es una p-res no construyes 00:02:32
vista, das el boom en el objeto 00:02:34
y es más fácil 00:02:36
bueno, pues 00:02:37
entonces ahora ya podemos hacernos 00:02:40
nuestro main, a ver si hemos montado bien 00:02:41
la arquitectura correctamente 00:02:44
vamos a sacar 00:02:45
el contexto 00:02:47
de sprint 00:02:49
Y ahora ya el contexto de Spring 00:02:51
Me saca mi bin raíz 00:02:54
El service 00:02:56
Y ahora ya con el service yo hago todo 00:02:58
Todavía estamos haciendo algo a mano 00:02:59
Porque no tenemos Spring Boot 00:03:03
¿Vale? Recordad que 00:03:06
Que ya lo incorporaremos 00:03:07
Que con Spring Boot 00:03:09
Spring Boot ya deduce todo esto 00:03:11
Este fichero ya no está 00:03:14
Porque lo deduce 00:03:16
Y ya que yo sepa no hay más nivel 00:03:17
De ocultación, ya es imposible ocultar 00:03:20
más que lo que oculta Spring Boot. 00:03:22
Así que ya más capas no vamos a poner, Ana. 00:03:24
Después de tres meses de capas 00:03:26
hemos llegado a la capa final. 00:03:27
Sí, pero tienes un conocimiento muy sólido 00:03:29
de base. Y has entrenado 00:03:32
bastante bien el cerebro. 00:03:34
Pero ahí estás. 00:03:38
Cuando tengas que tirar de ello, sobre todo cuando tenés un proyecto 00:03:39
y tengas que interpretarlo, 00:03:42
ese conocimiento está ahí. 00:03:44
Pero que ahora no sé cuál capa es cuál. 00:03:46
No, hombre, si lo sabes. 00:03:49
Pero si es que están clavadas. 00:03:50
jd bc iber jd bc hibernate jp a brindar a sprint sprint 00:03:52
jd bc hibernate jp a esas tres seguidas sprint 00:04:12
en particular Spring Data JPA 00:04:21
más el Spring Core que te gestiona 00:04:24
Luzbin, Spring Boot 00:04:26
más que capa, pues una ayudita 00:04:28
para quitarte la configuración 00:04:30
y ya está, y luego ya todo 00:04:32
eso lo metes en la arquitectura que te dé la gana 00:04:34
vale, que sí, que uno puede meter más 00:04:36
capas, pues si quiere que sea reactivo 00:04:38
si quiere que sea no sé qué, Aitor tiene 00:04:40
mogollón de capas, ah bueno, un Docker 00:04:42
vale, que todo eso lo quieres 00:04:44
meter en un contenedor Docker para no tener 00:04:46
pues, ah un Docker 00:04:48
Vale, que los tienes 00:04:50
Un Docker que lo quieres gestionar por 00:04:53
Kubernetes, que tiene un montón de 00:04:54
Pues Kubernetes por encima 00:04:57
Pero bueno 00:04:58
Vamos a dejarlo 00:04:59
Imagino que ya te has traído, te pulsas 00:05:02
A y te hace lo que quieras 00:05:04
No sé yo, eh 00:05:06
A ver, no lo sé, yo no he conseguido 00:05:08
Que pulsara A y que haga lo que quieras 00:05:10
Pero bueno 00:05:12
Vale, pero ahora 00:05:13
Vosotros podéis 00:05:18
si trabajáis en Java 00:05:19
que Dios lo quiera 00:05:22
que Dios lo quiera 00:05:23
porque vais a ser los mejores 00:05:26
porque ya con todo el esfuerzo que habéis hecho 00:05:27
que has aportado para tus cartas en Java 00:05:30
si, si, somos políglotas 00:05:32
es lo mío que sé 00:05:33
y ni eso, ni eso sé 00:05:35
así que imagínate, bueno pues no, más que eso 00:05:38
con todo el esfuerzo que habéis hecho en Java 00:05:40
pues Dios quiera 00:05:42
que trabajéis en Java un rato 00:05:43
entonces, ¿qué iba a decir? 00:05:45
Hay mucha 00:05:48
Todavía hay bastante gente 00:05:53
Trabajando con el ecosistema Java 00:05:54
En todas sus variantes 00:05:56
El 30% 00:05:57
Pues fijaos 00:06:01
Todas para vosotros 00:06:02
Pues 00:06:03
Trabajando en Java 00:06:06
Veréis proyectos hechos 00:06:08
De muchas maneras 00:06:10
Bien, mal, desastre, maravillosos 00:06:11
Algunos no entenderéis ni patata 00:06:15
Pero no pasa nada 00:06:16
la semana ya lo entenderéis todo 00:06:17
alguno diréis, pero que mal trabajan aquí 00:06:18
vaya mierda, menos mal que he llegado yo para arreglarlo 00:06:21
todo, de todo 00:06:23
de Spring Boot ya es 00:06:24
a ver, puedes poner un Docker para que te gestione ya 00:06:27
¿vale? meterlo todo en un Docker 00:06:29
y encima de Docker el sistema operativo de 00:06:31
Docker, Kubernetes 00:06:33
y encima de Kubernetes 00:06:34
el robot que te lo hace todo 00:06:36
¿no? 00:06:39
y encima 00:06:40
del robot, el humano 00:06:41
Bueno, el usuario 00:06:43
Aquí ya ni pinta nada 00:06:51
Todo esto se hace para usuarios que luego ni existen 00:06:52
Pero bueno 00:06:54
Vale, pues ahora ya 00:06:55
Vale, pues venga, vamos a 00:06:57
Uf, pues me temo que sí 00:07:02
O sea, se ha grabado todo este speech 00:07:06
Se ha grabado todo el speech 00:07:08
En fin, pues ahora ya sí que podemos 00:07:10
vamos a probar a ver si la arquitectura 00:07:13
funciona y a partir de ahí ya podremos meter más 00:07:15
cositas 00:07:17
vale, pues a ver, service 00:07:17
teníamos solamente un servicio 00:07:21
que es 00:07:23
recupera cliente por id 00:07:24
coged un cliente del que tengáis id 00:07:26
un cliente del que tengáis id 00:07:28
el 1 00:07:33
cliente 00:07:34
ala 00:07:37
voy a ponerle un tuestrín a cliente 00:07:40
que no sé si lo tengo puesto 00:07:43
para que esto 00:07:44
no me muestre algo feo 00:07:47
un segundo, que le pongo el tuestrín 00:07:49
y vuelvo 00:07:51
¿qué estamos haciendo? pues desde el 00:07:51
main patatero a lo cutre, que esto sí 00:08:00
que es cutre, probar las cosas desde un main 00:08:01
lo reconozco, pero es lo más 00:08:03
cómodo y fácil 00:08:05
pues probar que la arquitectura que hemos hecho de 00:08:06
sprint funcione 00:08:09
vale, entonces, no hemos hecho 00:08:10
nada, o sea, nosotros 00:08:13
programar, es que no hemos programado nada 00:08:15
hemos puesto clases y clases 00:08:17
y clases, millones de 00:08:19
clases, solo para hacer un 00:08:21
seller, cliente 00:08:23
from clientes, web 00:08:25
id, igual a 1 00:08:27
algo que en JDBC habríamos hecho 00:08:28
en una línea perfectamente 00:08:31
controlado, pues hemos hecho aquí 00:08:33
vamos, la leche 00:08:35
solo para hacer esto 00:08:37
yo ahí lo dejo 00:08:39
Para que veáis que 00:08:41
No, yo lo que quiero es que no seáis víctimas 00:08:44
Del tecnooptimismo 00:08:47
Que es el progreso siempre mejora nuestra vida 00:08:48
Pues no 00:08:52
Resistámonos a esa idea también a veces 00:08:52
A veces el decrecimiento 00:08:55
Es la solución 00:08:57
Tú abogas por el decrecimiento 00:08:58
¿No? 00:09:01
Efectivamente 00:09:06
A ver 00:09:07
Uy, qué suerte 00:09:12
Ala, pues ya está 00:09:14
Todo el rollo para hacer esto 00:09:19
Todo el rollo para hacer esto 00:09:21
Vale 00:09:26
¿No se ha funcionado a todo el mundo? 00:09:27
No se ha funcionado a todo el mundo, ¿no? 00:09:30
El ID 00:09:42
Lo tienes como interior o como long 00:09:43
Como long, por eso yo le he puesto la L 00:09:46
En el entity 00:09:48
Sí, en el 00:09:51
O sea, lo tengo aquí como long 00:09:52
Lo tengo en cliente como long 00:09:54
En mi caso lo tengo como long 00:09:55
Todo el rato, porque estas clases 00:09:58
Se las pedía HGP desde el script 00:09:59
Y como 00:10:02
Estaba como begin, lo puso como long 00:10:03
Vale 00:10:06
¿Dónde estaba yo aquí en el main? 00:10:12
¡Hala! 00:10:15
Pues ya está, y con esto ya podríamos tirar 00:10:16
Y hacer un proyecto hiper mega 00:10:18
maravilloso que hiciera millones de cosas 00:10:20
con mis clientes y mis pedidos 00:10:23
¿Vale? 00:10:24
A ver 00:10:39
Vamos a hacer una cosa 00:10:40
¿Cómo? A ver, te hace un create table 00:10:43
si tienes aquí 00:10:50
create en esta propiedad 00:10:51
¿Dónde estamos aquí? 00:10:53
O si no tienes la base 00:11:00
de datos 00:11:01
Te crea la tabla otra vez 00:11:02
Teniéndola ya 00:11:06
Pero has puesto aquí el nombre de la base de datos 00:11:09
Bueno, me has cambiado al tuyo 00:11:14
A ver si has dejado el mío 00:11:15
Yo que sé 00:11:17
Yo también tengo el mío 00:11:17
Y a mí me hace drop table, drop pivot 00:11:20
Y luego hace un create 00:11:22
Pues con aquí en UPDATE 00:11:27
Solo si cambia el esquema 00:11:31
Si no cambia el esquema no debería tirar la basura 00:11:33
A lo mejor habéis cambiado alguna 00:11:35
Propiedad, alguna cosa que hace 00:11:37
Que él vea que es diferente 00:11:39
El modelo de la 00:11:41
Es que por defecto ponía create 00:11:42
En tu caso 00:11:45
No lo creo 00:11:47
Tú tienes ubdate a palo seco 00:11:48
No tienes ubdate create 00:11:52
Ni nada de eso 00:11:54
Bueno pues 00:11:55
¿Tenías creado? Vale, vale 00:12:01
Entonces vamos a hacer una cosa 00:12:03
Voy a guardar el cliente aquí 00:12:04
¿De qué? 00:12:06
Este proyecto entero lo voy a subir ahora 00:12:24
Pero ahora mismo, ¿te refieres? 00:12:26
De la tabla, porque como nos la ha borrado 00:12:28
Las tablas y las ha vuelto a crear 00:12:30
No hay datos ni nada 00:12:32
mete tú cualquiera rápidamente aquí 00:12:33
te metes unos, es mucho más rápido que ejecutar 00:12:37
un script, mete los que te den la gana 00:12:39
ahí, metes dos o tres 00:12:41
para probar y ya está, vale, entonces 00:12:42
estaba yo aquí 00:12:45
que por qué queremos que nos dé error 00:12:46
para que nos acordemos de esto 00:13:01
vale 00:13:09
porque, vale 00:13:10
aquí 00:13:14
Y es donde, es uno, donde vemos que hibernate no nos lo pone tan fácil. 00:13:16
Porque yo quiero mi cliente, recupero cliente con el método que me ofrece el repositorio. 00:13:23
Es que no los he hecho yo, yo no los he hecho. 00:13:31
Entonces, si yo quiero que me hagan las cosas, pues tengo que aceptar sus reglas. 00:13:34
Y sus reglas son, dime. 00:13:40
Porque no tendrás puesto aquí 00:13:42
Create, en vez de Udate 00:13:51
Cuando dices 00:13:52
Me dropea, querías decir me elimina 00:13:57
Vale, porque es que 00:13:59
Dropear ya te vale 00:14:03
Vale 00:14:04
Igual teníais 00:14:09
Create, porque cuando yo subí esto 00:14:13
Lo tenía como create 00:14:15
Claro, y lo cambié luego después 00:14:16
A lo mejor 00:14:18
Vale, vale 00:14:19
Pues puede ser 00:14:22
Vale, pues lógicamente esto 00:14:28
Como bien habéis intuido 00:14:32
Algunos 00:14:35
A que esto era una excepción como la ropa de un pino 00:14:35
¿Verdad? 00:14:39
Porque esto ya no lo sabemos de memoria 00:14:41
El cliente se ha recuperado 00:14:42
Sin sus pedidos 00:14:45
Porque aquí tenemos esto 00:14:46
Que, ¿dónde está? 00:14:48
Ah, concha, aquí está 00:14:52
Aquí tenemos esto 00:14:53
Entonces en el servicio no tenemos que ejecutar todos los pedidos 00:14:55
Claro, pero entonces 00:14:57
¿Cómo arreglamos esto? 00:15:01
Pues uno diría, ay, pues no pasa nada 00:15:07
Pongo aquí el Iger, pero hombre, esa no es la solución 00:15:09
Poner el Iger 00:15:11
Entonces aquí el problema, ya sabemos cuál ha sido 00:15:12
Que el servicio 00:15:15
este de aquí 00:15:17
tira de find by id 00:15:18
que no lo he hecho yo 00:15:21
y find by id 00:15:22
te lo coge y te coge 00:15:24
abre el 00:15:27
contexto de persistencia, te coge el cliente 00:15:29
y lo 00:15:31
y lo cierra el contexto de persistencia 00:15:33
y no puedo elegir 00:15:35
yo que haga, que funcione 00:15:37
de otra manera, ¿vale? 00:15:39
primer problema de Spring, yo aquí no elijo 00:15:41
el contexto de persistencia cuando está vivo 00:15:43
no lo puedo elegir, es imposible 00:15:45
entonces como no lo puedo elegir porque es imposible 00:15:46
pues estoy 00:15:49
condenada para la eternidad 00:15:51
a este lazy exception 00:15:54
a menos que decida 00:15:56
pasar de este método 00:15:58
¿vale? a menos que decida pasar 00:15:59
de este, porque este no me vale 00:16:01
entonces 00:16:03
¿habría algún método que me ofrezca 00:16:05
el repositorio que me lo recoja 00:16:08
con sus pedidos? 00:16:09
pues seguramente no, si no lo hay 00:16:11
pues estoy jodida 00:16:13
Vamos a ver 00:16:14
¿Qué métodos me ofrece? 00:16:16
Define 00:16:21
Pues define 00:16:22
Find, all, find, nada 00:16:24
Find, all, find 00:16:26
All by the, find by the 00:16:27
Find 00:16:30
Nada 00:16:30
No puedo hacer nada 00:16:32
Efectivamente 00:16:35
Pues entonces 00:16:39
Que el repositorio me ofrezca ya muchas cositas 00:16:40
No significa 00:16:44
que no le pueda yo poner las mías propias 00:16:45
¿vale? 00:16:48
entonces yo, a las que me ofrece él 00:16:49
que es el cruz básico 00:16:51
¿lo pondrías en el repositorio y no en el service? 00:16:52
no, en el repositorio 00:16:57
métodos de repositorio 00:16:58
porque el service tira del repositorio 00:17:00
entonces lo tengo que poner en el repositorio primero 00:17:02
¿vale? porque el service 00:17:04
¿de dónde tira? si es que no tengo 00:17:06
ni JBC, ni tengo DAO, ni tengo nada 00:17:07
es que aquí estoy 00:17:10
muy angustiada 00:17:11
Lo tengo que poner aquí 00:17:14
Pero claro, esto es una interfaz 00:17:15
Entonces, yo no puedo aquí 00:17:17
Implementar un método 00:17:20
¿Vale? Pero no pasa nada 00:17:21
Es que Spring es tan listo 00:17:24
Que del propio nombre 00:17:27
Del método 00:17:29
Él ya infiere un montón de cosas y se lo inventa 00:17:29
¿Vale? 00:17:32
O bien lo infiere del nombre 00:17:34
O si del nombre no se puede inferir 00:17:36
Porque es demasiado complicado 00:17:38
Le pongo yo una query al lado 00:17:39
Y le digo, oye, este método es esta query 00:17:41
Le pongo una query jpql y tan listo, ¿vale? 00:17:43
Por ejemplo, vamos a hacer métodos propios para este de 00:17:46
aquí. 00:17:50
Vamos a suponer que quisiéramos, ¿vale? 00:17:51
Vamos a ponerle aquí métodos propios. 00:17:54
Métodos propios. 00:18:01
Vamos a hacer métodos propios para el repository, ¿vale? 00:18:04
Entre ellos, uno que nos va a interesar, pues, 00:18:07
es recuperar con pedidos, por ejemplo. 00:18:10
Vale, pero hay más 00:18:11
Hay como 00:18:13
5 millones 00:18:14
Hombre, métodos propios tantos como imaginación tengas tú 00:18:16
Pero casuísticas 00:18:20
Una casuística muy típica 00:18:21
Que es, vamos a recuperar por otra cosa 00:18:23
Que no sea el ID, por otro campo 00:18:25
Eso es algo que normalmente queremos hacer 00:18:26
Pues eso, afortunadamente, Sprint 00:18:28
Me permite expresárselo 00:18:31
Con el nombre del método 00:18:33
Y ya no tengo que hacer query, yo ni tengo que hacer nada 00:18:34
Con el nombre del método 00:18:36
Entonces, por ejemplo, vamos a recuperar clientes por nombre 00:18:37
clientes por nombre no es clave primaria 00:18:40
entonces yo 00:18:42
me tiene que recuperar una lista de clientes 00:18:44
vale 00:18:46
el public ya sabéis que en una interfaz no hace falta ponerlo 00:18:47
entonces 00:18:50
de que manera le digo a 00:18:51
sprint que me recupere por otro 00:18:54
parámetro, pues find 00:18:56
y aquí pongo el nombre del otro 00:18:59
campo, empezando con mayúscula como los 00:19:02
get, pues si yo tenía 00:19:04
en cliente un nombre 00:19:06
Pues aquí en client 00:19:08
Find by nombre 00:19:11
¿Vale? 00:19:13
Y aquí le tengo que pasar el parámetro, lógicamente 00:19:15
Y ya está 00:19:17
Tal cual 00:19:19
Si es que es muy mágico 00:19:21
Así por la cara 00:19:22
Por la cara 00:19:24
Él lo implementa deduciéndolo del nombre 00:19:26
¿Vale? 00:19:29
Y no solo eso, hay más variantes 00:19:30
Aquí creo, aquí ya sí que tendría que mirar la chuleta 00:19:32
Incluso le puedes decir que te lo he ordenado 00:19:35
order descendente o algo así 00:19:38
no lo sé, tendríamos que consultarlo 00:19:40
pero no me lo sé en memoria, pero le puedes 00:19:42
poner más, creo que de hecho 00:19:44
en algún sitio lo tengo aquí 00:19:46
vamos, vamos a ver 00:19:48
no sirve de nada, no lo pregunto 00:19:49
entonces, ¿qué coño me tengo que hacer? 00:19:53
esto es un juego 00:19:54
claro 00:19:55
o lo anterior 00:19:56
después enseñamos esto 00:20:00
vamos a llegar a eso donde voy a decir, bueno, con J 00:20:02
debe ser 00:20:04
A ver 00:20:04
Los dos días antes del examen 00:20:06
Los dedicaremos 00:20:09
Podemos hacerlo un poquito antes 00:20:12
No, un poquito antes 00:20:13
A ver, solo nos queda 00:20:15
Lo único que yo quiero 00:20:17
Lo único que yo quiero que veamos aquí un poquito más 00:20:19
Es esto metido en arquitectura 00:20:22
PIRRES con Spring Boot 00:20:24
Y luego MongoDB 00:20:27
MongoDB, ver las pautas de MongoDB 00:20:29
Cómo funciona y acceder con él es de Java 00:20:31
Eso es un doble vacío 00:20:33
MongoDB es una trata no nacional 00:20:34
Más sencilla 00:20:36
Hombre, MongoDB tiene una complejidad 00:20:37
No se quiere meter, pero bueno, MongoDB más o menos de qué va 00:20:39
Esas son las dos cosas 00:20:42
Que yo quiero ver, que se ven en un par de proyectos 00:20:44
Y luego 00:20:46
Y luego ya cuando 00:20:47
Acabemos eso 00:20:50
Que en tres clases lo hemos acabado 00:20:50
O sea, en tres días lo hemos acabado 00:20:53
Pues hacer una especie de compendio de todo lo que hemos visto 00:20:54
Para resituarnos 00:20:57
Antes de nuestro examen 00:20:59
Que será 00:21:01
A ver, en principio sí 00:21:02
Sí, sí, sí 00:21:07
Que tiene que acabar todavía 00:21:08
Sostenibilidad 00:21:11
Dile que no hace falta 00:21:12
Porque para hacer un test 00:21:14
Y navegar por internet 00:21:16
Podemos estar aprendiendo a hacer 00:21:18
Sostenibilidad ya está la capa del estado 00:21:20
¿Eh? 00:21:21
Sostenibility 00:21:26
Vale, pues entonces 00:21:27
Aquí vamos a mostrar 00:21:29
Demostrar 00:21:30
Bueno, hay que sostenerles a ellos 00:21:36
Ay, que no he hecho el servicio 00:21:38
Cachas 00:21:41
Vale 00:21:42
Entonces realmente 00:21:45
Esto de tantas capas es un rollo 00:21:49
Porque un repositorio 00:21:51
Un servicio 00:21:54
Recupera 00:21:55
clientes nombre, string nombre, retun, vale, retun clientes, que es el repositorio, punto, find by nombre, ahí está, 00:21:58
vale, ya tengo en el servicio 00:22:24
el find by nombre 00:22:27
vale, accedo desde el servicio 00:22:28
ya era en mi main 00:22:31
llama service. 00:22:32
recupera 00:22:36
clientes nombre 00:22:37
que este es el que hemos hecho nosotros 00:22:38
bueno, y el de arriba también, que era servicios 00:22:40
que es mucho gusto 00:22:43
recupera clientes 00:22:44
lo único que hace es llamar 00:22:49
al método del reproductorio que acabamos de hacer 00:22:50
No hace más que esto 00:22:52
Estamos haciendo todo muy rápido 00:22:54
Bueno, a ver, no hemos hecho ninguno 00:22:56
Cliente 1 00:23:00
Voy a recuperar cliente 1 00:23:02
Que yo aquí puse a propósito para hacer la prueba 00:23:03
Dos clientes que se llamaran igual 00:23:06
Para que me recuperaran los dos 00:23:07
Cliente 1 00:23:09
Y esto como es una lista 00:23:14
Pues vamos a 00:23:16
Mostrarle los clientes 00:23:18
De esa lista 00:23:21
Correcto, vale 00:23:21
pues él ha construido 00:23:42
solo el solito, el select 00:23:45
a partir del nombre del método 00:23:46
entonces hombre 00:23:49
hay que reconocerle algunas cosas 00:23:51
¿no? 00:23:52
que haga estas cosas solo 00:23:55
está muy bien 00:23:56
vale, entonces 00:23:58
hacer métodos que recuperen 00:24:00
por otro parámetro 00:24:02
muy sencillo y ya está 00:24:04
pero hay veces que lo que yo quiero 00:24:07
es una consulta un poquito más rara 00:24:09
Por ejemplo, recuperar todos los clientes, a ver, vamos a pensar uno y luego le pedimos al JPQL, imaginaos que queremos recuperar todos los clientes que han pedido, pedidos, ¿qué? Pedido que tiene, ID y concepto. 00:24:11
que han pedido bolis 00:24:30
claro, que han pedido bolis 00:24:34
o por concepto 00:24:38
entonces, esto no es un método tan sencillo 00:24:39
de poner porque concepto 00:24:42
no es un parámetro de cliente 00:24:43
entonces, aprovecharme de esto 00:24:45
de aquí, pues no puedo 00:24:48
vale, el barra baja te deja 00:24:49
coger de dentro de 00:24:54
puede ser 00:24:55
sí, no lo sé 00:25:00
pero bueno, vamos a ponerlo como ejemplo 00:25:01
de consult método en el cual yo quiero 00:25:04
una query en concreto, quiero que haga una query 00:25:06
mi query, haz esta query y devuélveme 00:25:08
entonces, ¿qué query necesitaríamos 00:25:10
hacer para 00:25:12
recuperar todos los 00:25:14
pues una query jpql 00:25:16
que lógicamente no la vamos a hacer 00:25:18
nosotros, no vaya a ser que nos 00:25:20
cansemos y pensemos 00:25:22
demasiado y aparte porque no sabemos hacer 00:25:24
jpql 00:25:26
a ver, sí que sabríamos en realidad 00:25:27
select cliente 00:25:30
vamos a tratar de escribirla 00:25:32
a ver hasta donde llegamos 00:25:35
y luego con lo que sabemos 00:25:36
si que sabríamos escribirla 00:25:38
vale, entonces yo le digo aquí 00:25:40
esto es una query 00:25:42
vale, y ahora me voy a hacer 00:25:43
mi query 00:25:47
mi query en jpql 00:25:49
sería select, que quiero seleccionar 00:25:51
cliente 00:25:52
cliente 00:25:54
from 00:25:56
Cliente C 00:25:59
¿Vale? 00:26:02
C, front cliente C 00:26:06
Ahora 00:26:08
Tengo que ligarla con pedidos 00:26:10
Porque la búsqueda va a ser en pedido 00:26:12
Entonces esto tengo que hacer un join 00:26:15
Que tanto os gusta 00:26:17
Vale, aquí el join no es 00:26:18
Con el nombre de tabla 00:26:21
Es with 00:26:23
C.úneme con sus pedidos 00:26:24
¿Vale? 00:26:27
Únemelo con sus pedidos, por favor 00:26:29
Porque si yo no pongo join con sus pedidos 00:26:30
No me carga sus pedidos 00:26:33
No me los carga 00:26:35
Vale 00:26:35
Vale, entonces esto es para decir 00:26:36
Cárgame también los pedidos, ojo, que son P 00:26:41
Y ahora, ¿cuál es mi cláusula de búsqueda? 00:26:43
Where 00:26:49
Joler 00:26:50
Where 00:26:52
P, que es el pedido 00:26:54
Punto, concepto 00:26:56
Igual al parámetro 00:26:58
Que el parámetro jpql 00:27:01
recordad que es dos puntos con el nombre 00:27:03
que a mí me dé la gana poner 00:27:05
concepto, por ejemplo 00:27:06
vale 00:27:08
ahora le preguntamos 00:27:09
a GPS si lo hemos escrito bien 00:27:13
vale, y ahora yo aquí pondría mi método 00:27:14
que es 00:27:17
list cliente 00:27:17
recupera 00:27:23
clientes 00:27:26
por 00:27:29
la verdad es que 00:27:30
Estando en un repositorio debería ponerlo en inglés 00:27:33
Find clientes 00:27:35
Concepto 00:27:40
Y ahora yo le tengo que decir 00:27:43
Que 00:27:46
Que lo que yo le voy a pasar aquí 00:27:46
Es un parámetro 00:27:51
Vale, le tengo que decir aquí 00:27:52
Que esto lo tiene que usar 00:27:55
Como parámetro para inyectarlo aquí 00:27:57
Entonces esto lo hago 00:27:59
Con esto de aquí 00:28:01
Vale 00:28:05
No sé si lo he escrito bien del todo 00:28:05
Para 00:28:09
Stream 00:28:12
Creo que el stream hay que ponerlo delante 00:28:16
A ver, se lo voy a pasar así 00:28:18
Entre los HGPT porque 00:28:22
Más cómodo que buscar la chuleta por ahí en mis proyectos 00:28:23
Vale 00:28:27
A ver que me dice 00:28:28
Casi 00:28:40
Vale, en param, vale, el param 00:28:42
Eh, ah, vale, vale 00:28:44
Es que lo tengo que pasar aquí 00:28:46
¿Qué estaba faltando? 00:28:49
El para 00:28:54
El parámetro 00:28:54
Claro, el nombre del parámetro, parezco tonta 00:29:00
Vale 00:29:02
Este es el primer del nombre 00:29:06
Lógicamente a este le llamo 00:29:08
Como me dé la gana 00:29:10
A este le llamo como quiera, lógicamente 00:29:11
¿Vale? 00:29:14
Entonces 00:29:17
Este parámetro de aquí 00:29:18
va a servir para inyectar este 00:29:20
que esta query tiene 00:29:22
más parámetros, más incógnitas 00:29:24
aquí separo por comas 00:29:26
para bla bla bla 00:29:28
¿vale? 00:29:29
el concepto del para 00:29:32
sería el dos puntos 00:29:34
concepto, claro, esto es como 00:29:36
la interrogación del SQL 00:29:38
del prepare de statement 00:29:40
dos puntos delante y esto de ahí 00:29:42
bueno pues 00:29:44
esta de aquí 00:29:46
Ahora tendríamos que hacer un servicio 00:29:48
Claro 00:29:52
Y este así a lo bestia 00:29:53
Pues directamente retune 00:30:18
Clientes 00:30:19
Y esto era 00:30:22
Find by clientes concepto 00:30:24
Y ahora en nuestro main 00:30:32
En nuestro main 00:30:34
De aquí 00:30:43
Recupera clientes por concepto 00:30:43
Ponedle alguno 00:30:51
A ver pedidos 00:30:53
Vale 00:30:56
Pedido a uno, yo lo tengo dos veces 00:31:02
Pedido a uno por dos clientes distintos 00:31:05
Entonces puedo poner 00:31:07
Pedido a uno 00:31:11
No sé si estaba con mayúscula o minúscula 00:31:12
Con minúscula 00:31:15
Pedido a uno 00:31:17
Vale, aquí la verdad es que 00:31:22
En una consulta real 00:31:31
Sí, voy un segundo 00:31:33
¿Cuál? ¿Este? 00:31:37
es llamar al otro que hemos hecho 00:31:55
y ya está, vale, la verdad es que 00:31:56
en una consulta real 00:32:06
no haríamos 00:32:07
esta query de aquí 00:32:10
donde estamos, en cliente repository 00:32:11
no lo haríamos aquí con el igual 00:32:13
haríamos un like 00:32:15
que tuviera el, no, haríamos 00:32:17
para que el concepto no fuera clavado 00:32:20
vamos a 00:32:21
cámbiame 00:32:24
la jpql 00:32:29
para que el concepto 00:32:31
contenga un patrón, porque es que si no 00:32:36
Que se queda muy feo 00:32:38
Concepto contenga 00:32:39
Un patrón 00:32:41
En lugar de ser 00:32:43
Tal cual 00:32:46
Venga, le ponemos esto 00:32:47
Que es mucho más bonito, que sea igual tal cual 00:32:56
Vamos a ponerle esto 00:32:59
Así queda mejor 00:33:01
Que el concepto se parezca 00:33:16
O contenga 00:33:19
Esto de ahí 00:33:20
Ahora mejor, entonces si yo ahora en mi main 00:33:21
Si yo ahora en mi main 00:33:25
pongo pedido sin más, me va a sacar 00:33:29
ciento y la madre, porque todos son pedido 00:33:31
A, pedido B, pedido C 00:33:33
vale, pues con el like más bonito 00:33:34
voy a poner este y me tiene que sacar tropecientos 00:33:38
tropecientos, porque 00:33:41
todos son así 00:33:42
a ver si es verdad que me 00:33:43
saca tropecientos 00:33:47
voy 00:33:48
a ver si funciona, porque, ah bien, la query 00:33:54
estaba bien 00:33:56
y al final veis 00:33:57
todo es SQL 00:34:00
jdbc está abajo 00:34:02
con su pico y pala 00:34:04
¿vale? 00:34:06
¿y qué querías ver? 00:34:08
el concat que está 00:34:11
aquí 00:34:12
no, se lo he preguntado a él 00:34:13
le he dicho, si quiero que contenga un patrón 00:34:25
se lo he cambiado 00:34:27
le he dicho, cámbiame la jpql 00:34:29
¿dónde se lo he preguntado? 00:34:32
bueno, aquí 00:34:36
cámbiame la jpql para que el concepto 00:34:36
contenga un patrón en lugar de ser tal cual 00:34:39
porque hombre, es una búsqueda más real 00:34:41
más realista, normalmente 00:34:43
me gustaba más que el igual 00:34:45
¿cómo? 00:34:47
sí, hay upper case 00:34:56
lower, hay lower y upper 00:34:58
en JPQL por lo menos 00:34:59
y en HQL 00:35:01
supongo que en SQL 00:35:03
no sé si en SQL hay lower y upper 00:35:05
no lo sé, aquí sí lo hay 00:35:07
porque me suena haberlo visto 00:35:09
a ver, hay muchísimas posibilidades 00:35:10
entonces efectivamente esto 00:35:13
teniendo la idea básica, pues uno 00:35:15
Entonces podríamos ya que nos ponemos 00:35:17
Vamos a incorporarle el método 00:35:19
Para quitar el lazy exception 00:35:21
Este famoso 00:35:23
Que nos había dado aquí 00:35:24
Si yo quiero ver el número de pedidos del cliente 00:35:27
Después de haberlo recuperado 00:35:29
Pues vamos a hacerle un método 00:35:31
Que me recupere con pedidos 00:35:33
Entonces 00:35:35
Nos vamos a hacer 00:35:36
Otra consulta por query 00:35:40
Otra consulta por query 00:35:43
Pero ahora que la query sea 00:35:47
Seleccioname el cliente 00:35:49
Con todos sus pedidos 00:35:53
¿Cómo? 00:35:54
No lo probé 00:36:00
¿Por qué? ¿A vosotros no os ha funcionado? 00:36:02
Venga, vamos a probarlo 00:36:04
Espérate que comente esto que estaba haciendo 00:36:06
Igual 00:36:07
¿Así no te ha funcionado? 00:36:13
Yo así no lo he probado 00:36:18
Ah, perdón, este me sobra 00:36:19
Vale, a ver 00:36:23
¿Qué es lo que me falla aquí? 00:36:25
¿Por qué me ha aparecido esta? 00:36:30
¿Por qué me ha aparecido este error ahí? 00:36:32
Porque tengo aquí una llave de más 00:36:38
Ah, no, porque he comentado la llave esta sin querer 00:36:39
Vale 00:36:41
Vale 00:36:43
Entonces 00:36:47
Ahora vamos a poner pedido a uno 00:36:49
Para que sea así tal cual 00:36:52
pero ¿qué te decía? 00:36:54
me decía 00:37:08
que no había conseguido nada 00:37:09
igual al concepto 00:37:11
y el concepto es que la mente es hola 00:37:12
y puse hola 00:37:14
y tienes conceptos que se llaman hola 00:37:16
o sea te daban una excepción 00:37:18
con el contraste sabes 00:37:19
y no se puede 00:37:21
además puse la mayúscula y el menú 00:37:22
lo copio y te dejo 00:37:25
no lo sé 00:37:28
pero estaría bien que lo investigaras 00:37:32
y nos lo cuentes 00:37:34
Vale, entonces 00:37:35
Estábamos haciendo 00:37:37
Espera, voy a poner la que estaba, que me gusta más 00:37:38
Esta 00:37:41
Y ahora la que estaba yo haciendo antes 00:37:43
Era para ya que estábamos 00:37:47
Vamos a devolver 00:37:49
El cliente con pedidos 00:37:51
Para quitar la lazy esta 00:37:53
Entonces aquí es donde 00:37:55
Me falta la llave que he quitado 00:37:57
Entonces vamos a coger 00:37:59
El cliente con todos sus pedidos 00:38:03
con todos sus pedidos 00:38:06
donde cliente.id 00:38:07
sea igual 00:38:10
a el id 00:38:12
y ahora el param 00:38:13
id que sea 00:38:16
long 00:38:18
si es lo que quiero probar 00:38:18
se puede 00:38:29
claro pero lo estoy 00:38:30
uniendo a sus pedidos 00:38:35
lo estoy uniendo a pedidos 00:38:36
claro recuperame cliente 00:38:39
con los pedidos dentro. Entonces, esto se 00:38:41
salta en Lazy, porque le estoy yo forzando 00:38:43
a volver pedidos. El propio 00:38:45
de FindById no se salta. 00:38:47
Claro, el FindById no tiene 00:38:49
join. 00:38:51
No, en cualquier caso, de hacer eso, tendría que 00:38:57
hacerlo en la JPQL, porque aquí yo no puedo 00:38:59
hacer código. Pero es que en la JPQL 00:39:01
ya lo estoy uniendo con esto. 00:39:03
Creo. Es que lo quiero probar ahora 00:39:05
sobre la marcha. ¿Y dónde me 00:39:07
faltan o me sobran llaves aquí? 00:39:09
Ah, es que me sobra una, jolines 00:39:11
Vale 00:39:12
Pues entonces no me gusta 00:39:13
Eh, find clientes 00:39:18
With pedidos 00:39:21
Eh, perdón, tienes razón 00:39:23
Find cliente 00:39:27
Adelante 00:39:29
Se puede 00:39:31
Find cliente by id 00:39:33
With pedido y devuelve un único objeto 00:39:37
Cliente 00:39:39
Vale, find cliente by id 00:39:39
Con pedidos, dado ese id 00:39:43
Vamos a ver si lo hemos hecho bien 00:39:45
Tendríamos el servicio 00:39:48
Que sería 00:39:52
Public cliente 00:39:53
Recupera 00:39:59
Cliente con 00:40:04
Pedidos 00:40:07
log 00:40:10
este me devuelve 00:40:14
clientes punto 00:40:18
recupera 00:40:22
cliente 00:40:24
estoy en service 00:40:26
find 00:40:35
a ver es que esto es porque 00:40:36
tengo el este mal 00:40:38
clientes.findcliente 00:40:40
by id with pedidos 00:40:44
vale 00:40:45
entonces, este me lo recuperaría ya 00:40:46
con todos sus pedidos, entonces yo lo llamo en el 00:40:49
main, ahora 00:40:51
voy a llamar al cliente 00:40:53
que será 00:40:57
así, recupera cliente 00:40:59
con pedidos y ahora voy a intentar 00:41:01
mostrar sus pedidos 00:41:03
y aquí ya si que no me debería salir 00:41:05
la excepción 00:41:07
vale 00:41:08
No, porque hoy tengo que hacer cosas en secretaría 00:41:10
Vamos a comprobar que esto funciona 00:41:16
Y hoy ya tenéis sostenibilidad 00:41:18
Y podéis cerrar ya 00:41:21
¿No venís preparados para sosteneros? 00:41:22
C.get 00:41:29
Pedidos.size 00:41:31
Nun pedidos 00:41:35
Vamos a ver 00:41:37
si nos salen los pedidos del cliente 00:41:49
uno, sin dar errores 00:41:52
no nos salen 00:41:54
que mala noticia me has dado 00:41:56
porque tenemos que irnos 00:41:58
que mala noticia 00:41:59
el mismo 00:42:01
el mismo 00:42:20
el mismo 00:42:24
yo hice pedidos 00:42:26
a ti te cortaste 00:42:31
el mismo 00:42:35
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:
7 de febrero de 2026 - 19:00
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
42′ 39″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
197.32 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid