Saltar navegación

20251218 EjercicioInmobiliaria - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 1 de enero de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

pensar en vosotros todo el rato 00:00:00
y en qué cosas 00:00:03
os voy a contar cuando vuelva 00:00:05
he empezado a grabar así que ya no puedo 00:00:07
hablar de otra cosa que no sea esto 00:00:10
¿vale? estoy repasando 00:00:11
solamente, pues para aprovechar 00:00:14
para ponernos en contexto, antes de pasar al otro 00:00:15
enunciado, ¿vale? estoy solamente repasando 00:00:18
machacando sobre lo mismo, pues para 00:00:19
que tengáis, ¿eh? 00:00:21
¿queréis que lo completemos? 00:00:25
¿vale? Pablo, tú tienes una pregunta 00:00:27
Acabo de empezar a grabar ahora 00:00:30
Es que cuando se ponen los iconos pequeñitos 00:00:33
El pelotón rojo se pone así 00:00:35
Pero 00:00:38
Si está grabando 00:00:38
Vale, entonces 00:00:40
Esto, la gestión 00:00:43
De la, si la aplicación 00:00:45
No es multi hilo 00:00:47
Pues podemos tener 00:00:48
Ese único objeto 00:00:50
Cada vez que queremos hacer alguna operación 00:00:52
Con la base de datos 00:00:55
Usamos esa conexión para hacer lo que sea 00:00:56
Y ya está 00:00:59
el programa irá avanzando, que ahora tiene que hacer otra cosa 00:00:59
pues usará esa misma conexión 00:01:02
y ya está, porque el programa es multihilo 00:01:04
perdón, no es multihilo 00:01:06
que queremos tener en lugar de una 00:01:08
única conexión, queremos tener un montón 00:01:10
de conexiones ahí a la espera 00:01:12
e ir cogiendo una de ellas 00:01:14
que sería lo ideal 00:01:16
si tenemos un programa multihilo, entonces el multihilo 00:01:18
ya no va a coger la conexión única, porque puede 00:01:20
que esté usada en ese momento por otro 00:01:22
no debería, y sincronizar esto 00:01:24
es un coñazo, entonces si la aplicación 00:01:26
es multihilo, entonces 00:01:28
este objeto es el que nos interesa 00:01:30
que es el que gestiona mi pool 00:01:32
de conexiones, el hilo que quiere 00:01:34
una conexión le dice al pool, dame una conexión 00:01:36
la usa para eso y luego 00:01:38
la suelta, y el pool ya gestiona 00:01:40
el cierre de esa conexión, etcétera 00:01:42
vale, pues este single con gestionaba 00:01:44
estos dos 00:01:46
la instanciación de estos dos para que fueran 00:01:46
únicos 00:01:50
tenemos el getConnection y el getPool 00:01:51
y ya está, era lo único que tenía esta clase 00:01:54
y ahora ya entrábamos en la 00:01:56
aplicación pura y dura que tenemos que seguir 00:01:58
el patrón, DAO, servicio como mínimo 00:02:00
como mínimo 00:02:02
¿vale? y ya está 00:02:04
y entonces aquí dijimos que 00:02:06
en las 00:02:08
en los DAOs 00:02:10
se ponen los métodos 00:02:11
que modifican, alteran 00:02:14
consultan la entidad 00:02:16
que sea, aquí 00:02:18
todo lo que toque a empleado 00:02:20
aunque para tocar a empleado tenga que usar 00:02:22
otra base de DAO, otra tabla, no pasa nada 00:02:24
¿no? por ejemplo 00:02:26
aquí sacar el empleado 00:02:28
con más pisos alquilados 00:02:30
o lo que sea, para hacer esa consulta 00:02:32
va a haber que tocar lógicamente 00:02:34
la tabla pisos también, porque están ligadas 00:02:36
la una con la otra, pero da igual 00:02:38
el resultado es un objeto empleado 00:02:40
o a todos los métodos que trabajan 00:02:42
con una entidad, ahí 00:02:44
aunque para obtener esos resultados 00:02:46
habría que tocar otras tablas 00:02:48
aparte de los del CRUD básico 00:02:50
sin ser del ETE, etcétera, pues piso 00:02:52
luego ya hacíamos 00:02:54
aquí, lo que os dejé yo ya es para 00:02:56
que hicierais la implementación de estos métodos y de piso sería pues los el cruz y si hay algún 00:02:58
otro que le interesa a la aplicación en función de el enunciado de lo que me han pedido hacer y 00:03:10
luego ya la clase servicio donde marcamos que queremos que haga la aplicación que queremos 00:03:15
que haga, y ahí vaya 00:03:22
los métodos que va a llamar el main 00:03:24
el main o 00:03:25
el serlet o quien sea 00:03:28
o quien sea, depende de la arquitectura 00:03:30
que no lo hicimos, entonces 00:03:32
a ver, podemos 00:03:33
queréis que completemos esta aplicación 00:03:36
o la dejamos 00:03:40
yo pensaba que esta vez 00:03:42
con ella y que la dejábamos y pasábamos a la otra 00:03:44
¿queréis que la completemos? así que estamos en plan 00:03:46
vale 00:03:48
vale, pues venga 00:03:51
pues ya está 00:03:53
entonces tenemos que hacer 00:03:57
en piso dado 00:03:58
que vamos a hacer 00:03:59
solo los métodos 00:04:01
que realmente le interesan 00:04:01
al ejercicio 00:04:02
no todo el crud 00:04:03
y todo eso 00:04:04
pues a este ejercicio 00:04:04
que tenía que hacer 00:04:07
va a tener que insertar 00:04:07
empleados 00:04:08
son los únicos requisitos 00:04:09
son estos 00:04:11
pues como va a tener que insertar 00:04:11
empleados y pisos 00:04:13
un insert 00:04:15
tenemos que hacer 00:04:16
pues venga 00:04:17
void insert 00:04:19
un piso. 00:04:22
¡Hala! ¿Qué más 00:04:26
cosas nos va a interesar hacer con los 00:04:30
pisos? 00:04:32
Modificar la 00:04:34
mensualidad. 00:04:36
Pues venga. 00:04:38
Entonces, modificar la 00:04:40
mensualidad 00:04:42
es una aplicación, o sea, es un método 00:04:42
que suena más a método de servicio. 00:04:46
Entonces, 00:04:49
realmente lo que implica esto es 00:04:50
actualizar el piso. 00:04:52
Pues en el DAO lo que iría es un UBDATE piso. Y ya el servicio que coja el piso, le cambie la mensualidad y ponga UBDATE. ¿Entendéis? Es decir, hay que, de alguna manera hay que tener cierto criterio para elaborar un diseño. 00:04:53
y es, insertar un piso 00:05:11
está claro que es un método de CRUD tal cual 00:05:13
insertar, pues tal cual al DAO 00:05:15
pero modificar su mensualidad 00:05:17
esto es hacer un UPDATE 00:05:19
del piso, pues ya está 00:05:21
hacemos un UPDATE en nuestro DAO 00:05:23
y luego ya habrá un método de servicio 00:05:25
que ya sí que sea modificar mensualidad 00:05:27
recién de mensualidad nueva, pues el método de servicio 00:05:29
recogerá el piso 00:05:32
le pondrá nueva mensualidad 00:05:33
y ya llamará al UPDATE 00:05:35
¿vale? 00:05:36
claro, claro, efectivamente 00:05:39
ahí, entonces 00:05:41
todo esto son de nuevo 00:05:43
cuestiones de diseño, esto no es que sea 00:05:45
la biblia de cómo se hacen 00:05:47
las cosas, pero bueno, son 00:05:49
UBDATE 00:05:51
vale, pues aquí 00:05:54
esto, la idea de 00:05:58
UBDATE PISO, lógicamente lleva 00:06:02
incorporado que PISO 00:06:04
tendrá una clave primaria, que no se toca 00:06:06
claro, el PISO 00:06:08
tiene una clave primaria 00:06:10
entonces UBDATE PISO da por sentado 00:06:11
que las claves primarias no se modifican 00:06:14
lógicamente 00:06:17
entonces aquí en el un date piso 00:06:18
lo que hará este método 00:06:21
tendremos que hacer el SQL para que 00:06:23
el registro 00:06:25
con el ID correspondiente 00:06:28
a este objeto 00:06:29
le cambie los datos con el resto de campos 00:06:31
las claves primarias no se tocan 00:06:33
bueno, pues con un date piso 00:06:35
ya podremos hacer el servicio de modificar 00:06:37
que igual le pedís a esta aplicación 00:06:39
HGPT y la planteé de forma completamente distinta 00:06:41
pues puede ser, pero entonces vosotros 00:06:43
como ya tenéis criterio y ya no 00:06:45
tenéis el control, que es lo que importa 00:06:46
no, no, no 00:06:48
como tenéis el control, entonces ya le podéis decir 00:06:50
es cuando realmente aprendes 00:06:53
le dices, uy, ¿por qué has puesto este método aquí? 00:06:54
¿no tendría más sentido 00:06:58
teniendo en cuenta que es de DAO, que es de CRUD 00:06:59
ponerlo en este otro sitio 00:07:01
y seguramente diga 00:07:02
tienes razón 00:07:05
no, no siempre 00:07:08
busca el trabajo 00:07:10
En estas cosas 00:07:12
No te da la razón 00:07:17
Lo que pasa es que es por sistema 00:07:19
Si le haces una consulta sentimental 00:07:21
No lo sé, no se la has hecho nunca 00:07:24
Entiendo que ahí empatiza un poco más 00:07:25
Depende 00:07:27
A ver, depende en qué tipo de cosas 00:07:31
No lo sé, pero en cosas que 00:07:33
O sea, complaciente como para inducirte 00:07:35
Que hagas las cosas mal, no 00:07:38
Eso yo no lo he visto nunca 00:07:39
pero bueno, con el tienes razón 00:07:40
no me refiero a que entonces diréis 00:07:44
ay claro, es que me lo hicieron la buena 00:07:46
sino que se genera un debate interesante 00:07:48
y que normalmente las cosas que te dice al respecto 00:07:50
aunque el primer tienes razón 00:07:52
haya sido un poco complaciente 00:07:54
las cosas que te dice al respecto 00:07:56
y el debate que se genera, pues suele tener su sentido 00:07:58
entonces ahí como no habéis perdido 00:08:00
el control y sabéis la pregunta que le hacéis 00:08:02
¿y por qué lo has metido aquí? 00:08:04
es decir, ah pues tienes razón 00:08:06
Es verdad que se podría meter ahí 00:08:08
Yo no lo he hecho por no sé qué 00:08:10
Pero ya más o menos 00:08:11
Ya se lo sois capaces 00:08:13
No, no, no, tenéis que 00:08:14
Saber más que él 00:08:17
Él tiene mucha más información sobre esto 00:08:19
Está claro, pero 00:08:22
Hay que saber un poquito más que él, efectivamente 00:08:23
Y ahora, pues bueno 00:08:26
Ya empezáis a tener el control de muchas cosas 00:08:27
Vale, UDATEPISO 00:08:29
Pues lo hemos colocado aquí 00:08:32
Porque nos habla a nosotros 00:08:33
No es que diga que esto es lo mejor del mundo 00:08:35
Cambiar en un piso 00:08:37
El empleado que lo lleva 00:08:40
Pues esto también va a tirar de UDATE 00:08:41
Esto implicará el servicio 00:08:43
Esto lo tendremos que meter en el servicio 00:08:45
Alquilar piso y dejar de alquilarlo 00:08:47
Pues también va a implicar el UDATE 00:08:49
Con lo cual esto se va al servicio 00:08:51
Vale 00:08:54
Me iba a salir un chiste como los de John 00:08:55
Pero me he reprimido 00:09:00
Es que es demasiado malo 00:09:01
Hasta para ti era malo 00:09:03
No, es que cuando he dicho 00:09:05
Este se va al servicio 00:09:06
yo le digo que seguro que no lo tiene enterrado 00:09:07
pues me ha salido eso 00:09:09
pero es malo hasta para John 00:09:10
que ya lo he dicho 00:09:11
no se ha hecho gracia 00:09:15
he dicho, este entonces se va al servicio 00:09:17
y va a decir, bueno no puede 00:09:21
porque lo estoy encerrado 00:09:23
ese era el chiste, ¿ves? 00:09:24
y he dicho, no, me lo callo porque ni yo 00:09:26
he superado a John 00:09:28
Estoy a la par 00:09:35
Estoy a la par 00:09:37
Vale 00:09:42
A ver, que de esos también me puede salir 00:09:43
Dado un código de piso 00:09:45
Mostrar el empleado que lo lleva 00:09:48
Este lo habíamos metido en el DAO 00:09:50
Este lo habíamos metido en el DAO de piso 00:09:54
En el DAO de empleado, ¿verdad? 00:09:58
Este ya lo habíamos metido en el DAO de empleado 00:10:00
Ese también lo habíamos metido 00:10:02
En el DAO de empleado 00:10:05
Y este también 00:10:06
Lo habíamos metido en el DAO de empleado 00:10:08
En el DAO de empleado 00:10:10
Ya lo teníamos todo 00:10:13
Entonces ya está 00:10:14
Tenemos estos dos DAOs 00:10:16
Podríamos meter lógicamente más cosas 00:10:17
A ver, get empleado 00:10:20
Un recuperar por ID 00:10:22
Es que eso, dejar un DAO 00:10:25
Un find by ID 00:10:27
O lo que sea 00:10:29
Es un poco desagradable 00:10:29
Esto mínimo porque es que lo vamos a necesitar 00:10:32
Y estos es que 00:10:40
También están siempre 00:10:44
Vamos, que son de examen 00:10:45
No, no es que sean de examen 00:10:48
Son de aprender, de debatir 00:10:49
¿No queríais debatir cosas? 00:10:52
Pues debatamos sobre esto, sobre qué opináis 00:10:54
Sobre que esto tenga que aparecer aquí 00:10:56
Una preguntilla tengo yo 00:10:57
Por ejemplo, para ver si 00:11:00
Eso no va a ocurrir 00:11:01
Para ver si está alquilado o no 00:11:02
Puedes devolver también una lista de pisos 00:11:05
Que te diga los que están alquilados 00:11:08
Bueno, pero sería otro método 00:11:10
¿Vale? Sería otro método 00:11:12
Depende de lo que te pida la aplicación 00:11:14
Vale, entonces 00:11:18
El DAO de piso lo dejamos así 00:11:19
Y el DAO de empleado 00:11:22
Lo dejamos así 00:11:24
¿Vale? 00:11:25
Vamos a hacer la implementación 00:11:27
Pues venga 00:11:29
Para hacer la implementación, otro paquetillo 00:11:31
¿En empleado? 00:11:34
En empleado los que estaban 00:11:36
No he tocado nada 00:11:38
Tiene estos cuatro solo 00:11:39
Que creo que son los únicos que voy a necesitar 00:11:45
Desde la clase servicio 00:11:48
A lo mejor luego no y hay que meter más 00:11:49
No lo sé, pero creo que son los únicos que voy a necesitar 00:11:50
No lo sé porque no he hecho el ejercicio 00:11:53
Vale 00:11:55
Dao, venga 00:11:59
Un paquetillo, dao, implementación 00:12:04
Pues 00:12:06
Piso, dao 00:12:15
Implementación 00:12:17
Ya está 00:12:19
Y este 00:12:20
Implementa 00:12:23
Implement 00:12:25
Piso 00:12:26
Dao 00:12:29
Al implementar piso dao 00:12:30
Necesitamos 00:12:33
Toda esa morralla 00:12:35
Todo esto 00:12:39
Vale 00:12:42
Pues venga 00:12:43
Recuperar piso 00:12:45
por id, este es un 00:12:47
select, un query, para que no nos 00:12:49
hagan inyecciones SQL un prepared statement 00:12:51
pues nada, esto va a ser 00:12:53
una 00:12:55
un try con recursos 00:12:56
vale, el recurso 00:12:58
será el prepared 00:13:01
statement, verdad 00:13:03
para que se cierre solo 00:13:05
y este va a ser 00:13:08
conexión 00:13:11
que la conexión la sacamos 00:13:13
con aquí 00:13:15
Ah, sí, sí, sí, perdón 00:13:19
Ya decía yo que me estaba quedando una línea muy larga 00:13:43
Aquí estoy haciendo una cosa muy fea 00:13:45
Claro, efectivamente 00:13:47
Está una cosa bastante horrible 00:13:49
El dado depende de 00:13:50
Este objeto 00:13:53
¿Vale? 00:13:54
Y este objeto se lo vamos a 00:13:57
inyectar en el constructor 00:13:59
vale, este es el diseño 00:14:01
habitual, efectivamente, muy bien 00:14:02
estás muy despierto 00:14:05
porque es que si no, a ver, me iba a ser una cosa 00:14:06
más fea que nada 00:14:09
di que sí, vale 00:14:10
y entonces 00:14:13
aquí le vamos 00:14:14
a inyectar lo que necesita 00:14:17
que es la conexión 00:14:19
vale 00:14:21
vale, se la inyectamos 00:14:21
con lo cual aquí no hace falta esto 00:14:35
aquí hace falta el 00:14:37
Prepare statement con bajo el SQL abajo, aunque quede un poco feo, select asterisco from la tabla que se llama inmobiliaria y la tabla se llamaba pisos. 00:14:39
Donde el id 00:15:17
Igual a este 00:15:28
¿Vale? 00:15:31
¿Qué? 00:15:34
Vale 00:15:41
Y aquí ya puedo poner 00:15:42
Set 00:15:46
Int 00:15:48
Interrogación 1 igual a id 00:15:49
¿Vale? 00:15:52
A ver, aquí 00:16:04
Lo único es que el result 00:16:05
Lo ideal sería meterlo todo aquí 00:16:07
Y así el result set 00:16:10
Se cierra solo también 00:16:11
Entonces 00:16:13
Esta sentencia acaba 00:16:15
Me sobra uno de estos, ¿verdad? 00:16:19
Me sobra 00:16:21
Dos, creo 00:16:22
Es que esto, claro 00:16:23
Bueno, voy a ir quitando errores de compilación 00:16:26
Porque si no, se vaya callando 00:16:33
Vale 00:16:35
Vale, entonces 00:16:36
Aquí 00:16:38
Este paréntesis cierra aquí 00:16:39
Entonces la otra sentencia 00:16:42
Bueno, pues nada, pongo aquí el result set 00:16:45
Query 00:16:56
Vale, y ahora piso p igual a new piso 00:17:05
Y ahora ya sí que p.set 00:17:14
Pues dirección 00:17:28
rs.get 00:17:31
String, el campo dirección 00:17:34
A ver si me los aprendo de memoria 00:17:37
En piso 00:17:39
Serían dirección, mensualidad 00:17:41
Alquilado 00:17:44
Y NIF barra baja de empleado 00:17:44
Vale, entonces 00:17:46
Dirección 00:17:50
Es que esto, claro, haciéndolo tardamos 00:17:52
Se nos va un montón de rato haciendo esto 00:18:03
Pero bueno 00:18:05
Es que este ejercicio decía que lo hicierais con JDBC 00:18:05
El siguiente 00:18:11
Con el de 00:18:11
Vale 00:18:12
Setdir 00:18:13
p.set 00:18:16
mensualidad 00:18:19
igual a rs.get 00:18:26
string, mensualidad era un decimal 00:18:29
¿verdad? luego es un double 00:18:34
mensualidad 00:18:36
set 00:18:43
p.set 00:18:52
alquilado, entonces que le ponemos 00:19:00
true o false, pues no 00:19:02
depende de lo que hayamos 00:19:04
sacado aquí, pues 00:19:06
rs.get 00:19:08
get 00:19:10
alquilado era 00:19:14
entero, no 00:19:16
get in 00:19:17
alquilado 00:19:19
es igual 00:19:21
a cero 00:19:26
entonces false 00:19:27
si no true 00:19:30
vale, porque 00:19:32
que se llama alquilado. 00:19:34
Alquilado, sí. 00:19:37
Vale. 00:19:38
Y aquí estamos. 00:19:39
Nos falta... 00:19:41
Vamos a ponerle el ID también, 00:19:44
pero ese es fácil. 00:19:46
El ID es el ID que me han pasado como parámetro. 00:19:48
No tengo que sacarlo del resource set. 00:19:50
¿Y qué campo le falta a este? 00:19:53
Que este de allá es el que nos complica. 00:19:56
Tenemos... 00:19:58
Si está alquilado o no. 00:19:58
La dirección. 00:19:59
El ID y la mensualidad. 00:20:00
Nos falta el empleado. 00:20:02
y aquí hay que poner un objeto empleado 00:20:04
es que no hay otra 00:20:06
entonces, esto no es fácil 00:20:07
¿vale? porque lo que nos ha 00:20:10
recuperado el result set 00:20:12
es el nif solamente 00:20:13
entonces a través del campo 00:20:16
nif deberíamos 00:20:18
nosotros hacer un select del empleado 00:20:20
para instanciar el empleado 00:20:22
¿vale? esto es 00:20:24
lo que hace que jdbc sea 00:20:26
engorroso, que tenemos 00:20:28
que hacer todas las consultas de todo a mano 00:20:30
e ir colocando los objetos 00:20:32
si tenemos un ORM 00:20:34
no, ni siquiera 00:20:37
porque eso es para 00:20:41
las entidades, las trabajas sueltas 00:20:43
tendríamos que poner la siguiente capa 00:20:45
por encima, que es JPA 00:20:47
que ese ya sí que 00:20:49
te hace todas las consultas que haya que hacer 00:20:50
para obtenerte solo el objeto 00:20:53
si tiene que hacer varias en diferentes tablas 00:20:54
vale, pero claro, pierdes el control completamente 00:20:56
de lo que está haciendo por dentro 00:20:59
tú le dices, recupera mi objeto 00:21:00
y él te recupera el objeto y se ha tenido que hacer 00:21:02
mil select a mil sitios donde hay 00:21:04
claves ajenas para construir los otros 00:21:06
los hace, comodísimo 00:21:09
pero bueno, lo ves, entonces esto en JDBC 00:21:11
es más rollo, entonces ¿qué pasa? 00:21:13
que antes de hacer esto 00:21:14
nos falta hacer el select 00:21:16
del empleado 00:21:19
con este nif 00:21:20
entonces 00:21:21
aquí, este empleado 00:21:24
empleado 00:21:34
si tuviese 00:21:35
si tenemos el 00:21:37
Es que no quiero llamar a panolearlo 00:21:39
Vale, entonces 00:21:47
Vamos a 00:21:48
Como que lo dejamos, no, no lo vamos a dejar 00:21:50
Vale 00:21:53
Vamos a hacer la otra 00:21:54
Sentencia de consulta 00:21:56
Que necesitaríamos 00:22:00
PS1 00:22:01
Vale 00:22:02
Bajamos esto aquí 00:22:03
PS2 00:22:09
Select asterisco 00:22:11
from empleados 00:22:13
where 00:22:16
nif, ¿cómo se llama el campo 00:22:18
del empleado? 00:22:20
El campo de la tabla 00:22:21
empleado se llama 00:22:23
nif, sin más. 00:22:26
Where nif, igual a lo que sea. 00:22:30
Vale. 00:22:32
Y esto así. 00:22:33
Vale, entonces tenemos estas dos 00:22:37
consultas que son las que nos interesan. 00:22:38
Hemos sacado 00:22:41
la primera y la hemos 00:22:42
ejecutado. Vale. 00:22:44
Entonces, con esta ejecución de aquí ya podemos sacar el ID del string nif del empleado, es esto, ¿verdad? 00:22:46
rs.get string nif empleado. 00:23:07
vale, este es el nif de empleado 00:23:17
y ahora este, que es el nif 00:23:20
del empleado, esta es la 00:23:22
interrogación que nos falta aquí 00:23:24
vale, esta es la interrogación 00:23:25
que nos falta aquí, entonces aquí 00:23:28
pues podemos hacer, podríamos 00:23:30
organizar mejor el código, hacer, pero bueno 00:23:31
lo que importa es que entendamos lo que estamos 00:23:34
haciendo, vale, aquí ya podemos 00:23:35
hacer a la consulta 2 00:23:37
a la ps2, vale 00:23:39
a la ps2 00:23:41
ya le podemos hacer un 00:23:44
string con 00:23:45
Uno 00:23:52
Nif empleado 00:23:55
Esto aquí 00:23:59
Nif empleado 00:24:01
Y ahora ya la ejecutamos 00:24:04
Sacamos de aquí el nif del empleado 00:24:06
Sacamos de aquí el objeto empleado 00:24:18
Empleado 00:24:20
N igual a new 00:24:22
Empleado 00:24:24
De aquí que tenemos que sacar 00:24:26
Pues de aquí ya sacamos 00:24:39
En punto 00:24:41
Set nif 00:24:42
Pues nif de empleado 00:24:44
En punto 00:24:46
Set nombre 00:24:48
Del rs2 00:24:50
Punto get string 00:24:52
Nombre 00:24:54
En punto set 00:24:56
Nib nombre 00:25:02
Vale 00:25:03
El array de pisos 00:25:06
Pasamos de él, lógicamente 00:25:09
Set sueldo base 00:25:13
Pues rs2 00:25:15
Punto get 00:25:18
El sueldo base será dable, ¿verdad? 00:25:19
Pues get double, como se llame aquí. 00:25:22
Sueldo base. 00:25:26
Sueldo base. 00:25:32
¡Hala! Ya tenemos el empleado. 00:25:36
Y ahora ya podemos hacer la que nos faltaba. 00:25:38
P.set empleado igual a este. 00:25:41
¡Hala! Y este es el piso completo para devolver. 00:25:47
Dirección, mensualidad, si está alquilado o no lo está, su ID. 00:25:51
y para el empleado hemos sacado el empleado 00:25:55
vale 00:25:57
y ahora ya devolvemos P 00:25:58
y ahora 00:26:01
aquí 00:26:11
devuelves P 00:26:12
devuelve P 00:26:13
esto lo que pasa es que yo no quiero 00:26:16
un throws, quiero 00:26:21
un try catch 00:26:23
ahí, vale 00:26:25
retorno 00:26:28
a ver 00:26:29
Tengo el 00:26:34
Try 00:26:36
Que el try empieza aquí 00:26:38
Y el try termina aquí 00:26:40
Vale, y 00:26:43
Porque está dentro del try 00:26:45
¿Verdad? Vale 00:26:48
Entonces 00:26:49
Ahí 00:26:50
Y ahora aquí lo quito 00:26:56
Vale, y ahora ya 00:27:02
No, ahora ya me viene 00:27:07
Lo que me faltaba, es que decía, ¿por qué no me sacas lo del catch? 00:27:09
Ahora ya me viene lo del catch 00:27:11
Que me estaba faltando 00:27:13
Vale, ahora ya sí 00:27:14
Bueno, pues esto 00:27:19
Efectivamente es 00:27:25
Esto es un rollo 00:27:27
Esto es un rollo 00:27:29
Porque en cuanto hay una clave ajena 00:27:31
Para reconstruir 00:27:34
Un objeto, tenemos que hacer 00:27:36
Select del resto de tablas de las que tiramos 00:27:38
Entonces, es un 00:27:39
Claro, de la lista hemos pasado, lógicamente 00:27:41
Hemos hecho lo que se llama 00:27:43
Un find en modo lazy 00:27:45
cuando luego usemos la siguiente 00:27:46
capa nuestra que ya es JPA 00:27:50
un ORM, haremos el 00:27:51
find y ese find te 00:27:54
actualiza todo, la lista de pisos 00:27:55
el no se que, pero claro lo podemos 00:27:57
a veces no necesitamos la lista de pisos 00:27:59
y el ORM va a estar 00:28:02
haciendo por debajo una cantidad de select 00:28:04
entonces lo podremos configurar para que 00:28:05
trabaje en modo lazy, es el modo 00:28:07
vago o no modo vago, en modo 00:28:09
vago es, no me rellenes todas 00:28:12
las listas que hay dentro, todos los arrays 00:28:14
de las claves ajenas, solamente cuando te las pida específicamente 00:28:15
cuando te las pida, sí, rellénamelas, ¿vale? Entonces, bueno 00:28:19
lo que importa es que aquí, pues efectivamente vemos 00:28:22
que hay una complejidad grande en montar los objetos a mano 00:28:26
a partir de los select cuando hay consultas, hay una complejidad grande 00:28:31
pues por eso, precisamente, porque uno ya estaba escribiendo esto y dijo 00:28:35
jude, qué rollo, pues por eso se inventaron los ORMs 00:28:39
¿vale? que es lo siguiente 00:28:43
que vamos a ver, porque 00:28:45
el Spring JDBC es una capita 00:28:46
mínima que te 00:28:49
ahorra muy pocas cosas, pero no 00:28:51
vale, lo veréis 00:28:52
en el siguiente ejercicio 00:28:55
vale, pues ya está 00:28:56
aquí 00:28:59
aquí lo que 00:29:00
pasa es que hemos sido 00:29:03
vagos con el 00:29:04
SQL, yo en 00:29:09
particular, pero no tendríamos por qué 00:29:11
haber hecho los select, aquí podríamos 00:29:13
haber hecho un inner join 00:29:15
y unir el nif 00:29:16
de pisos o con el nif 00:29:18
empleado de aquí con el nif de aquí 00:29:21
y en un único select me saldrían 00:29:23
todos los campos 00:29:25
y así yo me ahorraría esta 00:29:26
cosa tan horrorosa que he hecho 00:29:29
aquí, que es un while dentro de otro 00:29:31
que da miedo verlo, esto es 00:29:33
muy feo, vale, aquí 00:29:35
podríamos haber hecho en un único 00:29:37
select, podríamos haber sacado 00:29:39
todos los campos, los del piso 00:29:41
y los del empleado, el único seller 00:29:43
con lo cual, ahora ya nos pondríamos 00:29:44
aquí a hacer todos los sets 00:29:46
primero del empleado y luego 00:29:48
del piso y listo 00:29:50
¿vale? entonces si sustituís 00:29:52
este seller por el que 00:29:55
fuera, pues ya está 00:29:56
queda mucho más sencillo el código, que sería 00:29:58
la forma de hacerlo, ¿vale? lo que pasa es que yo con el 00:30:00
SQL soy un poco 00:30:02
vaga, habría que, a ver, si lo podríamos 00:30:04
haber pedido a echar GPT el seller y no lo habría hecho 00:30:06
en un pispás y no habríamos 00:30:08
tenido que pensar tanto 00:30:09
vale, pues entonces 00:30:12
el find all queda mucho más sencillo 00:30:14
el insert 00:30:17
también queda sencillo 00:30:19
porque hemos hecho el más complicado 00:30:21
queda sencillo 00:30:22
y el actualizar 00:30:23
vamos a hacer 00:30:27
este último 00:30:29
este último 00:30:32
este último pues lo mismo, va a ser 00:30:36
más facilito que el de arriba 00:30:38
Aquí hacemos la sentencia 00:30:41
Prepared 00:30:46
Statement 00:30:47
Y aquí, ¿qué tendríamos? 00:30:49
Pues aquí tendríamos 00:31:00
Uvdate, a ver 00:31:01
Los del SQL que habéis estudiado recientemente 00:31:06
Sí 00:31:09
Luego las arreglo, pero bueno 00:31:11
Uvdate 00:31:14
Pisos, sería, ¿no? 00:31:16
Uvdate pisos 00:31:18
Set 00:31:20
¿Cómo era el UDATE? 00:31:21
Set 00:31:27
Values igual no sé qué 00:31:27
Where no sé cuántos 00:31:29
¿Cómo era esto? ¿No os acordáis? 00:31:31
Ya, pero esta es 00:31:35
Básica, deberíamos acordarnos 00:31:35
Vamos a hacer unos vagos de tres pares 00:31:37
UDATE pisos, set 00:31:38
Y aquí ya poníamos 00:31:41
UDATE pisos 00:31:43
Aquí poníamos los campos, ¿verdad? 00:31:45
¿Qué campos vamos a actualizar? El IDE no 00:31:47
Entonces, ¿qué campos vamos a actualizar de pisos? 00:31:49
Vamos a actualizar de pisos, dirección, mensualidad, alquilado y NIF de empleado. 00:31:51
Vale, pues entonces UBDATE PISOS, dirección, mensualidad, alquilado y NIF de empleado. 00:31:58
Udate pisos 00:32:19
Set 00:32:21
¿Y era un set values? 00:32:22
No, era un set, ¿no? 00:32:25
Y aquí se ponían los valores 00:32:26
Que son 00:32:27
Uno, dos, tres 00:32:28
Y cuatro 00:32:31
Set, y ahora el where 00:32:32
Sí, sí, sí, voy 00:32:34
Where 00:32:36
Igual 00:32:39
A esta 00:32:42
Y me falta 00:32:44
Esto 00:32:46
Vale 00:32:47
Udate pisos 00:32:50
Set 00:32:57
Aquí mi único mosqueo si es un values o no 00:32:57
Yo creo que no, es set 00:33:01
Ah, lo sabéis seguro, vale 00:33:02
Where id igual a esto 00:33:03
Vale, pues ya está, entonces este me dice ya lo de la 00:33:05
Sí, pues 00:33:11
Add catch 00:33:12
Y ahora ya sí, ¿qué hacemos aquí? 00:33:13
Pues aquí lo que tenemos que hacer es 00:33:16
Fijarlas estas 00:33:18
Set la dirección 00:33:20
setString 00:33:22
la primera interrogación 00:33:24
tiene que ser 00:33:27
la primera es la dirección del piso 00:33:28
p.piso 00:33:31
piso.getdir 00:33:34
ps.set 00:33:37
dirección 00:33:42
mensualidad 00:33:43
es un double 00:33:45
pues será 00:33:46
la segunda 00:33:47
interrogación es 00:33:50
piso.get 00:33:53
mensualidad 00:33:56
hombre, ha despertado 00:33:58
Brian 00:34:02
la siguiente es 00:34:03
el alquilado 00:34:06
la tercera interrogación 00:34:07
es el alquilado 00:34:10
y aquí que le ponemos, pues depende 00:34:11
de como sea piso 00:34:14
donde está 00:34:16
el alquilado 00:34:21
no hay un get alquilado 00:34:24
en piso, ah es que es un is 00:34:25
perdón, y se ha alquilado porque es un Boolean 00:34:27
es un ISO 00:34:29
sí, él lo va a cambiar 00:34:30
automáticamente, es verdad, sí, pero 00:34:36
sí, o sea, si le pones 00:34:37
se pasa a un Boolean 00:34:41
él luego en la base de datos lo va a meter 00:34:42
como entero, hace la conversión 00:34:44
como lo del Boolean, el problema 00:34:45
efectivamente es eso, que MySQL 00:34:48
y otras bases de datos 00:34:50
no manejan el tipo Boolean 00:34:51
y eso es un coñazo desde una aplicación Java 00:34:53
entonces te permite 00:34:55
que JDBC, la API JDBC 00:34:57
te permite que tú trabajes con Boolean 00:34:59
setBoolean, getBoolean, como si existieran 00:35:01
y luego hacen la conversión 00:35:03
a 0, 1, lo que haga falta 00:35:05
yo he pasado un poco por 00:35:07
hacer la mano, pero sí, efectivamente 00:35:09
entonces, si está alquilado 00:35:11
pues le pondríamos 00:35:13
un 1 y si no le pondríamos un 0 00:35:15
¿vale? 00:35:17
y nos falta 00:35:20
el string 00:35:22
del NIF del empleado 00:35:26
que es la interrogación 4 00:35:27
la interrogación 4, ¿dónde la sacamos? 00:35:31
Pues la sacamos de piso.getEmpleado.getNif y nos falta la interrogación 5, que la interrogación 5 era el id, con lo cual es un int, la interrogación 5 es un date piso, pues piso.getId. 00:35:33
y ahora que ya tenemos 00:36:02
creemos que bien 00:36:05
esto seguramente hemos escrito mil errores 00:36:06
pero bueno, eso se depura con las ejecuciones 00:36:09
cuando ya tenemos eso, pues ala 00:36:10
vale, esto me devuelve 00:36:13
efectivamente el número de columnas que realmente 00:36:21
se han visto afectadas, que debería ser una 00:36:23
yo puedo pasar del retorno 00:36:25
o puedo no pasar para usarlo para validar 00:36:27
o devolverlo 00:36:30
incluso y en función de si valido 00:36:31
Usar aquí un boolean para ver si se hizo o no 00:36:33
Bueno, pequeñas variantes 00:36:36
Cosas que podemos incorporar 00:36:38
¿Vale? Yo aquí paso de 00:36:40
Validaciones y nada, pero 00:36:42
Sí, muy bien 00:36:44
Jolín, sí que estáis despiertos 00:36:48
Efectivamente 00:36:49
Sería así 00:36:51
¿Vale? Y esto sería así 00:36:52
Todo el rato 00:36:56
En empleado 00:36:56
Que son los más raros 00:37:00
¿Vale? Por ejemplo 00:37:01
vamos a intentar hacer 00:37:03
el empleado con el sueldo máximo 00:37:06
¿vale? 00:37:09
esto sería hacer lo mismo 00:37:10
recuperar estos dos 00:37:12
podrían ser los más interesantes 00:37:14
vamos a hacer uno 00:37:16
y luego ya lo interesante sería en el servicio 00:37:17
plantear ahí los métodos 00:37:20
pues qué métodos de los DAOs va a usar 00:37:22
los servicios 00:37:23
vamos a hacer uno de los servicios 00:37:24
a ver ese servicio, cómo se construye desde los DAOs 00:37:27
pues venga, vamos a hacer 00:37:30
Por lo menos este método y luego alguno de los servicios 00:37:31
Venga 00:37:34
Pues vamos a hacer la implementación 00:37:36
El empleado famoso 00:37:43
Empleado 00:37:45
Dado 00:37:50
Implementación 00:37:51
Vale, y este 00:37:53
Implements 00:37:55
Este de aquí 00:37:59
Ala, magnífico 00:38:02
Pues por ejemplo, vamos a 00:38:12
Asumir que queremos hacer este 00:38:14
Vale 00:38:16
El empleado con el sueldo máximo 00:38:20
Pues aquí 00:38:22
Todo depende del control que tengamos en SQL 00:38:24
Si sabemos hacer un 00:38:26
Select con el max, con el no se que 00:38:28
Ya lo tenemos, que si no lo tenemos que hacer por programa 00:38:30
Vale 00:38:32
Entonces vamos a hacer 00:38:34
Lo que haríamos en la vida real 00:38:36
Vamos a pedirle el select a chal GPT 00:38:37
Pero, claro 00:38:39
no, pero en el examen 00:38:41
os pongo cosas más sencillas 00:38:48
en el examen, pues no os voy a poner 00:38:50
que tengáis que hacer una SQL complicadísima 00:38:52
pero es que esto siempre 00:38:54
aunque no supiéramos SQL 00:38:56
esto lo tenemos muy fácil sin saber SQL 00:38:57
que es hacer un SELEC de todos los empleados 00:39:00
y hacer nuestro algoritmo de máximo 00:39:02
por programa 00:39:03
tienes que hacer un FINDALL 00:39:04
de los empleados 00:39:08
y ya está 00:39:08
Por eso digo 00:39:10
Ya, pero esa respuesta de lo que él me ha dicho 00:39:13
Y he dicho, en un examen 00:39:15
En un momento dado 00:39:18
Si uno con el SQL se asusta 00:39:18
Pues haces un find all de empleado 00:39:21
Y maximizas 00:39:24
Y ya se acabó 00:39:24
Pero vamos a buscarle 00:39:25
La select al no sé qué 00:39:29
A ver, ¿cómo le preguntamos a este 00:39:32
Así por las buenas, entrándole directamente 00:39:34
Que no sabe de qué le estamos hablando 00:39:36
vosotros que sois muy hábiles 00:39:37
preguntando 00:39:42
no sé si obteniendo respuestas, eso ya no lo sé 00:39:44
pero preguntando si sois hábiles 00:39:46
¿le pasaríais el script y le diríais 00:39:48
quiero consultar esto? yo creo que sí 00:39:50
le pasaría el script de la base de datos 00:39:52
para que él la tenga y luego diría 00:39:54
hazme un select con el empleado con el sueldo máximo 00:39:55
quizás lo mejor 00:39:58
pues venga, te paso 00:39:59
un script 00:40:02
vosotros copiáis y pegáis directamente 00:40:03
ya, pero es que yo soy de otra generación 00:40:08
donde la amabilidad era un valor 00:40:10
sí, pero ahí 00:40:12
sí que deberíamos entrar al concepto de pensamiento 00:40:18
bien dicho 00:40:20
a ver, pensar piensa 00:40:26
más que nosotros 00:40:28
¿y tú qué haces? 00:40:29
¿qué hace tu cerebro? 00:40:33
¿qué hace tu cerebro que sea distinto? 00:40:34
Bueno, dicho esto 00:40:40
Sí, ese debate 00:40:47
Ahora en cuanto acabemos esto lo vamos a tener 00:40:49
Que no, que no 00:40:51
Con eso no cuentes, porque yo jamás sería tan malvada 00:40:53
Como para mandaros ahí fuera 00:40:56
Con toda esa tropa 00:40:57
Os voy a mandar fuera cuando 00:40:59
Tengáis recursos para enfrentaros a 00:41:01
A lo que hay fuera 00:41:03
Venga 00:41:04
A ver, pues estábamos diciendo que le íbamos 00:41:07
a pedir al chat GPT el este. Entonces, ya me habéis distraído, te paso un script de 00:41:09
una base de datos. Vale, y entonces voy a sacarlo de aquí, el script de la base de 00:41:15
datos inmobiliaria. Ay, qué pena, lo he perdido, el de inmobiliaria, porque no lo puedo sacar 00:41:24
aquí fácilmente, ¿verdad? Bueno, tengo un truco para sacarlo. Si tenéis que sacar 00:41:33
un script de aquí, tenemos un truco 00:41:38
para sacarlo facilísimo 00:41:40
que es, os vais a la ingeniería inversa 00:41:41
donde tenemos el diagramita 00:41:44
y de ahí que nos saque el script, vale 00:41:45
entonces 00:41:47
ingeniería inversa, next 00:41:50
vale, next 00:41:51
¿de qué quieres? inmobiliaria 00:41:56
que es esta 00:41:59
next 00:42:00
ala, next 00:42:01
ejecute, todo magnífico 00:42:04
next 00:42:07
y finish, venga 00:42:08
Vale, es esta, ¿no? 00:42:10
Esta es nuestra inmobiliaria 00:42:13
Vale, pues aquí, botón derecho 00:42:15
Copy SQL 00:42:16
Botón derecho, Copy SQL 00:42:18
Pues copiáis botón derecho, Copy SQL 00:42:22
Y vamos a pasarlos aquí a un nuevo ficherito SQL 00:42:25
¡Hala! Ya tenemos la tabla empleados 00:42:29
Toda esta basura de aquí no la quiero 00:42:32
Y ahora, vámonos a la otra 00:42:34
Nos vamos a la otra 00:42:39
Que estaba aquí 00:42:41
Botón derecho, copy SQL 00:42:42
La paso aquí 00:42:45
Todo esto no lo quiero 00:42:48
Vale 00:42:54
Pues estas son mis dos tablas 00:42:55
Vamos a pasárselo a chat GPT 00:42:58
A chat GPT 00:43:01
Pero a ver si es capaz de permanecer callada 00:43:05
Y no se puede decirme mil cosas sobre este script 00:43:07
Vale, y ahora 00:43:09
Perfecto, ¿qué necesitas exactamente? 00:43:12
Quiero 00:43:18
Una 00:43:18
Select que me 00:43:20
Saque 00:43:24
El empleado 00:43:25
Con más sueldo, ¿no? 00:43:27
Pero claro, necesitará 00:43:31
Espera 00:43:32
El empleado 00:43:36
Que más, ah no, el que más 00:43:39
Pisos alquilados tenga, vale, más fácil 00:43:40
Más fácil 00:43:42
El empleado 00:43:43
que más 00:43:45
pisos alquilados 00:43:50
tenga 00:43:53
ala 00:43:54
pues esta es la que queremos 00:43:56
¿vale? ¿nos gusta? 00:44:05
nos gusta 00:44:07
está bien 00:44:08
podríamos hasta haberla hecho 00:44:11
nosotros 00:44:13
nos saca los datos del empleado 00:44:14
contando 00:44:17
cuántas veces 00:44:19
apareces 00:44:21
el código 00:44:22
cuántos códigos aparecen 00:44:24
haciendo un join 00:44:27
en la tabla pisos 00:44:28
con su NIF 00:44:30
entonces, haciendo un join de la tabla pisos 00:44:32
con su NIF, me cuenta 00:44:35
todos los códigos que aparecen 00:44:36
y luego ya los ordena el descendente 00:44:38
para quedarse con el primero 00:44:41
¿entendido, verdad? 00:44:42
bueno, pero podemos entenderlo 00:44:45
claro 00:44:47
saca 00:44:48
los empleados 00:44:51
y además a cada empleado le pone un código 00:44:52
que es la cuenta 00:44:55
de cuántos 00:44:57
códigos de pisos aparecen 00:44:59
uniéndole a él con la tabla 00:45:01
pisos, entonces le saldrán 00:45:03
muchos empleados, cada uno 00:45:05
de ellos con la cuenta de pisos que tiene en la otra 00:45:07
tabla, me los ordena por 00:45:09
descendente y se queda con el primer 00:45:11
con lo cual el SELED 00:45:13
me devuelve un único empleado que es el que más 00:45:15
pisos tenga, pues este SELED 00:45:17
magnífico, nos parece 00:45:19
estupendo. Mira, pasa Manoli 00:45:21
por ahí, avisamos. 00:45:23
Llévala, llévala. 00:45:25
Venga, que nos sacamos. 00:45:27
Vale, pues entonces. 00:45:29
No, esta está muy bien. 00:45:30
Esta, si es como... 00:45:35
Como te llamo, Manoli. 00:45:36
Esta está estupenda. 00:45:37
Vale, que no nos gusta 00:45:41
el SQL. 00:45:42
Bueno, a ver, pasa, porque todo lo que 00:45:45
hagas por código carga al sistema. 00:45:46
Pero bueno, da igual, si no va a cargar a la base 00:45:48
de datos, da lo mismo. 00:45:50
Vale, que no nos gusta 00:45:51
Hacemos un find all de empleados 00:45:52
Y ya está, y contamos 00:45:54
Venga, pues hala, vamos a copiar esta SQL 00:45:56
Vosotros aquí hasta pasáis de 00:46:01
Ni dais gracia, ni nada, ¿no? 00:46:03
Que le den por saco 00:46:05
Venga, perfecta 00:46:06
Gracias 00:46:12
Hala, ya está 00:46:14
Un lago quemado 00:46:17
Un lago vacío 00:46:18
Ahora hay un lago menos encanada, por tu culpa. 00:46:21
Joder, hombre, un lago no. 00:46:23
Entero no. 00:46:26
A lo mejor cortan el agua un día, pero ya está. 00:46:28
¡Hala! 00:46:35
¡Hostia del Pedro! 00:46:37
Copiamos esta SQL magnífica, estupenda. 00:46:38
Y la vamos a dejar aquí copiadita para ponerla ahora cuando haga falta. 00:46:42
Espera, aquí en un stream, porque es que es demasiado gorda esta. 00:46:47
Entonces, vamos a poner aquí un string 00:46:49
Nuestra SQL es esta 00:46:51
La he confirmado 00:46:54
La he confirmado 00:47:00
Ahora, magnífico 00:47:01
Nuestra 00:47:07
A ver, ¿esto cómo se hacía para que fuera multilínea? 00:47:08
Con tres, ¿verdad? 00:47:14
¿Cómo se hace para que te admita Java 00:47:20
Un string multilínea? 00:47:22
Si le doy a como 00:47:24
Si pero hay una forma de hacer en java el multilínea 00:47:29
Pero bueno dime como 00:47:32
Ya pero porque le he puesto esto 00:47:33
A ver espérate 00:47:42
Ya que estamos 00:47:52
Como es el 00:47:52
stream 00:47:55
multilínea 00:47:56
en java, que es a partir 00:47:59
de no sé qué versión, ya no me acuerdo 00:48:01
sin tilde y sin nada, eso también 00:48:03
está secando los lagos, porque tiene que 00:48:05
hacer un mapeo por más 00:48:07
stream multilínea 00:48:09
oye, pues lo he hecho 00:48:11
bien, stream multilínea 00:48:13
lo he puesto bien 00:48:15
porque no le ha gustado 00:48:16
ah, con saltos 00:48:18
de líneas reales, ah no, pero yo no los quiero 00:48:21
con saltos de líneas reales 00:48:23
No, no, no, no 00:48:25
Es que yo quería un string normal 00:48:26
Pero es que 00:48:31
Claro, tengo que estar 00:48:31
Ah, es por el punto y coma 00:48:37
No, no es por el punto 00:48:41
¿Por qué me sigue dando aquí un error? 00:48:45
Venga 00:48:50
Quiero meterlo 00:48:51
En un string 00:48:55
Java 00:48:57
Dame la sentencia 00:48:58
Venga 00:49:02
Pues sí que está pensando 00:49:05
Para hacer un stream 00:49:08
Aquí tienes 00:49:12
Lista para pegar en Java 00:49:17
Jodido vago 00:49:19
Dentro de nada 00:49:19
Esto ya lo había hecho yo 00:49:21
Pero si es lo que yo intentaba hacer 00:49:24
El multilínea 00:49:28
Claro 00:49:28
Ah, espérate, espérate 00:49:31
Espérate, es que estáis en todos 00:49:33
Igual no 00:49:35
Sí, tengo el 21 00:49:37
Bueno, pues ya está 00:49:39
Perfecto 00:49:42
No sé qué he hecho antes, pero 00:49:50
Lo he puesto luego 00:49:52
Pero con el multilineal no 00:49:54
Vale, vale, bueno, perfecto, ya está 00:49:56
Ahora ya sí que sí 00:49:58
Vamos a copiar el try con recursos 00:50:00
Este que están 00:50:03
Estupendo 00:50:04
Copio hasta aquí 00:50:08
Empleado dado 00:50:10
Y ahora ya sí que sí 00:50:12
Prepare statement 00:50:15
SQL 00:50:19
Aquí la verdad, como no hay interrogaciones 00:50:24
No haría falta que fuera precompilada 00:50:27
Pero bueno 00:50:29
Ah, la conexión 00:50:30
No la he metido en este DAO 00:50:34
En este DAO no he metido la conexión 00:50:35
Vamos a meter la conexión 00:50:37
Vale, el constructor 00:50:40
No está empelado 00:50:49
Vale 00:50:59
Aquí le meto 00:51:02
De esas cosas se entera 00:51:04
De lo demás no despierta 00:51:06
Pero de eso 00:51:09
Ahora ya sí 00:51:09
Y ahora ya 00:51:22
Pues sí 00:51:23
Vale 00:51:26
Y ahora ya aquí el cat 00:51:28
Y ahora ya 00:51:30
Lo único que tenemos que hacer aquí es 00:51:32
Result set 00:51:35
Pero 00:51:39
a ver 00:51:42
yo, esto teóricamente 00:51:43
yo no lo iba a hacer, o sea, tenía preparado 00:51:46
un montón de cosas 00:51:47
antes que eso 00:51:49
vale, un momentito 00:51:56
ah sí, un momento, que vamos a acabar esto 00:51:57
hemos dicho que vamos a acabar esto, hacemos un método de servicio 00:51:59
de los complicados y ya está 00:52:02
qué prisa tenéis, quién os espera 00:52:03
¿os espera alguien? 00:52:05
¿qué prisa tenéis? 00:52:08
¿os espera alguien? 00:52:09
Eso, encima yendo a hacer baño 00:52:12
Pues lo mismo que a mí 00:52:15
Nadie nos espera 00:52:19
Por eso nos quedamos aquí 00:52:20
Resulset 00:52:21
Oye, pero vosotros ahora os tenéis que ir todos juntitos 00:52:25
A celebrar la Navidad 00:52:28
Ahí de verdad 00:52:29
Los jóvenes de hoy luego se os critica 00:52:34
Pero tenéis una vida más dura 00:52:36
Es verdad, lo digo en serio 00:52:37
Yo durísima tengo la vida 00:52:39
Vale, pues ya está 00:52:41
Empleado 00:52:49
A ver, este es el empleado 00:52:53
Que vamos a devolver 00:52:59
Empleado 00:53:00
Igual 00:53:06
Anul 00:53:07
Y ahora ya lo creamos 00:53:10
Y le fijamos las cositas 00:53:12
pues mientras 00:53:23
rs.next 00:53:25
¿qué ocurre? 00:53:27
vale 00:53:31
pues ¿qué hacemos? pues nada, el empleado 00:53:32
punto 00:53:35
setNIF 00:53:36
¿qué? 00:53:38
¿qué? 00:53:39
bueno pues con el jdbc template 00:53:43
no tienes que hacer el try catch 00:53:48
y no tienes que hacer, si has hecho un buen 00:53:50
mapper, no tienes que hacer el mapeo. 00:53:53
El JDBC template, o sea, el Spring JDBC, 00:53:55
lo que te arregla es no gestionar los try. 00:53:58
Y si haces un buen mapper, no tener que hacer esto que 00:54:04
estamos haciendo a mano nosotros, 00:54:09
de hacer el empleado a partir de las propiedades, 00:54:11
si has hecho un mapper. 00:54:14
Para eso es para lo que te vale. 00:54:15
¿Vale? 00:54:17
Entonces, RS, getString, el nip del select, 00:54:17
A ver, el select ya lo tenemos hecho 00:54:22
Aquí lo tengo 00:54:33
En punto set 00:54:38
Nombre 00:54:45
Punto get string 00:54:49
En punto set 00:54:50
De los pisos pasamos, lógicamente 00:54:58
RS punto get 00:55:00
Double, ¿no? 00:55:05
Y este era el campo 00:55:07
Nombre 00:55:08
No hemos sacado 00:55:10
Este select que nos ha dado 00:55:16
No nos ha sacado 00:55:17
Del empleado 00:55:20
Del empleado 00:55:22
Que está aquí 00:55:25
Nombre y sueldo 00:55:26
Vale, no nos ha sacado el sueldo 00:55:27
De este 00:55:30
Se lo podríamos poner nosotros 00:55:31
Vale, o sea 00:55:35
El select 00:55:37
Podríamos añadir aquí 00:55:39
Un e.sueldo que él no ha puesto 00:55:40
¿Vale? Un e.sueldo 00:55:42
Pero bueno, pasamos 00:55:44
No se lo pongamos 00:55:46
¿Qué sueldo base le vamos a poner? 00:55:47
Fero, a tomar por saco 00:55:49
Venga, es Navidad 00:55:50
¿Es Navidad? 00:55:53
300.000 euros 00:55:56
De sueldo base 00:55:57
Ala, pero vamos 00:56:00
Que en condiciones normales, añadís aquí 00:56:02
El campo que falta, que no lo ha metido 00:56:04
En el sele, añadís aquí el campo 00:56:06
y se lo plantáis aquí 00:56:08
y ya está 00:56:10
y ahora 00:56:12
retun 00:56:13
y se acabó 00:56:15
que me devolverá null si ha ido al catch 00:56:17
bueno 00:56:24
seguramente hay mil errorcillos, mil cositas 00:56:25
pero bueno, tendríais que probarlo 00:56:28
en 300.000 euros 00:56:30
no en euros 00:56:32
vale 00:56:32
seguro que sí 00:56:35
es que este no tiene interrogaciones 00:56:37
Este select 00:56:42
No depende de nada 00:56:44
De hecho este método no recibe nada 00:56:46
Entonces vamos a hacer algún servicio 00:56:48
Que se apoye ya sobre estos 00:56:50
Por ejemplo 00:56:52
El servicio este de aquí 00:56:53
Que era 00:56:56
Cambiar en un piso 00:56:57
El empleado que lo lleva 00:57:04
A ver como lo haríamos apoyándonos en los dados 00:57:06
¿Vale? 00:57:08
Cambiar en un piso el empleado que lo lleva 00:57:10
vale, pues esto lo haríamos en un servicio 00:57:12
de piso 00:57:15
porque afecta a piso 00:57:16
aunque ya os dije el otro día que lo de los servicios 00:57:19
ya es más flexible, a lo mejor puede haber una sola clase 00:57:20
de servicio con los requisitos de la aplicación 00:57:23
esa clase de servicio usa los dos dados 00:57:25
y ya está, depende 00:57:26
de los servicios que tengamos que dar 00:57:27
si están muy separados por entidad o no lo están 00:57:30
bueno, vamos a hacer aquí 00:57:33
nosotros un 00:57:34
y ya enseguidita nos vamos 00:57:35
vale 00:57:38
Vamos a hacer aquí 00:57:41
Un paquete 00:57:42
Y este service 00:57:44
Sería 00:57:58
Pues 00:58:00
Piso service, por ejemplo 00:58:02
Pues en este piso service 00:58:04
Nos vendría muy bien 00:58:09
Hacer un método que este ya es directamente 00:58:11
Lo que la aplicación me pide 00:58:13
Cambiar 00:58:14
Empleado piso 00:58:18
Pues venga, aquí ya no hace falta 00:58:20
Ni que sigamos estándares 00:58:23
en nombres, el DAO si que suele seguir estándar 00:58:24
insertPiso, findById, get 00:58:27
no sé qué, esto ya como depende 00:58:29
de la aplicación 00:58:31
pues entonces, este sería 00:58:32
void, aunque podría ser un 00:58:35
boolean, que verifique si se ha hecho o realmente 00:58:37
no se ha hecho, pues por ejemplo 00:58:39
cambiar 00:58:41
empleadoPiso 00:58:42
y este que recibe como parámetro 00:58:45
pues este tiene que recibir como parámetro 00:58:47
el id del piso, supongo 00:58:49
el id del piso 00:58:51
y el need del nuevo empleado 00:58:53
vale 00:58:56
ahora, el piso service va a necesitar 00:59:02
los daos 00:59:07
pero vamos a pensar, no sé si los dos 00:59:07
uno solo, ya veremos 00:59:10
vamos a ver que tendríamos que hacer 00:59:12
pues aquí la modificación, ¿quién la va a recibir? 00:59:13
la va a recibir 00:59:18
el objeto piso 00:59:18
porque el objeto piso es el que tiene 00:59:20
aquí el campo 00:59:23
la modificación la va a recibir 00:59:24
el objeto piso 00:59:27
luego aquí habrá que llamar a un 00:59:27
update de piso 00:59:30
vale, entonces vamos a ver 00:59:32
vale 00:59:34
entonces 00:59:36
nosotros primero vamos a coger el piso a modificar 00:59:37
pues para coger el piso 00:59:40
a modificar lo tenemos tan fácil 00:59:42
como llamar al find by id 00:59:44
del dao de piso 00:59:46
con lo cual el dao de piso hace falta sí o sí 00:59:48
el dao de piso 00:59:50
nos hace falta 00:59:54
y el dao de empleado 00:59:55
Puede que nos haga falta, cuando nos haga falta lo ponemos 01:00:00
Vale, el dao de piso 01:00:02
Se llama a piso dao 01:00:05
No dao piso, jolín 01:00:08
Vale, este nos hace falta 01:00:09
Vale, entonces 01:00:14
Se lo vamos a pasar por 01:00:16
Constructor 01:00:19
Todo esto es lo que 01:00:20
Nos ahorra sprint en dos instancias 01:00:24
Que era lo que quería yo ver hoy en realidad 01:00:26
Lo del sprint boot, pero bueno 01:00:30
A la vuelta, vale 01:00:31
Este es así 01:00:33
Le pasamos 01:00:35
Este, y no sabemos si luego 01:00:39
Ahora hay que modificarlo pasándole el otro 01:00:42
No lo sabemos 01:00:43
Pues ahora ya, vamos a coger el piso 01:00:44
A modificar, y para eso tenemos 01:00:57
En dado piso 01:00:59
Un maravilloso 01:01:00
Find by id 01:01:03
No sabemos si está implementado o no, pero bueno, debería 01:01:04
Ahora ya tenemos el piso 01:01:07
Ahora, al piso hay que cambiarle el empleado 01:01:08
Pues vamos a sacar el empleado 01:01:11
¿Vale? Porque piso 01:01:13
No tiene un set nif, piso tiene un set 01:01:15
Empleado, set objeto entero 01:01:17
Vamos a sacárselo de aquí, pues para eso 01:01:18
Vamos a editar también el empleado 01:01:21
Pues entonces vamos a 01:01:23
Necesitar aquí el otro 01:01:30
No sé que estoy haciendo 01:01:32
Empleado 01:01:40
Down 01:01:43
Vale 01:01:44
Y ahora, vale 01:01:49
Vamos a sacar el empleado 01:02:01
empleado 01:02:03
igual a través 01:02:05
de nuestro dao empleado 01:02:07
punto find by id 01:02:09
find by if 01:02:11
perdón 01:02:13
ahora ya si que podemos hacer 01:02:14
exacto 01:02:17
ahora ya 01:02:20
piso punto set 01:02:21
empleado 01:02:23
igual al empleado que acabamos de sacar 01:02:25
y que nos falta 01:02:28
pues nos falta actualizarlo 01:02:29
dao piso 01:02:31
punto 01:02:33
ubdate piso 01:02:35
y se acabó 01:02:37
entonces los servicios ya son 01:02:39
cosas random que la aplicación 01:02:44
me pida y se 01:02:46
apoyan sobre lo que necesiten 01:02:48
de las otras dos cosas 01:02:50
los daos ya si que son 01:02:51
deberían ser más estrictos 01:02:54
dao de piso todo lo que va a 01:02:56
alterar o consultar pisos 01:02:58
dao de empleado todo lo que va a alterar o modificar empleados 01:02:59
Claro, el servicio siempre se apoya en el DAO 01:03:02
El DAO es la primera capa que ponemos 01:03:12
Y ahora ya el main 01:03:14
Llamaría a esto 01:03:19
Y así más o menos con esto 01:03:20
Podéis completar el resto de la aplicación 01:03:27
Entonces aquí, efectivamente 01:03:30
Hacer esto a mano es estupendo 01:03:32
porque te permite optimizar al máximo la aplicación 01:03:35
nunca jamás va a tener un rendimiento mejor 01:03:38
que hecha así, nunca jamás 01:03:40
pero es un rollo 01:03:42
para hacer cuatro métodos 01:03:44
hemos estado escribiendo un montón de cosas 01:03:46
por no hablar de que necesitamos el SQL 01:03:47
hemos tenido para hacer un join 01:03:50
hemos preguntado a HGPT pero no nos acordamos 01:03:51
vale, pues a partir de ahí 01:03:53
es donde vamos ya poniendo 01:03:55
capas, vale 01:03:57
entonces 01:03:59
el siguiente ejercicio 01:04:01
que son también dos tablas 01:04:04
que una tira de otras? Pues lo hacéis 01:04:05
ya con Spring JDBC. ¿Qué Spring JDBC 01:04:07
qué arregla? Pues 01:04:09
todo este rollo de 01:04:11
los try, catch, 01:04:13
que se hace un rollo, 01:04:15
lo arregla, porque le damos la sentencia y se acabó. 01:04:17
¿Vale? ¿Y qué 01:04:20
otra cosa arregla? Todo 01:04:21
esto que hemos tenido que hacer a mano, que es 01:04:23
construir el objeto 01:04:25
y ponerle las propiedades 01:04:27
una por una. El JDBC 01:04:29
directamente, a partir 01:04:31
del select, te lo mete en el objeto 01:04:33
pero claro, le tenemos 01:04:36
que haber hecho un mapper, que es el objeto este 01:04:38
que vimos, para decirle 01:04:40
al menos, cada campo 01:04:42
del select, a qué propiedad va 01:04:43
pero si le hacemos ese mapper, él ya lo hace todo 01:04:45
¿vale? 01:04:47
pero claro, tampoco es tanto 01:04:49
no nos arregla tanto, por eso es por lo 01:04:51
que se ponen más capas por encima 01:04:54
que es lo de JPA 01:04:56
e hibernate, que es lo que veremos 01:04:57
a la vuelta 01:05:00
¿Vale? Y tenemos que revisar 01:05:00
Que era lo que yo quería revisar hoy 01:05:03
Porque al usar Spring JDBC 01:05:04
Que lo usamos el otro día 01:05:06
En este ejercicio de los trans 01:05:09
Pues al usar 01:05:11
Usábamos ya 01:05:14
¿Vale? 01:05:15
Al usar ya Spring 01:05:19
Nos olvidábamos del singleton 01:05:20
Es, usamos Spring 01:05:22
Pero aún así no perdemos el control de 01:05:25
Vale, pero ¿qué objetos necesitas? 01:05:26
Necesitas este 01:05:29
vale, pues lo metes aquí 01:05:30
en la clase de configuración 01:05:33
esta clase sería más bonita de llamar a configuración 01:05:35
aquí en la clase de configuración 01:05:37
metemos anotado como bin 01:05:39
todos los objetos que mi aplicación 01:05:41
va a usar 01:05:43
como singleton, vale, no objetos 01:05:44
de la aplicación, objetos del modelo, aquí no metemos 01:05:47
empleados, pisos, porque eso ya es 01:05:49
del modelo y habrá tropecientos mil 01:05:51
aquí los, vale, pues mi aplicación 01:05:52
va a usar un datasource, pues aquí 01:05:55
se mete anotado con bin 01:05:57
le digo como hacerla 01:05:58
vale 01:06:00
mi aplicación usa un jdbc template 01:06:01
pues lo meto aquí anotado 01:06:04
como bin 01:06:06
y además diciéndole como instanciarla 01:06:07
pues mi aplicación necesita esto 01:06:10
porque gestiono transacciones 01:06:12
pues lo meto aquí anotado como bin 01:06:14
lo que es más 01:06:16
mi aplicación necesita un dao 01:06:17
solo uno 01:06:20
mi aplicación necesita un service, solo uno 01:06:21
podríamos meterlo aquí 01:06:24
pero no lo hemos metido aquí 01:06:26
que era una de las cosas con las que yo me quería meter 01:06:28
hoy, porque en esta aplicación 01:06:30
que hicimos de ejemplo 01:06:32
ya las habíamos anotado por su cuenta 01:06:33
y habíamos puesto aquí 01:06:36
repository, entonces me da 01:06:38
igual poner aquí 01:06:40
repository y no meterla en la otra anotada 01:06:42
como bin, que no poner aquí 01:06:44
repository y meterla 01:06:46
en la otra anotada como bin, es lo mismo 01:06:48
cumple la misma función 01:06:50
sí, vale 01:06:51
y en el servicio igual, un segundo 01:06:53
Que en tres minutos de verdad que me callo 01:06:56
Y en el servicio igual 01:06:58
Necesitamos un singleton ventaservice 01:06:59
Solo uno, una instancia de este 01:07:04
Solo una instancia de este 01:07:05
Luego habría que decírselo a Sprint 01:07:07
Habría que decírselo 01:07:09
Inicialmente aquí 01:07:10
Bin y poner aquí el service 01:07:13
E instanciarlo 01:07:15
Ostras 01:07:16
¿Vale? 01:07:20
Que te lo has cargado 01:07:24
vale, entonces 01:07:25
si lo anotamos aquí 01:07:32
ya no tengo que meterlo ahí 01:07:35
entonces le doy más semántica a la aplicación 01:07:36
la aplicación sabe 01:07:39
no solo que esto es un BIM 01:07:40
sino que además es un servicio 01:07:42
y al hacer un servicio 01:07:44
pues dentro de todo 01:07:47
el ecosistema este de Spring 01:07:49
hereda e implementa cosas 01:07:50
de las que podríamos nosotros tirar aquí 01:07:52
¿Vale? Entonces, lo único es que si 01:07:54
Yo, en lugar de ponerlo 01:07:57
Como bin en el otro sitio, lo anoto 01:07:59
Aquí, pues eso me obligaba 01:08:01
A poner aquí 01:08:03
Esto 01:08:04
El component scan 01:08:06
¿Vale? Va a decir, cuidado 01:08:08
Que va a haber más bin de los que hay aquí 01:08:10
Va a haber más bin, búscalos a partir 01:08:12
De aquí, búscalos a partir de aquí 01:08:15
Si yo los hubiera metido 01:08:17
Todos aquí como bin 01:08:19
El ventaservice y el ventasdao 01:08:20
Los hubiera metido todos aquí 01:08:23
con lo cual no hubiera puesto anotación 01:08:24
repository service, este 01:08:26
component scan me sobra, porque ya 01:08:28
sprint no tiene que irse fuera a buscarlos 01:08:30
¿vale? pero bueno 01:08:32
se queda por ahora así solamente 01:08:34
y ya está 01:08:37
a la que volvamos 01:08:37
repasamos esto, porque 01:08:40
el paso siguiente a esto es 01:08:42
esto 01:08:44
ha implicado 01:08:46
gestionar los bin, ha implicado 01:08:47
decidir nosotros que es singleton 01:08:50
ni que no, anotarlo 01:08:52
ha implicado todo eso, que es 01:08:54
genial, porque lo controlamos 01:08:56
todo, pero hay 01:08:58
un siguiente paso que es, mira voy a meter 01:09:00
Spring Boot 01:09:02
con Spring Boot este fichero 01:09:03
entero no existe, desaparece 01:09:06
hacemos pin 01:09:09
y Spring Boot lo crea 01:09:10
lo hace solo todo 01:09:12
entonces claro, la gente hace aplicaciones 01:09:14
oye Spring Boot que fácil, ni puñetera idea 01:09:16
de lo que está haciendo, pues así no 01:09:18
se hacen las cosas, entonces el siguiente paso 01:09:20
es esto mismo. 01:09:22
¿Eh? 01:09:25
Esto mismo es hacerlo con Spring Boot. 01:09:26
Pero ya sabréis lo que está haciendo. 01:09:28
¿Vale? ¿Y por qué le damos 01:09:31
esa configuración que le damos? Porque en Spring Boot 01:09:32
hay que configurarlo. 01:09:34
Claro, pero bueno, esto ya lo repasaremos. 01:09:36
¿Vale? 01:09:38
Venga, pues ala. 01:09:40
Creo que os queréis ir. 01:09:42
¿Quedes bien? 01:09:44
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:
1 de enero de 2026 - 17:47
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
1h′ 09′ 47″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
310.63 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid