Saltar navegación

20260205 JPA-DTO-SPRINGBOOT_1 - 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. Pues habíamos visto que aparte de los métodos que te ofrece ya Spring Data JPA por el hecho de implementar una clase que herede de esta, que son los básicos del CRUD, recuperar por ID, por clave primaria, recuperar todos, borrar por clave primaria y save, o sea, persistir, que serían un poco los básicos. 00:00:00
Pues aparte de los básicos uno puede construir 00:00:23
Sus métodos propios 00:00:26
Basados en el propio 00:00:27
Nombre del método o en una consulta 00:00:30
Las dos formas básicas 00:00:32
Y pum, te los construye 00:00:34
Automáticamente JPA 00:00:36
Entonces 00:00:37
Recuperar por otro 00:00:39
Campo de 00:00:42
De la entidad 00:00:43
Find by y el campo de la entidad 00:00:45
Y ya está, y JPA te lo construye entero 00:00:48
No tienes que hacer nada 00:00:50
Es el ejemplo más típico 00:00:51
Pero vamos, se puede jugar más 00:00:53
De esto, esto es como JPQL 00:00:55
Que si uno se mete, pues ve que hay muchas más posibilidades 00:00:57
Pero ya sabemos las posibilidades 00:00:59
Y luego uno ya se puede meter a ver más cosas 00:01:01
Hay más reglas 00:01:03
Me refiero 00:01:05
O sea, hay más cosas que uno puede 00:01:06
Generar automáticamente a partir del nombre 00:01:12
Que exclusivamente la consulta 00:01:14
De consultar por otro campo 00:01:16
Puedes consultar por campo 00:01:17
Mayor o menor que no sé qué, si es numérico 00:01:20
Puedes hacer más cosas 00:01:22
Puedes consultarlo y además que te lo dé ordenado 00:01:24
O sea, solamente 00:01:27
Por el nombre, siguiendo ciertas reglas 00:01:28
En lo que pones en el nombre 00:01:30
Ya puedes hacer métodos 00:01:32
Que genere Spring Data JPA 00:01:34
Su código automáticamente 00:01:36
Si, creo que es order by 00:01:37
No es sort, pero vamos, sería algo así 00:01:42
Si le pones hgpt 00:01:44
Reglas para no sé qué, pues nos daría 00:01:46
Las que tiene, supongo 00:01:48
Que tiene unas cuantas 00:01:49
vale, que queremos consultas 00:01:51
específicas que no podemos generar 00:01:54
con este protocolo que 00:01:56
tiene tan chulo de a partir del 00:01:58
nombre del método que me genera el código automáticamente 00:02:00
pues plantamos la query 00:02:02
y ya está, vale 00:02:03
como aquí que hicimos esta query 00:02:06
para recuperar 00:02:07
un cliente no por un campo 00:02:09
suyo, sino por un campo de pedido 00:02:12
que tiene una lista dentro 00:02:14
entonces pues aquí 00:02:16
la ventaja del join en JPQL 00:02:18
es que no tenemos que hacer un join 00:02:20
basado en un campo de la tabla 00:02:23
porque es que aquí no hace falta 00:02:25
porque ya está dentro de cliente 00:02:27
pedidos, entonces ya 00:02:29
con poner el join lo que 00:02:31
significa aquí es, oye coge el cliente 00:02:33
pero coge también todos los pedidos 00:02:35
que tiene, coge los todos 00:02:37
aquí también está 00:02:38
el inner y el left que a ti te gusta 00:02:41
tanto, Daniel, también se 00:02:43
podría poner inner y left 00:02:45
inner join y left join 00:02:47
inner join y left join, uno de los dos 00:02:48
nunca sé cuál 00:02:50
uno de los dos es el que 00:02:51
cuando tú unes 00:02:54
una tabla con otra, con uno de los dos 00:02:56
te coge, aunque las 00:02:58
otras sean null, te las coge 00:03:01
también las originales y en el otro 00:03:02
si con la que enlazas no hay 00:03:05
son nulles, no te coge las originales 00:03:06
pero vamos, nunca sé cuál es 00:03:08
inner y cuál es left, pero bueno 00:03:10
no da igual, ¿verdad? 00:03:12
cuando pones el left 00:03:14
no te dejaría los clientes que no tienen pedidos 00:03:18
cuando pones el inner te deja clientes 00:03:21
aunque no tengan pedidos también 00:03:23
seguramente, no lo sé 00:03:24
bueno pues entonces esta 00:03:26
era una consulta que recuperábamos 00:03:28
por un campo de dentro de pedidos 00:03:31
luego no nos quedaba más remedio que hacer el join de pedidos 00:03:33
y aquí ya poníamos la condición 00:03:35
que fuera 00:03:37
pues en este caso era que fuera similar 00:03:37
a el patrón 00:03:41
con delante y detrás lo que fuera 00:03:43
pero podría ser igual, que es el primer 00:03:45
caso que hicimos, entonces 00:03:47
si le ponemos la query, pues le damos el nombre 00:03:49
que nos dé la gana, lógicamente 00:03:51
lo más explicativo posible, claro 00:03:53
y si la query tiene parámetros, pues 00:03:55
hay que poner un pack 00:03:57
de estos, un pack de estos 00:03:59
por cada parámetro, vale 00:04:01
y ya está, y JPA la genera 00:04:03
todo, que esto es realmente lo que es 00:04:05
bonito y bueno de JPA 00:04:07
que te haga los métodos solos 00:04:09
esto es lo chulo 00:04:11
¿Puedes poner más de un concepto ahí? 00:04:13
¿Puedes poner coma y luego...? 00:04:15
Sí, sí, sí. 00:04:17
Pones un pack de eso separado por coma 00:04:17
por cada incógnita que tuvieras en tu query, 00:04:20
porque podrías tener varias incógnitas. 00:04:22
Todas ellas empiezan con los dos puntos delante. 00:04:24
¿Vale? 00:04:27
Aquí pusimos este 00:04:28
para poner un método que fuera a cargar con los pedidos 00:04:30
y aquí es donde vimos 00:04:33
que el cell, si no ponemos el fetch, 00:04:34
en el jpql, si no lo ponemos, 00:04:37
te consulta los pedidos 00:04:41
para hacer lo que fuera, o sea, los tiene en cuenta 00:04:43
para luego hacer la consulta, la web 00:04:45
o lo que fuera, los tiene en cuenta, pero no los 00:04:47
mete, no los incorpora en él 00:04:49
es decir, respeta el lazy 00:04:51
este join respetaría el lazy si lo hubiera 00:04:53
sin embargo 00:04:55
si queremos que en la consulta que 00:04:57
hagamos, ese cliente devuelto 00:04:59
si incorpore también sus pedidos 00:05:01
aunque tengamos un lazy 00:05:03
en la anotación, pues 00:05:05
ponemos aquí después 00:05:07
el fetch, ¿vale? 00:05:09
entonces este método lo hicimos pues para recuperar 00:05:10
los clientes con todos sus pedidos 00:05:13
y que no nos saliera lazy bla bla bla 00:05:15
¿vale? luego ya desde el servicio 00:05:17
pues uno hace sus métodos y se acabó 00:05:19
¿vale? aquí es donde nos quedamos el otro día 00:05:21
¿vale? y bueno 00:05:23
esto está muy bien pero 00:05:25
estos 00:05:27
tres métodos que hemos puesto de ejemplo 00:05:29
que podrían ser 00:05:31
300.000 más 00:05:33
tienen la característica de que 00:05:34
todos ellos nos devuelven un objeto 00:05:37
entidad entero, el cliente entero 00:05:38
que en este caso el cliente entero 00:05:41
no es tan gordo, o sea, tiene 00:05:42
ID, nombre y lista de pedidos 00:05:44
¿vale? tiene ID, nombre 00:05:46
y la lista de pedidos, tampoco tiene tanto 00:05:50
pero claro, porque estamos haciendo un modelo muy sencillito 00:05:52
con poquitas cosas 00:05:55
pero en una situación real 00:05:56
las entidades del modelo 00:05:58
tienen dentro la leche 00:06:00
un montón de propiedades 00:06:02
de colecciones que las están ligando 00:06:04
con otras, un mogollón 00:06:06
Entonces, ¿realmente necesitamos que todas las consultas que vamos a poner aquí, luego en los servicios, estén basadas en retornos sobre los objetos enteritos? Seguramente la información me sobre, ¿vale? Yo no necesito tanta información. 00:06:07
O sea, ese método a lo mejor está en particular solo para trabajar con el nombre y no sé qué más del cliente. Entonces, yo estoy condenada a devolver siempre objetos completos con todo lo que tienen dentro, que eso es no solo pesado, sino pues peligroso. 00:06:28
O sea, estoy mandando fuera de mi servicio, estoy mandando el objeto con un montón de información, ¿vale? Es decir, estoy como si estuviera lanzando fuera, exponiendo al universo toda mi lógica de negocio entera cada vez que hago un servicio. 00:06:48
Toda la lógica de negocio 00:07:04
Va para afuera 00:07:06
¿Vale? Entonces, bueno 00:07:06
¿Realmente es necesario? 00:07:09
Siempre va a ser necesario 00:07:12
Hay veces que sí, ¿no? 00:07:14
Si yo aquí quiero devolver 00:07:15
El cliente entero con todos sus pedidos 00:07:17
Con todo, pues ya está 00:07:20
Pero no siempre es necesario 00:07:21
¿Vale? Pues, ¿qué hacemos normalmente? 00:07:22
¿Qué se hace normalmente? 00:07:25
Hacer entidades que no son entidades 00:07:27
Del modelo, sino que están pensadas 00:07:29
Exclusivamente para recoger 00:07:32
datos que tú 00:07:33
quieres consultar 00:07:36
y luego transmitir. O sea, son los objetos 00:07:37
que sirven para almacenar 00:07:39
resultados de consultas. 00:07:41
¿Vale? ¿Perdón? 00:07:43
Como tablas intermedias. 00:07:45
Como si fuera una vista 00:07:47
en el concepto de SQL, ¿vale? 00:07:49
Como si fuera una vista 00:07:51
que tú en una vista seleccionas 00:07:52
qué datos te gustan de una tabla 00:07:55
y no los tienes todos todo el rato 00:07:57
porque es un mogollón. Pues es como si fuera 00:07:59
una vista, entonces no es una entidad del modelo 00:08:01
no forma parte de la lógica de negocio 00:08:03
la lógica de negocio son mis entidades 00:08:06
del modelo y ahí está toda la información 00:08:07
con todas las anotaciones, con todo 00:08:09
entonces yo eso lo dejo ahí protegidito 00:08:11
y lo que 00:08:14
expongo al exterior, lo que mando 00:08:16
fuera a través de los métodos 00:08:18
primero del repositorio y luego del servicio 00:08:20
son estas 00:08:22
vistas, entre comillas 00:08:24
estas vistas que para cada consulta 00:08:25
tienen los datos que le interesará 00:08:27
a esa consulta, exclusivamente esos 00:08:30
y esos ni tienen anotaciones 00:08:31
ni tienen nada, porque no pertenecen a la modelo 00:08:33
ni pertenecen a nada 00:08:35
esos son los famosos DTOs 00:08:36
que se llaman los Data Transfer Object 00:08:39
que forman parte 00:08:41
de cualquier arquitectura de estas 00:08:43
y DTOs, pues de nuevo 00:08:45
es otra capa más 00:08:47
como le gustan a Pablo 00:08:49
pues sí, lo podríamos ver como otra capa más 00:08:50
en realidad no es que sea una capa 00:08:53
es una capa de vistas 00:08:55
es como un paquete con vistas 00:08:58
es lo que yo realmente 00:09:05
quiero mandar hacia afuera 00:09:07
lo que yo realmente quiero mandar hacia afuera 00:09:09
aquí a lo mejor no se ve 00:09:11
tanto la utilidad de eso 00:09:13
pero cuando tienes una arquitectura p-rest 00:09:15
es básico 00:09:17
como ya 00:09:18
veremos la semana que viene 00:09:20
porque tú cuando pides tus objetos 00:09:22
haces tus consultas en una arquitectura p-rest 00:09:25
aquí cuando lo haces 00:09:28
el resultado está en tu propia aplicación 00:09:29
tu propio main o donde sea 00:09:31
y tú pues con eso 00:09:33
ya haces lo que seas, traes lo que quieras 00:09:35
lo pasas a no sé dónde, te metes en el objeto 00:09:37
pero cuando tú haces la consulta 00:09:40
desde un servicio API REST 00:09:42
desde tu web 00:09:43
pues lo que te devuelve es el resultado 00:09:44
de esa consulta mapeado en un JSON 00:09:47
entonces ¿qué necesidad tienes tú 00:09:49
de mapear en un JSON? 00:09:52
un objeto que tiene millones de cosas dentro 00:09:53
un JSON 00:09:56
manejable. 00:09:57
Entonces, tú lo que te haces son 00:09:59
tus data transfer object que tienen 00:10:01
solo la información que necesitas y eso 00:10:03
ya sí que se mapea en tu JSON ya cortito 00:10:05
y manejable. Es que, de hecho, 00:10:07
la locura que se monta, 00:10:09
imaginaos aquí, mapear 00:10:11
esto en un JSON. O sea, yo saco esto. 00:10:13
Saco un cliente 00:10:16
con mi método de servicio y cliente. 00:10:17
Y el API REST, el pobre, 00:10:19
pues, ¿qué hace? Lo que hace 00:10:21
es, te lo mapea 00:10:23
un JSON, porque es lo que tú vas a ver. 00:10:25
Te lo mapea un JSON 00:10:27
Entonces, mapear a un JSON 00:10:28
ID y nombre está bien 00:10:30
Pero ponte a mapear a un JSON pedidos 00:10:31
Muy bien, pedido, me pongo a mapear 00:10:34
En JSON pedidos 00:10:36
Y ID y concepto 00:10:37
Pero ahora tengo que mapear cliente 00:10:40
Muy bien, me voy a poner a mapear cliente 00:10:42
Tiene 00:10:44
ID y nombre, pero tiene pedidos 00:10:45
Con lo cual me meto en un bucle infinito 00:10:48
Entonces, yo de repente hago 00:10:50
Una inocente petición 00:10:52
Y mi página web no para 00:10:53
Claro, solo puedo ñapar 00:10:55
Poniendo anotaciones 00:10:58
Pues ignoran el Jason 00:11:00
Pero ya es hacer una ñapa 00:11:02
Ya es hacer 00:11:03
Una ñapa y decirle a Jackson 00:11:05
Esta propiedad no cuenta, pero claro, no cuenta para la PIRRES 00:11:07
A lo mejor sí cuenta para otros 00:11:10
Conclusión 00:11:11
Deteos, ya está 00:11:14
¿Os lo he vendido suficientemente bien? 00:11:15
No, ya estáis convencidos 00:11:17
¿No? Vale, pues 00:11:19
Entonces 00:11:21
Ya respiro 00:11:23
Porque es que sois un poquito 00:11:26
Exquisitos 00:11:28
Estáis todo el rato, pues no lo veo 00:11:29
Pues yo creo que no sé cuánto 00:11:32
Es que claro, todos hacéis tambalear 00:11:33
Mis cimientos que ya son 00:11:38
Frágiles de por sí 00:11:39
No hombre, ya lo sé 00:11:41
Vale, pues entonces 00:11:46
Seguro que no 00:11:47
Vamos a meterlo 00:11:50
En un paquetito 00:11:52
Y es que realmente 00:11:54
Yo sé que encima os provoco, ya lo sé 00:11:58
Pero es que 00:12:00
La cantidad de paquetes que llevamos 00:12:01
Para solo poder hacer un main 00:12:04
Que en una consulta 00:12:06
JDBC 00:12:08
Es un getConnection 00:12:09
Se ejecute query y ya está 00:12:12
Pues la cantidad de paquetes 00:12:14
Que llevamos, pero claro, ¿quién escala 00:12:16
Una aplicación con JDBC y quién escala esto? 00:12:18
Con JDBC, pues no es trivial 00:12:20
Al escalarla, con esto se supone que sí 00:12:22
Ampliarla 00:12:24
A ver, yo hice 00:12:25
Espera, esto no lo voy a grabar 00:12:33
A ver, no porque 00:12:35
Ya he contado la anécdota 00:12:36
De vieja cebolleta 00:12:40
Seguimos 00:12:41
Vale, pues vamos a hacer 00:12:42
Un paso intermedio, venga 00:12:45
Tenemos aquí una 00:12:47
Una 00:12:49
Un modelo tan pequeñito 00:12:51
Que pocas cosas podemos hacer 00:12:53
Pero por ejemplo, vamos a recoger 00:12:54
El nombre 00:12:57
Porque es que en pedido repository 00:13:01
Poco podemos hacer, solo tiene un cliente 00:13:03
Vamos a recoger 00:13:05
El id 00:13:06
Y el nombre 00:13:09
Y algo 00:13:10
Que se salga del 00:13:13
Que sea un agregado 00:13:15
Pues vamos a recoger id 00:13:16
Nombre 00:13:19
y el primero de la lista 00:13:19
ni siquiera el más caro 00:13:22
es que no tenemos ni precio 00:13:24
y el primer pedido de la lista 00:13:25
vale 00:13:29
eso lo podríamos hacer 00:13:31
con un JPQL directamente 00:13:33
pero si no tendríamos que hacer que en el repositorio 00:13:34
nos devuelva a todos y luego en el servicio 00:13:37
ya el primero de la lista 00:13:39
entonces 00:13:40
el cliente con su número de pedidos 00:13:41
cliente y cuantos has pedido 00:13:47
El cliente y cuántos has pedido 00:13:49
Esa sí que es una consulta que quizá tiene más sentido 00:13:50
El cliente y cuántos has pedido 00:13:53
Vale, pues entonces 00:13:54
Esa información se correspondería 00:13:56
A una vista de esta manera 00:13:59
Vale 00:14:00
Primera, hay como dos posibilidades 00:14:02
De DTO, de vistas 00:14:06
Primera, la más 00:14:07
Cliente 00:14:09
En un pedidos 00:14:11
La más sencilla 00:14:13
Yo me hago aquí una interfaz, mi vista es una 00:14:20
interfaz y me da 00:14:22
los datos con el get, vale 00:14:24
pues hemos dicho 00:14:26
era long, verdad, el id 00:14:27
long get id 00:14:30
es uno de los parámetros 00:14:32
el otro era nombre, string 00:14:34
get 00:14:36
nombre 00:14:39
y el número de pedidos 00:14:39
que sería un integer 00:14:44
num pedidos 00:14:46
del cliente 00:14:49
vale, esta es una vista muy sencilla 00:14:53
ahora 00:14:55
entonces fijaos que 00:14:59
puede haber muchos en una aplicación 00:15:05
porque cada consulta es interesante 00:15:08
que tenga agregados de cosas distintas 00:15:10
que son transversales a las entidades en sí 00:15:12
vale, ahora yo ya me voy a mi 00:15:14
repositorio, pues venga 00:15:16
vamos a hacer una query 00:15:17
que ahora veremos 00:15:19
como la hacemos 00:15:23
vale, y esta query 00:15:25
se va a implementar 00:15:32
en el método que me devuelve una lista de esta, me devuelve cada cliente con su número 00:15:34
de pedidos. Get clientes con un pedidos. Entonces no tendría parámetros porque me los tenía 00:15:46
que devolver todos. Y esto pues nada. Y ahora hacemos nuestra JPQL. Vamos a lanzarnos a 00:16:10
hacer lo que sea y si no pues se la pedimos son clientes ahora yo aquí no pongo esto esta es la 00:16:20
historia que aquí no tiene sentido hacer esto from from cliente c vale aquí no tiene sentido 00:16:28
aquí lo que yo pongo son los campos que quiero hacer exacto que serían c punto y de verdad c 00:16:36
Punto nombre 00:16:44
Y ahora 00:16:45
La cuenta de pedidos 00:16:47
Que sería count c punto 00:16:49
Pedidos 00:16:52
Pero claro, para que me tenga los pedidos 00:16:53
En cuenta en esta jpql 00:16:56
Tengo que hacer el join 00:16:58
Si no, no me 00:16:59
Los va a tener en cuenta 00:17:01
Count c punto pedidos 00:17:03
Como el alias 00:17:06
Porque ya le he puesto un alias 00:17:07
Perdón 00:17:10
count es de SQL 00:17:14
¿verdad? en SQL es count y en JPQL 00:17:17
juraría que también 00:17:19
bueno 00:17:21
es como SQL, que da igual 00:17:25
no es sensible a mayúscula, minúscula 00:17:26
¿vale? 00:17:28
en Android por ejemplo lo tenemos 00:17:29
Manoli era sensible a mayúscula 00:17:31
vale, a ver 00:17:35
igual 00:17:37
si os gusta más así 00:17:39
para que se vea claro que esto es JPQL 00:17:40
Y ahora, yo hice pedidos, pero claro, para que no me devuelva, porque la consulta así tal cual, o sea, estoy guiándome por SQL, la consulta así tal cual me devolvería el primer cliente tantas veces como pedidos tiene con su número de pedidos, porque se va a unir a pedidos. 00:17:43
entonces lo tenemos que agrupar, ¿no? 00:18:07
con el group by 00:18:09
group by 00:18:10
lo vamos a agrupar 00:18:13
por c.id 00:18:15
para que todo esto me lo agrupe 00:18:17
los que sean iguales, todos los que tengan 00:18:19
todos los resultados de la consulta 00:18:22
que tengan id y nombre igualitos 00:18:24
pues que lo agrupe 00:18:26
porque todos van a tener el count de pedidos igual, ¿no? 00:18:27
vale, entonces 00:18:30
agrúpamelo 00:18:31
y ya está 00:18:32
yo creo que esta JPQL 00:18:36
estaría bien 00:18:41
vamos a lanzarnos, si no rápidamente la cambiamos 00:18:41
y ya está 00:18:45
porque no 00:18:45
es que no voy a seleccionar el cliente 00:18:49
entero, estoy seleccionando 00:18:51
campos que a mí me da la gana 00:18:53
elegir para formar 00:18:55
esta vista 00:18:57
o sea, estoy construyendo esta vista con campos 00:18:58
sueltos, uno es el ID, otro es 00:19:01
el nombre, pero podría a lo mejor 00:19:03
Ni siquiera creer el ID, entonces no pongo ni el ID 00:19:05
¿Vale? O sea, estoy seleccionando 00:19:07
Campos sueltos de las tablas que estoy 00:19:08
Haciendo, cliente y pedidos unidas 00:19:10
Claro, en este caso 00:19:12
Una lista, claro, porque 00:19:17
No tengo un web, entonces 00:19:18
Todos 00:19:20
Bueno, pues entonces 00:19:21
Esto en principio 00:19:24
Creemos que estaría 00:19:25
Vamos a ponerlo en el servicio, claro 00:19:27
Pues venga, le ponemos 00:19:30
Un método 00:19:39
public list 00:19:40
cliente num 00:19:46
pedidos 00:19:49
y este sería 00:19:51
lista clientes 00:19:55
con num 00:19:58
pedidos 00:20:00
y este te devuelve directamente 00:20:01
clientes 00:20:06
punto 00:20:10
get clientes 00:20:11
num pedidos 00:20:14
ahí está, y ahora nuestro main 00:20:15
que está 00:20:22
Aquí 00:20:26
Nuestro main que está aquí 00:20:27
Todo esto ya nos había funcionado 00:20:31
Y ahora vamos a hacer 00:20:33
Nuestro servicio 00:20:41
Los tabuladores ya ni sé cómo están 00:20:44
Lista clientes 00:20:48
Con numpedidos 00:20:50
Punto 00:20:51
Para cada cliente con numpedidos 00:20:54
Este es un 00:20:56
Interfaz 00:21:00
No tiene un toString 00:21:01
Así que vete a saber el system out cual es 00:21:04
Pues para cada uno de ellos 00:21:06
Vamos a mostrar directamente 00:21:09
Vamos a mostrar 00:21:10
X.getNombre 00:21:19
Del id pasamos para 00:21:23
Claro, JPA es tan listo 00:21:31
Que él ya te instancia un objeto 00:21:33
Que pertenezca a esa interfaz 00:21:36
Cuando te hace la query 00:21:37
¿Vale? 00:21:38
Es decir, ¿qué hace JPA? 00:21:40
JPA cuando haga este select 00:21:42
Claro, le va a dar estos tres valores 00:21:43
Como ve que tiene que volcarlos aquí 00:21:47
Como ve que tiene que volcarlos aquí 00:21:49
Pues te instancia un objeto 00:21:51
Que implemente esta clase 00:21:53
Y te lo mete, y ya está 00:21:54
Y luego tú, ¿qué es lo único que puedes hacer? 00:21:56
Sacarle los datos, no puedes hacer nada más 00:21:58
Sacarle los datos 00:22:00
Entonces vamos a ver si tenemos suerte 00:22:02
Y nos falla 00:22:05
Y podemos arreglar el fallo 00:22:06
¿Qué? 00:22:13
No, ojalá falle 00:22:16
Porque si falle vamos a aprender algo 00:22:17
Eso sin duda 00:22:19
Si no falla no vamos a aprender nada 00:22:19
Bueno, que esto funciona en este caso muy concreto 00:22:21
Pero a lo mejor está muy próximo a un fallo 00:22:25
Y si no lo pillamos 00:22:28
No aprendemos 00:22:29
Claro 00:22:30
Qué poca resistencia 00:22:33
La tolerancia a la frustración tenéis 00:22:38
Qué suerte hemos tenido 00:22:40
Vale 00:22:45
El select me lo ha hecho 00:22:46
Con lo cual la 00:22:49
La sintaxis jpql está bien 00:22:50
Hasta ahí hemos llegado 00:22:53
Pero 00:22:53
Invalid method bla bla bla 00:22:55
Get client en un pedidos 00:22:58
Como que no, está mal 00:23:03
Ah, es que he puesto en un pedidos 00:23:04
En lugar de poner get en un pedidos 00:23:06
¿Verdad? 00:23:08
Vale, entonces a ver 00:23:11
¿Dónde está el cliente en un pedidos? 00:23:12
Vale, vale 00:23:14
Espérate, es que aquí yo me he inventado 00:23:16
Un nombre un poco raro 00:23:18
Vale, getNumPedidos 00:23:19
No he puesto la sintaxis de getter 00:23:22
O sea, he hecho lo que me ha dado la gana y eso es feo 00:23:24
Vale 00:23:26
GetNumPedidos, vamos a ver ahora 00:23:29
Que podría estar la cosa en otro lado 00:23:31
Vale, null, null, null, null, null 00:23:33
Null, null, null 00:23:44
Va a ser que no tengo la base de datos 00:23:47
Lanzada 00:23:49
Va a ser eso, ¿verdad? 00:23:50
¡Qué problemón! 00:23:59
Vale, a ver 00:24:05
Ahora está lanzada 00:24:06
Si ahora falla, ya sí que 00:24:07
Vamos a vernos en un problema serio 00:24:09
Muy serio 00:24:12
Sí, porque no vamos a tener ni idea 00:24:12
Pero 00:24:15
¿Nul, nul, nul? 00:24:16
¿Y por qué nos aparece nul, nul, nul? 00:24:19
¿Qué he hecho yo mal en la query? 00:24:21
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:02
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
24′ 26″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
103.44 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid