Saltar navegación

20251211 BDR-SPRING-JDBC - 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 11 de diciembre de 2025 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, pues vamos a dar nuestro siguiente pasito en el tema de acceso a datos, 00:00:01
que es el que nos interesa a nosotros. 00:00:07
¿Verdad? 00:00:09
Pues mira, es de lo poco que te puede interesar en la vida. 00:00:15
¿Qué? 00:00:26
Joder, con el sprint de los cojones. 00:00:30
¿Qué? 00:00:32
vale, vamos a 00:00:32
que sí 00:00:35
me da lo mismo que esté grabando 00:00:36
me da igual 00:00:39
vale 00:00:40
pues vamos a ponerle una pequeña capita 00:00:42
¿vale? 00:00:45
os vais a cagar 00:00:46
¿queréis sprint? 00:00:48
os vais a cagar 00:00:50
os vais a cagar 00:00:51
¿vale? 00:00:54
pero vamos 00:00:55
por la pata abajo enterita 00:00:57
y os vais a arrepentir 00:00:59
¡Ay, sprint, sprint! ¿Pero qué crees que es sprint? 00:01:02
¿Alguien con solución a la vida? 00:01:05
Si tú lo quieres manejar bien y lo quieres 00:01:06
entender, te vas a cagar. 00:01:08
Hazme caso. Te vas a arrepentir. 00:01:11
Vale. 00:01:14
Bueno, pues vamos a 00:01:16
poner una primerita 00:01:17
capa de abstracción. 00:01:18
Bueno, a ver, es una broma, no pasa nada. 00:01:20
Es una broma todo. 00:01:24
No os asustéis. 00:01:25
No, no. 00:01:27
de verdad, confía en mí 00:01:27
no los pongo yo, los pone la vida 00:01:36
los pone el universo, los pone el entorno 00:01:38
claro 00:01:40
vale, pues entonces 00:01:41
en esta aplicación que hemos hecho 00:01:43
bueno, tenía un 00:01:46
serlet, pero eso ahora mismo es un detallito 00:01:48
para nosotros, vale, nos da igual 00:01:50
un main, un serlet, la capa 00:01:52
sobre todo que nos importaba 00:01:54
que es la nuestra 00:01:55
la de nuestro módulo es esta 00:01:57
la implementación del DAO 00:01:59
¿vale? entonces la implementación 00:02:01
del DAO es la que tiene el acceso 00:02:04
a datos 00:02:06
vale, pues nosotros 00:02:06
lo hemos hecho con 00:02:08
JDBC puro 00:02:11
que es lo que hay 00:02:13
lo que está ahí abajo 00:02:15
y no hay nada más que eso, otra cosa 00:02:17
repito, es lo que vayamos poniendo por encima 00:02:19
para encapsular o enmascarar esto 00:02:21
pero esto es lo que hay 00:02:23
entonces nosotros lo vemos 00:02:24
y bueno, vale, no es tan horrible 00:02:26
pero bueno, tiene un try 00:02:28
con recursos que es un poco 00:02:30
feo, tiene aquí 00:02:32
pues bueno, este en particular 00:02:35
que es hacer un insert no tiene tanto 00:02:37
pero este de aquí, por ejemplo 00:02:39
que era recuperar por ID 00:02:41
pues ya empieza, con esta 00:02:42
generación de vagos, pues ya 00:02:44
empieza a angustiarnos 00:02:46
porque yo tengo que devolver una venta 00:02:47
pero lo que saco 00:02:51
con el result set 00:02:53
pues lo que saco con el query 00:02:54
son valores sueltos 00:02:55
entonces tengo que preocuparme de instanciar 00:02:57
la venta, poner los valores sueltos 00:03:00
uff, que pereza 00:03:02
ver todo esto aquí, por no hablar de capturar 00:03:04
las excepciones 00:03:06
pues 00:03:07
si es fácil 00:03:10
bueno, os pondré 00:03:12
os dejaré para el fin de semana 00:03:14
esta tarde yo me daré a tiempo 00:03:16
pues algunos ejercicios para que 00:03:18
practiquéis con JDBC 00:03:20
que no son más que pues seguir haciendo 00:03:21
consultas, borrados, lo que fuera 00:03:23
para que practiquéis con el JDBC 00:03:25
que será pues poner las sentencias que sean 00:03:27
ejecutarlas y comprobar que funcionan 00:03:30
y ya 00:03:32
¿vale? 00:03:32
bueno, pues esto ya, entre capturar 00:03:35
excepciones, mapear 00:03:37
mis campitos sueltos 00:03:40
a un objeto 00:03:41
eh, abrir y, preocuparme 00:03:43
de abrir y cerrar las cosas 00:03:45
gracias al try con 00:03:47
recursos, pues no tengo que preocuparme de cerrarlas 00:03:49
pero bueno, tengo que preocuparme de poner un try 00:03:51
de este estilo, pues esto ya empiezan a quedar 00:03:53
códigos un poquito 00:03:55
feos y sobre todo que me obligan a 00:03:57
preocuparme de muchas cosas 00:03:59
bueno, pues hay una primera 00:04:00
y pequeñita, una primera y pequeñita 00:04:03
capa de abstracción que podemos 00:04:05
poner 00:04:07
que se llama Spring 00:04:08
JDBC, vale 00:04:11
porque Spring es mucho 00:04:13
pues hay una pequeñita capa de abstracción 00:04:14
que podemos poner 00:04:19
que viene dada a través de 00:04:20
esto 00:04:25
de una de las partes de Sprint 00:04:26
que encapsula el JDBC, una pequeñita 00:04:29
capa de abstracción, ligera 00:04:31
no tiene nada que ver con el líder de Sprint 00:04:32
no tiene que ver, forma parte del líder de Sprint 00:04:35
Sprint es una cosa muy gorda 00:04:37
y esta es una parte de Sprint 00:04:38
esta es una parte de Sprint 00:04:43
que me permite poner una capa 00:04:45
ligera 00:04:47
entonces, esta capa ligera 00:04:47
esta capa 00:04:50
ligerita 00:04:52
esta capa 00:04:53
ligera 00:04:57
no es la 00:04:57
capa gorda que también puede hacer el sprint 00:05:00
con el sprint data JPA no es la capa gorda 00:05:02
porque es que esa capa gorda, que es una capa 00:05:04
más gorda que viene por arriba 00:05:06
esa yo ahí ya sí que no veo SQL 00:05:07
ni veo nada, de repente todo aparece 00:05:10
y así no se hacen las cosas 00:05:12
porque luego no entiende uno lo que está pasando 00:05:14
por debajo, entonces sprint JPA 00:05:16
es una primera capa ligerita 00:05:18
que todavía te permite tener tu acceso al SQL. 00:05:20
Tú lo ves y tú haces las sentencias SQL que tú quieras. 00:05:24
Entonces, eso te permite optimizar el acceso a la base de datos 00:05:28
porque tú seleccionas los SQL que quieres. 00:05:32
No como con el sprint más la siguiente capa de sprint 00:05:35
que tú ahí no haces SQL para nada. 00:05:39
Entonces, si esta capa no me evita hacer SQL, 00:05:44
no me lo evita, ¿qué me evita? 00:05:48
Pues me evita 00:05:51
una de las cosas más importantes 00:05:52
y pesadas. 00:05:54
Lo que se llama 00:05:55
el mapeo. 00:05:58
Me evita lo que se llama 00:06:02
hacer el mapeo, que es 00:06:03
pasar de campos sueltos 00:06:05
que yo me he sacado de aquí, 00:06:08
pasar a mi objeto. 00:06:10
Me evita el mapeo, ¿vale? 00:06:12
A través de una cosa que ahora instanciamos 00:06:14
que se llama 00:06:16
todo lo que vamos a ver 00:06:17
lo vemos lógicamente 00:06:22
en un overview reducido 00:06:23
pero luego a partir de ahí 00:06:25
uno ya puede meterse 00:06:26
y ver el resto de métodos 00:06:27
de clases que tiene 00:06:28
pero bueno 00:06:29
eso ya son detalles 00:06:29
una vez que uno ha entendido 00:06:30
realmente de qué va el rollo 00:06:31
¿vale? 00:06:32
entonces me evita eso 00:06:34
por un lado 00:06:35
¿qué más nos evita? 00:06:36
manejar los try-catch 00:06:39
nos lo evita 00:06:40
¿vale? 00:06:41
nos 00:06:43
evita también 00:06:46
o nos enmascara de forma muy sencilla 00:06:49
la gestión de las transacciones 00:06:51
que eso es casi lo más importante 00:06:53
¿vale? porque cuando 00:06:54
trabajas con una base de datos 00:06:57
lo puedes hacer todo muy bien 00:06:58
no hay errores y todo funciona 00:07:01
pero si tú no has diseñado bien 00:07:03
la política de transacciones, lo que estás 00:07:05
haciendo puede ser una cagada, ¿no? 00:07:07
el típico ejemplo que os pondrán siempre 00:07:08
envases de datos de hacer una transferencia. Si tú el SQL, el insert, lo haces primero y luego 00:07:11
falla el delete de la otra, pues el dinero se queda en las dos cuentas. Con lo cual, para ti muy bien, 00:07:23
pero para el banco muy mal. O al contrario, si haces primero el delete, que ese funciona y luego 00:07:31
al hacer el insert en la otra cuenta 00:07:37
ese falla, pues va al banco 00:07:39
fenomenal, pero para ti una putada 00:07:41
entonces, esta es 00:07:43
una simplificación de una situación 00:07:45
en la que expresamos que hay 00:07:47
muchas cosas que se hacen en las bases 00:07:49
de datos, una sucesión de sentencias que queremos 00:07:51
que o se hagan todas 00:07:53
o no se haga ninguna 00:07:54
porque si se hacen a la mitad 00:07:56
todo ha funcionado, la aplicación 00:07:59
no da problemas, pero el estado final 00:08:01
en el que se queda la base de datos 00:08:03
no es el que queremos 00:08:05
entonces de transacciones 00:08:06
no trabajasteis 00:08:10
o el concepto de transacciones a mi pasa en bases de datos 00:08:12
no vale 00:08:15
tiene que ver con los coches 00:08:17
hombre pues si 00:08:18
tú compras un coche 00:08:21
vale pues entonces 00:08:23
normalmente si uno está 00:08:25
tocando con JDBC puro 00:08:28
con JDBC puro 00:08:30
uno tiene que preocuparse 00:08:31
de establecer 00:08:34
perfectamente se 00:08:35
con todas las transacciones, quiero estas sentencias 00:08:37
todas juntas, pues aquí 00:08:39
me las apaño para 00:08:41
ya mencionaremos como, me las 00:08:43
apaño para decir que 00:08:45
aquí inicio una transacción, aquí ya he terminado 00:08:47
y hago el commit, el commit y el 00:08:49
rollback, si que os suena 00:08:51
¿no? el año pasado 00:08:52
el commit y el rollback, si os suena 00:08:55
entonces si que os suena lo que es una transacción 00:08:56
ah y de que os suena 00:08:58
entonces 00:09:01
bueno 00:09:02
vale, bueno, en general 00:09:03
una transacción es 00:09:06
un conjunto de sentencias 00:09:09
SQL que queremos 00:09:11
que funcionen de tal manera 00:09:13
que o se ejecutan todas 00:09:14
o no se ejecuta ninguna 00:09:17
entonces, ¿qué política seguimos cuando queremos 00:09:18
hacer eso? 00:09:21
pues nosotros fijamos 00:09:23
que el 00:09:25
commit no se haga automáticamente 00:09:27
o sea, commit es lo que 00:09:29
la sentencia 00:09:31
que tú ejecutas para decir, oye, lo que acabo 00:09:33
de hacer en la base de datos, que se consolide, 00:09:35
que no se quede ahí 00:09:37
pendiente, que se consolide, ¿vale? 00:09:39
Entonces, cuando queremos una transacción, 00:09:41
nosotros decimos, oye, el commit 00:09:43
no me lo hagas automáticamente por sentencia. 00:09:45
No me lo hagas automáticamente. 00:09:48
Falso, commit, no quiero commit. 00:09:49
Ahora, me pongo a hacer sentencias todas las que hay en la 00:09:51
transacción. Si todo 00:09:53
ha ido bien y he llegado al final, porque 00:09:55
ninguna me ha dado excepción, entonces ahora 00:09:57
ya hago el commit. 00:09:59
que el commit significa 00:10:00
consolida este estado final 00:10:02
consolídalo, porque se han hecho 00:10:04
todas las sentencias una tras otra 00:10:06
ninguna ha generado excepción 00:10:08
luego todo está perfecto, ahora 00:10:09
consolido estas acciones 00:10:12
y eso significa hacer commit 00:10:14
vale, si en algún momento 00:10:16
de esa secuencia de sentencias 00:10:18
SQL, alguna ha fallado 00:10:20
pues entonces lo que queremos 00:10:22
es que todas las de arriba 00:10:24
se deshagan, se olviden 00:10:26
como si no se hubieran hecho 00:10:28
pues eso es hacer un rollback 00:10:29
un rollback es, fuera, todo lo que he hecho 00:10:31
hasta, de aquí hacia 00:10:34
arriba, hasta el último commit 00:10:36
que hice, deshazlo, como si no hubiera existido 00:10:38
¿vale? ese es el concepto de commit 00:10:40
y rollback, que lógicamente está relacionado 00:10:42
con las transacciones 00:10:44
bueno, pues todo esto venía a cuento 00:10:45
de que con mi JDBC puro 00:10:47
yo lo controlo todo, con lo cual estupendo 00:10:50
yo tengo un montón de sentencias SQL 00:10:52
que quiero que funcionen con una 00:10:54
transacción, pues antes de 00:10:56
ejecutar todas ellas, statement, ejecutive 00:10:58
date, bla, bla, bla, todas ellas 00:11:00
me pongo arriba, e 00:11:02
autocommit falso, autocommit falso 00:11:03
que se puede hacer con jdbc, muy sencillo 00:11:06
vale, y ahora ya cuando 00:11:08
ya han terminado todas al final, pongo 00:11:10
commit, vale 00:11:12
y en las que están entre medias, que 00:11:13
habrá trycatch, pues en los catch 00:11:16
es porque alguna genera excepción, ahí pongo 00:11:18
rollback, si he entrado en el catch 00:11:20
es porque alguna ha fallado, pues rollback no hay para 00:11:22
así lo haríamos con jdbc 00:11:24
entonces nos tenemos que preocupar 00:11:26
lógicamente pues de poner los commit 00:11:28
false, poner los commit 00:11:30
donde yo quiera, los rollback en los 00:11:32
cats, etcétera, bueno pues 00:11:34
esta capita ligera de 00:11:36
jdbc, además 00:11:38
de este mapeo, además de 00:11:40
cerrar los recursos 00:11:42
y hacer, y permitirme olvidarme 00:11:44
del trycat, dejar las excepciones 00:11:46
ahí me permite una gestión 00:11:48
de transacciones, vale 00:11:50
ya con un modelo más parecido al 00:11:52
Spring Data JPA que sería ya la capa 00:11:54
Gorda, la que no podemos 00:11:56
Arrancar desde el principio con esa capa, porque esa capa 00:11:58
Es pin, ya está 00:12:00
Ni puta idea de lo que ha pasado ahí, ni por qué 00:12:02
Y si cambia algo, ¿qué hago? 00:12:04
¿Vale? 00:12:07
Bueno, pues entonces, y aparte 00:12:08
Para 00:12:11
Volver a la reflexión 00:12:12
Que estabais dando en digitalización 00:12:14
Lo he dicho 00:12:16
200.000 millones de veces, pero lo vuelvo 00:12:18
A decir, os ha pedido la 00:12:20
Reflexión sobre qué valor 00:12:22
podéis aportar, ¿qué valor podéis aportar? 00:12:24
pues ¿qué valor podéis aportar? 00:12:26
capacidad de aprendizaje 00:12:28
esa 00:12:30
y eso se entrena pues 00:12:32
lucha, conociéndolo todo, luchando 00:12:34
con todo, resiliencia 00:12:36
famosa, ostras 00:12:38
en este examen de acceso a datos es que 00:12:40
no he hecho nada, no pasa 00:12:42
nada, en el siguiente 00:12:44
pues todas estas cosas que están aquí deslavazadas 00:12:45
me pongo y ahora ya si lo hago 00:12:48
bien, esa capacidad de resiliencia 00:12:50
de superación, ese es el valor 00:12:52
que podéis aportar, esa capacidad de aprendizaje 00:12:54
no tanto los contenidos 00:12:56
¿vale? pues eso 00:12:58
a sufrir 00:13:00
¿perdona? 00:13:01
vale 00:13:06
bueno, pues venga, vamos a poner 00:13:06
esa pequeña capita 00:13:09
de Spring JDBC 00:13:11
a ver, que esto es poco de escribir 00:13:13
y es que ayer por la tarde no me dio tiempo 00:13:16
a subiros chuleta, pero vamos a tener que escribir 00:13:17
poquito. Y no sé ni en qué proyecto 00:13:20
lo tengo ya. 00:13:22
Ya ni me acuerdo, pero no me dio tiempo a mirarlo. 00:13:24
No, no, no. Sobre este mismo, he dicho. 00:13:27
Vale, entonces voy a ver 00:13:30
un segundito. 00:13:31
Sí, vale, aquí lo tengo. 00:13:39
Vale, pues entonces, dime. 00:13:40
Bueno, pues 00:13:44
este es sobre el proyecto del otro día. 00:13:44
Como este proyecto ya tenemos un dado de implementación. 00:13:46
¿Vale? Pues sobre este 00:13:50
proyecto del otro día 00:13:52
con este de implementación 00:13:54
ahora vamos a ver 00:13:56
como lo haríamos 00:13:57
con JDBC 00:13:59
vale, vamos a ver 00:14:01
este para no tocarlo 00:14:06
hacéos una copia 00:14:08
de este en vuestro mismo workspace 00:14:10
os hacéis una copia 00:14:12
pues nada, copy 00:14:15
y os creará otro 00:14:16
vale, otro proyecto 00:14:18
igualito 00:14:20
En mi caso es este 00:14:21
Y así este no lo ensuciamos 00:14:25
Este es el que ya se ha quedado limpio 00:14:27
Funcionando perfecto del otro día 00:14:28
Spring JDBC 00:14:30
Que es una parte de Spring 00:14:34
Una capita ligera 00:14:37
Esto es una capa que pone Spring 00:14:38
Sobre JDBC 00:14:44
Para atrapar esto que digo 00:14:45
Para atrapar los trycon recursos 00:14:47
trapar todo eso, es una capa que pone encima 00:14:49
entonces si usamos Spring JDBC 00:14:51
esto se queda enmascarado 00:14:53
y tenemos 00:14:55
el trabajo más sencillo 00:14:56
bueno, pues entonces para no tocar este 00:14:58
que este es el que digo, que lo único que se 00:15:01
se había quedado pendiente en este es hacer los formularios 00:15:03
para desde ellos llamar al 00:15:05
find by id y al insert 00:15:06
porque los servicios y la 00:15:08
implementación estaba, solo faltaban los formularios 00:15:11
para llamar a esto, ¿vale? 00:15:13
todo lo demás estaba 00:15:14
y bueno, faltaban los formularios y faltaba 00:15:15
en este serlet, que sería una buena despedida 00:15:19
de los serlets para vosotros, a ver si realmente 00:15:21
lo habéis entendido, falta en el 00:15:23
serlet hacer las dos acciones 00:15:25
que faltaban, teníamos hecha la acción de 00:15:27
listar y la acción de eliminar 00:15:29
faltan la acción 00:15:31
de insertar, que sería llamar al 00:15:33
implementación de insertar 00:15:35
y la acción de encontrar por id 00:15:37
que sería llamar al servicio 00:15:39
de get por id y ya está 00:15:41
pues eso es lo que faltaría en este serlet 00:15:43
poner los dos acciones 00:15:45
que faltan 00:15:47
hasta aquí se llega desde los dos 00:15:48
formularios que podéis pedir a HGPT 00:15:52
y luego tunear con los nombrecitos 00:15:54
que os interese 00:15:56
y ya está, y desde aquí 00:15:57
llamar al servicio 00:16:00
correspondiente 00:16:02
es lo que faltaría para que quedara esta aplicación 00:16:02
completa, bueno 00:16:06
pues os habéis hecho ya una 00:16:07
copia limpia de este 00:16:10
vale, pues entonces, abrid 00:16:11
vuestro singleton 00:16:13
Vuestro singleton 00:16:15
De conexiones 00:16:19
Que era este, ¿verdad? 00:16:21
Este singleton 00:16:24
Era una clase que nos habíamos hecho 00:16:25
Para asegurarnos 00:16:28
De que objetos que vamos a usar 00:16:30
Para la conexión son únicos 00:16:33
En todo el ámbito de la aplicación 00:16:35
En todo el scope 00:16:37
De la aplicación que se llama 00:16:39
Porque como se usa mucho scope 00:16:40
Cuando uno 00:16:42
en el contexto nuestro 00:16:44
o ya tienes aplicaciones 00:16:47
con un montón de 00:16:49
scopes 00:16:50
se traduce como ámbito 00:16:52
en este contexto 00:16:54
entonces puede haber 00:16:56
en una aplicación en general 00:16:59
puede haber muchos ámbitos 00:17:00
donde se mueven los objetos 00:17:02
el otro día nos vimos ya por ejemplo en esa situación 00:17:04
teníamos el ámbito de Tomcat 00:17:06
y el ámbito de nuestra propia 00:17:09
aplicación 00:17:10
entonces ahí tuvimos el problema 00:17:11
de que el driver manager 00:17:14
que se arrancaba 00:17:15
en el ámbito de Tomcat 00:17:18
porque se arranca según la aplicación arranca 00:17:20
no encontraba el objeto 00:17:22
driver para comunicarse con MySQL 00:17:24
porque el objeto driver estaba en este otro 00:17:26
ámbito, en este otro scope 00:17:28
entonces por eso teníamos que hacer el class for main 00:17:29
para, vale, bueno pues 00:17:31
entonces, este es 00:17:34
nuestro singleton que es 00:17:36
el que tal y como lo hemos 00:17:37
programado garantiza que estos dos 00:17:40
objetos que tenéis vosotros, la conexión 00:17:42
simple y el 00:17:44
pool de conexiones, porque 00:17:46
lo hicimos de las dos maneras, son únicos 00:17:47
en la aplicación. Vale, pues 00:17:50
el objeto de Spring 00:17:52
JDBC base 00:17:53
con el que lo hacemos todo 00:17:55
es este, el JDBC 00:17:57
templata, ¿vale? Es este de aquí 00:18:02
y a través de este ejecutamos 00:18:04
los SQL y listo. 00:18:06
Este ya sí que necesita 00:18:08
una dependencia 00:18:09
que la podéis buscar 00:18:10
en el repositorio 00:18:12
es esta, tal cual 00:18:18
del framework de Spring 00:18:21
SpringJRG 00:18:23
vale 00:18:24
la versión que os salga en el repositorio 00:18:27
si lo buscáis por ahí o si no ponéis esto 00:18:31
y se acabó 00:18:33
esto es lo que quería haber subido 00:18:34
para que no tuvierais que copiar 00:18:40
pero no pasa 00:18:43
Pues desgraciadamente sí 00:18:43
Voy a abrir 00:18:52
Vale, pues entonces 00:18:53
Con esta dependencia de aquí 00:19:06
Lo habéis copiado 00:19:10
Si no la cogéis de Maben 00:19:12
Ponéis Spring JDBC y os va a salir esto 00:19:20
Pues con esta dependencia de aquí 00:19:23
podemos 00:19:28
trabajar con este objeto. 00:19:30
Lo podréis importar 00:19:33
de la librería correspondiente 00:19:35
del framework de Spring. 00:19:37
Y ahora, vamos a hacer 00:19:39
el método para que esto realmente se convierta 00:19:41
en un singleton. Este objeto queremos 00:19:43
que sea único en toda la aplicación. 00:19:45
Bueno, vale, 00:19:47
pues este es nuestro get 00:19:51
para el singleton. 00:19:52
¿Vale? 00:19:56
Entonces 00:19:56
Copiáis y pegáis lo del properties de arriba 00:19:58
Lo copiáis y pegáis 00:20:01
Si es null hay que instanciarlo 00:20:03
Esto lo copiáis y pegáis de arriba 00:20:05
Y esto es 00:20:06
Lo que instancia el JDBC template 00:20:08
El JDBC template 00:20:12
Hay que 00:20:14
Instanciarlo de esta manera 00:20:16
¿De dónde lo copiamos? 00:20:18
De los métodos de arriba 00:20:19
O sea, arriba que tenéis 00:20:22
El get de la conexión 00:20:23
Y el get del pool 00:20:26
También tenéis esto 00:20:27
Porque sacábamos las propiedades de la base de datos 00:20:28
Del property 00:20:31
Entonces esto lo copiáis tal cual 00:20:31
Y esto es lo que instancia 00:20:35
El JDLC template 00:20:36
Esta de aquí 00:20:38
Esta sentencia de aquí 00:20:39
En realidad es la equivalente al class for name 00:20:46
Esta nos hace falta 00:20:49
Porque estamos viendo 00:20:53
El ejemplo de una aplicación web con tonka 00:20:55
¿Vale? 00:20:57
Si no, no nos haría falta 00:20:59
Si nos movemos a una aplicación de escritorio 00:21:00
Que nos moveremos ahora 00:21:04
Para ver lo de las transacciones más fácil 00:21:05
Pero las transacciones aquí en esta 00:21:07
En la aplicación web ya se valía demasiado 00:21:08
Si nos movemos a la aplicación de escritorio 00:21:10
Esto ya no lo vamos a poner 00:21:13
Tenemos solo un ámbito de objetos 00:21:14
Ya el driver manager va a encontrar su driver sin problema 00:21:16
Pero aquí sí porque es una aplicación web 00:21:19
Bueno, esto, este proyecto 00:21:21
Lo subiré también 00:21:23
Claro 00:21:26
Vale, pues con esto 00:21:26
Creamos el JDBC template 00:21:29
Que se asocia 00:21:31
A esta conexión 00:21:33
El JDBC template se puede asociar 00:21:34
A una conexión única o a un pool también 00:21:39
Si lo asocio a un pool 00:21:41
Es que esto me lo ahorro 00:21:43
Y pongo aquí el pool de arriba, junto pelota 00:21:44
¿Vale? Porque tengo ya un pool 00:21:46
También creado en esta conexión 00:21:49
Entonces el pool es un data source 00:21:50
Entonces tengo dos data sources posibles 00:21:53
Este que es el de una conexión única 00:21:55
Y el pool 00:21:57
Que es un datasource pool 00:21:59
Pues pongo aquí el que me dé la gana de los dos 00:22:00
¿Cómo se llama el método? 00:22:03
El get jdbc template 00:22:07
Es el que me va a permitir 00:22:09
Obtener este objeto 00:22:11
Vale, es el singleton 00:22:15
Igual que tengo el get conexión 00:22:20
Pues es el singleton de este 00:22:22
Si es null, me lo instancia 00:22:23
¿Vale? 00:22:26
Entonces bueno, estoy viendo un poco los detalles 00:22:28
este me lo instancia 00:22:30
asociado a una conexión 00:22:32
única, pero repito 00:22:34
también admite el constructor 00:22:36
un pool, lo que también es un data source 00:22:38
el pool, podría poner aquí el pool y ya está 00:22:40
y me lo instancia asociado a un pool 00:22:42
me da lo mismo, asociar 00:22:44
a una conexión única que a un pool de conexiones 00:22:46
¿vale? de hecho lo voy a poner aquí 00:22:48
si luego lo... copiamos 00:22:50
eso sí, nos llevabas copiándolo un rato 00:22:55
ay Rodrigo 00:22:57
te veo así que la... 00:23:05
Intentad meterlas cada vez que podéis, ¿eh? 00:23:07
Es que estaba tratando de entenderlo, 00:23:09
por eso lo he recopiado. 00:23:11
Vale, ahora mismo 00:23:18
lo único que tenéis que entender es 00:23:19
que el objeto este de Spring JDBC, 00:23:21
el JDBC template, 00:23:23
me va a facilitar 00:23:25
ejecutar las sentencias SQL 00:23:26
que yo quiera. Me lo va a facilitar. 00:23:28
¿Vale? Pero claro, 00:23:33
ese objeto JDBC template hay que asociarlo 00:23:34
a una conexión. 00:23:36
Una conexión única o un pool, me da igual, 00:23:38
Son las dos cosas que estamos manejando 00:23:40
Conexión única o pool 00:23:41
Si lo asocio a conexión única pongo esta cosa 00:23:42
Si lo asocio a un pool 00:23:45
Pues pongo aquí el pool de arriba 00:23:46
Que lo tengo ya instanciado 00:23:49
Y ya está 00:23:51
¿Vale? Que no es null 00:23:52
Pues devuelvo el que tenga 00:23:54
¿Vale? 00:23:55
Repito la tontería 00:24:17
¿Vale? 00:24:18
Que tal y como lo tenía antes 00:24:19
Efectivamente cada vez devolvía un objeto nuevo 00:24:20
Se iba multiplicando la aparición de objetos 00:24:23
lo que quiero es inicializar 00:24:25
el de arriba, en el resto lo tengo bien puesto 00:24:28
¿verdad? si, si, en el resto, si 00:24:29
vale, vale, aquí lo tenía muy mal 00:24:31
vale, entonces si es null 00:24:33
le doy valor 00:24:35
y si no es null no hace falta darle valor 00:24:36
y en ambos casos lo devuelvo 00:24:39
claro, lógicamente esto no servía 00:24:41
de singleton para nada 00:24:43
podía funcionar 00:24:45
igualmente pero con un montón de objetos 00:24:47
ahí en la memoria 00:24:49
vale, bueno pues ya este 00:24:50
objeto lo tenemos instanciado, ahora vamos 00:24:53
a usarlo. A usarlo 00:24:55
desde nuestras clases 00:24:57
DAO implementación, que son 00:24:58
las que tocan ya la base de datos. 00:25:01
¿Podemos quitar esto? 00:25:04
¿Sí? 00:25:06
¿Sí? ¿No? 00:25:07
¿Hasta dónde? 00:25:10
La property es la que tiene la conexión. 00:25:23
La localhost, MySQL, 00:25:25
la cadena de conexión. ¿Vale? 00:25:27
Venga, pues ahora 00:25:45
abrimos nuestro 00:25:46
DAO implementación, que ahora lo vamos a hacer distinto. 00:25:48
Lo vamos a hacer 00:25:50
Con JDBC puro 00:25:51
Sino con este de aquí 00:25:53
Entonces 00:25:58
Los métodos que teníais 00:25:58
Dejadlos vacíos directamente 00:26:03
Porque ahora ya no lo vamos a hacer 00:26:06
O no lo vais a hacer con JDBC puro 00:26:08
Los limpiáis y los vaciáis 00:26:09
Vacíos 00:26:11
Y el da implementación vuestro 00:26:12
Os acordáis, tendría ahí 00:26:15
Un connection, ¿no? 00:26:17
Que es luego el que usan 00:26:19
Un connection o un pool, depende 00:26:21
Que es el que usaban luego los métodos de abajo 00:26:23
Pues ahora no vamos a usar ese 00:26:26
Connection, vamos a usar este 00:26:29
¿Vale? Vale, pues entonces 00:26:30
Vamos a usar este objeto 00:26:36
Pues mi venta da implementación 00:26:38
Necesita este objeto 00:26:40
Necesita este objeto que como veis de forma 00:26:41
Muy sencilla, lo va a hacer todo 00:26:44
Ahora vamos aquí 00:26:46
¿Vale? Ahora vamos aquí abajo 00:26:48
Pero como veis, mis códigos 00:26:50
De 6, 7, 8, 9, 10 líneas 00:26:52
veréis en que se han reducido 00:26:54
ahora los miramos más en detalle 00:26:57
esto es solo para un primer vistazo 00:26:58
aquí, dime 00:26:59
claro, todo lo que hay 00:27:02
dentro de los métodos fuera 00:27:04
porque ahora la implementación va a ser con Spring JDBC 00:27:06
no va a ser con JDBC puro 00:27:09
y lo que os estaba diciendo 00:27:10
todavía no escribéis nada 00:27:15
como un primer vistazo 00:27:17
mirad como se han reducido 00:27:19
ahora ya yo hago los SQL 00:27:21
y ni gestiono excepciones 00:27:23
Ni me preocupo de los recursos 00:27:25
De abrir la sentencia 00:27:28
Nada 00:27:31
El JDC Template tiene métodos para hacer lo que yo quiera 00:27:31
¿Vale? 00:27:35
Por ejemplo 00:27:37
Vamos al insert 00:27:37
Si abrís JDC Template 00:27:40
Punto, veréis que se despliega 00:27:43
Hay una cantidad de cosas para hacer mil cosas 00:27:44
Que uno se puede meter, investigar y averiguar 00:27:46
Pero que queremos hacer 00:27:48
Insert, delete, update 00:27:50
Pues JDC Template, update 00:27:51
y ahí ya metemos 00:27:54
el SQL que queramos 00:27:56
con interrogaciones 00:27:58
en las 00:28:00
en las variables 00:28:02
y luego después 00:28:04
pongo tantos parámetros 00:28:06
como interrogación necesite 00:28:10
pam pam pam 00:28:12
pues need comprador 00:28:14
redcoach en el color 00:28:15
este es mi insert, me da implementación 00:28:16
para el insert 00:28:20
esto tú habrás 00:28:22
borrado el antiguo y escribirás esto. 00:28:27
O sea, 00:28:31
hemos reducido unas cuantas líneas 00:28:31
a esto. 00:28:34
¿Vale? Sí, esto 00:28:36
lo que pasa es que esto todavía 00:28:42
esto lo vamos a escribir ahora. 00:28:44
Esto todavía no lo escribáis. ¿Vale? 00:28:46
Escribís este objeto para poder 00:28:47
hacer esto. ¿Vale? 00:28:49
¿Vale? Entonces, 00:28:53
se queda mucho más sencillo. 00:28:54
Pero claro, hacemos un segundinín. 00:28:57
Como veis, hemos puesto una 00:28:59
pequeña capita, pero 00:29:01
el SQL no lo enmascara 00:29:03
el SQL lo sigo escribiendo yo 00:29:05
y eso está muy bien 00:29:07
porque tengo un mínimo de control 00:29:08
para optimizar el rendimiento de la base de datos 00:29:11
si yo elijo el SQL, tengo un mínimo de control 00:29:13
¿vale? 00:29:15
vamos a 00:29:18
pasar de los find 00:29:19
por el delete, pues el delete 00:29:20
es lo mismo 00:29:23
jdbctemplate, update 00:29:23
y pongo mi delete 00:29:26
bueno, porque este método 00:29:28
recordáis que lo habíamos hecho 00:29:33
para que devolviera un boolean 00:29:34
con true si realmente borraba alguna columna 00:29:36
y false si no 00:29:38
y este método te devuelve el número de columnas 00:29:39
afectadas, entonces por eso 00:29:42
lo he igualado a 1 y he devuelto directamente 00:29:44
lo que dé 00:29:47
entonces el insert y el update 00:29:47
perdón, el insert 00:29:53
y el delete se han quedado 00:29:55
muy sencillos 00:29:57
Y ahora esto ya por dentro, hará el prepare statement, hará el setting, hará el ejecuter, lo hará ya todo, capturar a la excepción, todo el rollo, ¿vale? Pero me deja elegir el SQL. 00:29:58
Bueno, ¿el delete y el insert los tenéis escritos? 00:30:15
¿A cuál vamos? ¿Al insert? 00:30:22
Insert es hacer en SQL y aquí poner los tres parámetros de la venta, V. 00:30:30
A ver, si lo pones directamente 00:30:35
directamente no puedes 00:30:50
porque como va entrecomillado 00:30:51
sería como poner literalmente esto, no tendría sentido 00:30:52
podríamos hacer lo que 00:30:55
hicimos al principio de todo 00:30:57
que es cortar aquí las comillas 00:30:58
y concatenar 00:31:01
entonces ya sí que concatenaría con el valor 00:31:02
Pero volvemos a lo de siempre 00:31:04
Que entonces tú estás construyendo un string 00:31:06
Y en ese string 00:31:08
SQL estás metiendo 00:31:10
Lo que el tío te quiera meter aquí 00:31:12
Que en lugar de NIF comprador 00:31:14
Puede ser Drop Database 00:31:16
Lo has construido aquí y lo pasas a la base de datos 00:31:17
Con interrogaciones 00:31:21
Primero lo pasas a la base de datos 00:31:23
Le dices a la base de datos 00:31:25
Te la paso a medias 00:31:26
Ahora ya te voy a pasar el valor que va aquí 00:31:27
Entonces la base de datos ya sabe 00:31:30
que ahí tiene que llegar un valor 00:31:33
y si le llega un drop database pa pa pa 00:31:34
dice no, esto no me vale 00:31:36
sabe que le tiene que llegar 00:31:38
un valor para encajar en esa cajita 00:31:41
que él se está esperando 00:31:43
vas a la base de datos como en dos pasos 00:31:44
bueno 00:31:46
insert y delete entonces pues ya está 00:31:49
vale, ya hemos visto 00:31:51
alguna de las ventajas del Spring JDBC 00:31:53
que es jolín, que rápido 00:31:55
escribo yo esto 00:31:56
nos vamos al find by id por ejemplo 00:31:57
vale, el find by id 00:32:02
ya significa 00:32:04
recuperar un objeto venta 00:32:06
aquí se nos complicaba más 00:32:08
porque teníamos que hacer el result set 00:32:10
del result set ir campo por campo 00:32:12
construyendo el objeto 00:32:14
pues este es tan listo 00:32:15
que yo le hago el select 00:32:17
y me lo convierte en objeto 00:32:20
directamente, venta 00:32:22
me lo convierte en objeto 00:32:23
pero claro, como sabe 00:32:25
él de estas columnas 00:32:28
cuál es cuál en cada propiedad 00:32:30
del objeto, cómo sabe cómo construirlo 00:32:33
porque le tengo que dar 00:32:35
yo un objeto mapeo 00:32:37
que es el que nos falta poner aquí 00:32:38
¿vale? entonces 00:32:41
con este objeto le doy la información 00:32:42
de cómo se corresponden 00:32:45
los campos del result set 00:32:47
con las propiedades del objeto 00:32:48
con este mapeo 00:32:50
¿vale? entonces este mapeo 00:32:51
es una interfaz funcional de las que 00:32:55
tanto os gustan 00:32:57
el mapeo 00:32:57
es una interfaz funcional 00:32:59
row mapper, que el mismo 00:33:02
nombre lo dice, mapeo de filas 00:33:04
es una interfaz funcional 00:33:06
magnífica, en este caso 00:33:07
es una bifuncción 00:33:09
recibe 00:33:11
dos valores y te devuelve algo 00:33:13
que recibe 00:33:16
el result set 00:33:19
y un siguiente parámetro que es el número de columnas 00:33:20
del result set, pero ese 00:33:23
lo podemos usar aquí o no, da igual 00:33:25
depende de lo que queramos hacer en este mapper 00:33:27
este mapper está abierto a que hagamos mil cosas 00:33:28
Pero bueno, el mapper sencillo es, cojo mi result set y con él construyo el objeto que es el que me devuelve el mapper, ¿vale? 00:33:30
Entonces, de mi result set, la propiedad IDE, llévala, claro, hacéos un constructor en venta con todos los parámetros, 00:33:44
Que no lo tendréis 00:33:55
Porque si no, no pasa nada 00:33:56
Pero tendríamos que poner aquí las llavecitas 00:33:58
Y hacer un new venta 00:33:59
Set, set, set, set 00:34:01
Y luego retún venta 00:34:02
Entonces para que quede más cortito 00:34:03
La interfaz funcional 00:34:05
Haceos un constructor con todos los parámetros en venta 00:34:06
Es decir, aquí en venta 00:34:11
Que donde está venta 00:34:13
Aquí 00:34:15
Haceos un constructor con todos los parámetros 00:34:16
Y así la interfaz funcional 00:34:20
Queda más cortita 00:34:23
Bueno, sí, porque tengo uno 00:34:26
Sin ID 00:34:31
Porque, bueno, es como principio básico 00:34:31
Tú cuando instancias un objeto venta 00:34:34
No le das el ID 00:34:36
Porque es auto, entonces, hombre, este es 00:34:38
Pero vamos, el que nos importa ahora 00:34:40
Es este 00:34:42
Entonces, hacéos uno con todos los parámetros 00:34:43
Con el único objeto 00:34:46
De luego escribir ese mapper 00:34:48
Más rápido 00:34:51
Porque si no, tenéis que hacer el new ventas 00:34:51
set, set, set, set, set y retúmbela. 00:34:54
¿Vale? 00:34:58
Un constructor con todos. 00:35:01
Dime. 00:35:05
Ah, que tú has levantado la mano hace un rato. 00:35:06
Es verdad, perdón. Se me había olvidado. 00:35:07
Es verdad, perdona. 00:35:10
Sí, vamos ahora. 00:35:16
Venga. 00:35:20
Venta la implementación. 00:35:23
¿Dónde estamos? 00:35:24
Entonces. 00:35:25
Ahora ya 00:35:26
Ese constructor con parámetros 00:35:28
Nos facilita hacer esta interfaz 00:35:32
Acabo de decir 00:35:34
Esta es una interfaz que 00:35:38
Asume, esto llámalo como queráis 00:35:39
X e Y, pero vamos, lo he llamado así 00:35:42
Para que se entienda 00:35:44
Claro, este dice 00:35:44
Cojo estos dos parámetros 00:35:48
Pero claro, para que esa interfaz funcional 00:35:49
Luego tenga sentido 00:35:52
Este RS 00:35:53
este RS 00:35:55
se supone que este RS 00:35:56
va a ser un objeto ResultSet 00:35:59
porque si no es un objeto 00:36:01
ResultSet 00:36:04
cuando luego esta interfaz funcional 00:36:05
entra en acción, que es esto de RSGETIN 00:36:08
¿vale? 00:36:10
o sea que 00:36:14
yo lo estoy copiando como teniendo fe 00:36:15
¿cómo? 00:36:17
no me hace falta tener fe 00:36:19
vale, pues ahora 00:36:21
lo vamos a explicar otra vez, dime 00:36:24
Que si puedo, ¿qué? 00:36:25
Sí, a ver 00:36:31
Espera, me bajo la coma aquí abajo 00:36:32
Ahí 00:36:33
Vale 00:36:35
Esta 00:36:38
Es una interfaz 00:36:40
A ver, vamos a repetirlo otra vez, ¿qué es esto? 00:36:42
Esto es un objeto 00:36:46
Interfaz funcional 00:36:47
¿Qué es un objeto interfaz funcional? 00:36:48
Es un objeto 00:36:51
No es un objeto que tenga un valor, no lo es 00:36:52
Es un objeto que hace algo, ¿vale? 00:36:55
Es decir, los datos pueden contener valores 00:36:58
o pueden contener comportamientos, las dos cosas. 00:37:00
Esa es la base de la programación funcional, ¿vale? 00:37:03
Pues este dato, mape, 00:37:06
este dato lo que contiene es un comportamiento, ¿vale? 00:37:08
Y ese comportamiento, ¿cómo lo programo yo? 00:37:12
¿Cómo lo especifico en Java? 00:37:14
Mediante una interfaz funcional, 00:37:15
mediante una función lambda, perdón, 00:37:17
mediante una función lambda, 00:37:18
es la forma de especificar comportamientos, ¿vale? 00:37:19
Pues esta función lambda me dice, 00:37:22
Tú dame dos parámetros 00:37:25
que yo con ellos te voy a construir 00:37:26
un objeto de esta manera. 00:37:28
Y te lo voy a devolver. 00:37:30
Pero claro, para que este 00:37:32
RSGetIn tenga sentido, 00:37:34
esto de aquí tiene que ser un 00:37:37
ResultSet, porque de los ResultSet, 00:37:38
de los queries, es de donde salen 00:37:41
estos valores. 00:37:42
La cosa es que en mi clip se dice 00:37:44
respecto a RS. 00:37:45
Pero tu clip no tiene por qué decir eso aquí. 00:37:48
Habéis importado el roadmap. 00:37:51
No tiene por qué decirte nada. 00:37:52
Claro, bueno, importa 00:37:55
Roadmapper, pero tu eclipse se tiene 00:37:57
Que callar, a una lambda tú le metes 00:37:59
Lo que le da la gana, si se lo va a tragar 00:38:01
Todo, luego otra cosa es cuando lo 00:38:03
Ejecute, pero mientras 00:38:05
Respetes la sintaxis 00:38:07
¿Vale? 00:38:08
O sea, el RSS 00:38:13
Por dentro también hace lo del 00:38:15
White hasnet 00:38:16
Eso lo hace 00:38:17
Luego el query for object 00:38:21
Esto lo único que te dice es 00:38:22
Si tú me das un registro 00:38:24
un result set posicionado 00:38:27
en un sitio, porque el result 00:38:29
William, ¿qué? 00:38:31
Espera un segundito. 00:38:33
Un segundito, voy a terminar de explicar esto que deje claro. 00:38:37
Que quede claro, vale, lo ponemos. 00:38:40
Vale, o sea, un result set 00:38:41
es un conjunto de registros 00:38:43
pero además con un indicador de posición. 00:38:45
Es las dos cosas 00:38:48
a la vez. Entonces, 00:38:49
este me dice, tú dame un result set 00:38:51
que tendrá su indicador de posición. 00:38:54
y yo con el registro que esté en esa 00:38:55
posición, sacaré su 00:38:58
campo id, su campo este, su campo 00:39:00
este, su campo este y te construyo un objeto 00:39:02
es lo que está diciendo 00:39:04
este comportamiento, tú dame un result set 00:39:06
que llevará dentro su indicador de fila 00:39:08
y yo con esa fila 00:39:10
te hago un objeto 00:39:12
y ahora, el num es un 00:39:13
segundo parámetro que necesita esta interfaz 00:39:16
funcional mapper, que 00:39:18
es el número de columnas del 00:39:19
result set, que no tenemos por 00:39:22
que usarlo aquí. O sea, esto es 00:39:24
para construir un objeto, pero a lo mejor 00:39:26
podríamos hacer una intensidad funcional, una 00:39:28
lambda más compleja, lo que tú verificarás antes 00:39:30
si num es 00:39:32
igual al número de columnas del result set 00:39:34
que lo puedes sacar, porque los objetos result set 00:39:36
tienen un método getMetadata, donde 00:39:38
sacas las columnas que tienen, patatín, 00:39:40
no me quiero meter en berenjenales, ¿vale? 00:39:42
Pero num es un parámetro 00:39:44
que 00:39:45
el roadmap debería interpretarlo 00:39:46
como número de columnas del result set. 00:39:50
que tú lo usas para hacer validaciones 00:39:52
aquí dentro, para hacer una lambda 00:39:54
complicadísima lo usas, que no 00:39:55
no lo usas, yo he hecho aquí 00:39:58
la versión sencillita, que a partir 00:39:59
de un result set con un número de 00:40:02
columnas num 00:40:03
posicionado en un sitio 00:40:04
me devuelves el objeto 00:40:07
correspondiente a esa fila 00:40:09
¿vale? eso es lo que me hace 00:40:12
esta lambda, ¿vale? ahora ¿cómo 00:40:13
vamos a usar esta lambda? pues ahora 00:40:15
ya esta lambda, ahora ya sí que bajamos 00:40:17
al find ID, ¿vale? 00:40:20
Ahora el findMyId 00:40:22
Es el que ya hace el query for object 00:40:23
Y ahí es donde se hace todo el while next 00:40:26
Todo el rollo 00:40:27
Y ahora, este query for object 00:40:28
Dice 00:40:32
Exacto, por eso se lo pasamos 00:40:32
Aquí, como parámetro 00:40:36
Entonces este query for object 00:40:37
Hace el select a través de 00:40:39
Las órdenes del mapper 00:40:42
Cada iteración del while 00:40:43
Va cogiendo y va llevando el objeto 00:40:45
Etcétera 00:40:48
En este caso, como estamos pasando 00:40:48
por id, yo llamo 00:40:51
al query for object, porque el query for object 00:40:53
me saca un objeto solo, pero es que aquí 00:40:55
encaja, claro, si no sería 00:40:57
pues que el de abajo, el find all 00:40:59
sería como el de abajo, dime 00:41:01
¿el num cuando lo estás usando? 00:41:02
no lo estoy usando, podría usarlo si quisiera 00:41:05
es lo que acabo de contarle a él, pero no lo estoy 00:41:07
usando, repito 00:41:09
el num se interpreta como 00:41:10
el número de columnas del registro 00:41:13
lo uso 00:41:15
si quisiera hacer esta 00:41:17
lambda más completa, más 00:41:19
enrollada, más yo que sé, pues que además me gusta 00:41:21
el número de columnas, pues cualquier cosa 00:41:23
si quisiera validar que el número 00:41:25
de columnas es el número de propiedades del objeto 00:41:27
para si no, devolverme un null 00:41:29
para lo que yo quisiera, pero no lo estoy usando aquí 00:41:30
lo estoy, ¿vale? 00:41:33
pero es eso, significa eso 00:41:35
vale 00:41:37
pues entonces 00:41:39
el find id 00:41:41
fijaos, se ha convertido 00:41:44
de la versión esta rollo 00:41:46
que teníamos en la otra 00:41:48
Ha pasado 00:41:50
De todo esto 00:41:53
Ha pasado 00:41:54
A esto 00:41:57
A esto 00:41:58
Hombre, pues si yo pongo aquí un retun 00:42:00
Es una línea 00:42:03
Hombre 00:42:04
Cuanto menos escribas 00:42:07
Menos opción 00:42:09
Tienes de equivocarte 00:42:12
¿Vale? 00:42:13
Cuanto menos escribas, menos opción tienes de equivocarte 00:42:15
Si tú tienes 20 novias, la vas a cagar seguro 00:42:18
Pues yo no tienes una, ¿no? Porque te fuerzan más. 00:42:20
Pues es lo mismo. 00:42:22
Cuantas más opciones tengas de cagarla, 00:42:24
peor. 00:42:26
Pues cuanto menos código escribas, 00:42:28
menos opciones de cagarla. 00:42:31
¿Vale? 00:42:33
Vale. 00:42:35
Pero daos cuenta de que esto, 00:42:36
pese a eso, 00:42:38
nos deja poner el 00:42:40
ese... 00:42:42
No vale 00:42:42
cagarla en la primera oportunidad. 00:42:46
Bueno. 00:42:48
En la primera idea del código ya la cagaste. 00:42:50
En fin. 00:42:54
¿Quién ha escrito venta con B? 00:42:54
¿Quién ha escrito venta con B? 00:42:57
Ah, creo que yo. 00:42:58
Vale, y ahora. 00:42:59
Por ejemplo. 00:43:01
Eso, lo único que puedes cagarla, 00:43:05
que es aquí, pues pone 00:43:06
JDBC, pones esto con B. 00:43:08
Ya está. 00:43:10
Vale, y el único que nos falta, 00:43:11
find all. Fijaos que 00:43:15
cortito se queda también. 00:43:16
ahora un query 00:43:18
y este 00:43:20
le digo el mapeo 00:43:22
y como este me va a devolver muchos 00:43:25
pues me devuelvo un list de venta 00:43:27
es que no tengo ni que hacer el list 00:43:30
ni que ir uno por uno añadiendo 00:43:31
¿vale? 00:43:33
en el otro venta da implementación 00:43:35
en el find all 00:43:37
tenía que hacerme el list 00:43:39
ir construyendo, ir añadiendo 00:43:40
capturar la excepción 00:43:42
todo este rollo tenía que hacer en el JDBC puro 00:43:43
en este ya está. 00:43:46
¿Vale? 00:43:49
Le tengo que dar el mapper, lógicamente. 00:43:50
¿Perdón? 00:43:53
Insertar venta, este. 00:43:55
Dime. 00:44:00
¿Cómo se podría usar el numarrio? 00:44:01
¿Qué métodos tiene? 00:44:03
A ver, el num es una variable. 00:44:05
Tú la usas para lo que quieras hacer en esa lambda. 00:44:07
Uso típico. 00:44:10
Solo quieres construir el objeto, por ejemplo, 00:44:11
si validas 00:44:14
que ese result set 00:44:16
es correcto porque tiene tantas columnas 00:44:18
como tiene tu objeto 00:44:21
pues entonces podrías hacer pues if num 00:44:22
igual a no sé qué, pues entonces ahora ya construyo 00:44:24
el objeto y lo devuelvo 00:44:26
que no, devuelvo null, yo que sé 00:44:28
podrías usarlo para lo que quisieras dentro de esa 00:44:30
lambda, nosotros no lo hemos usado para nada 00:44:32
hemos asumido que el result set viene con 00:44:34
todos los campos, que es un select asterisco 00:44:36
que viene con todo, lo hemos asumido y hemos creado el objeto 00:44:38
y se acabó, ¿vale? 00:44:40
vale, pues ya está 00:44:42
esta es nuestra implementación, ¿ya se ha acabado? 00:44:46
pues ya hemos hecho la libre 00:44:49
la segunda parte 00:44:51
¿hasta dónde? 00:44:53
hasta el enlace 00:44:57
hasta aquí 00:44:58
vale 00:45:00
entonces, ¿qué hemos hecho? 00:45:02
simplemente, de la aplicación anterior 00:45:06
hemos hecho una copia 00:45:08
hemos añadido el objeto jdbctemplate 00:45:09
al singleton para poder obtenerlo 00:45:12
y he cambiado los da implementación 00:45:14
es lo único que hemos cambiado 00:45:17
vale 00:45:18
y nos debería seguir funcionando la aplicación 00:45:22
vamos a verificarlo 00:45:25
antes de 00:45:27
irnos a los baños 00:45:30
o a lo que sea 00:45:33
voy a 00:45:34
lanzar la base de datos 00:45:37
Lo que tengo que crear es una base de datos. 00:45:46
Vale, a ver, yo tengo... 00:45:48
Vale. 00:45:51
Voy a ver si esta aplicación... 00:45:53
Porque no hay más cambios que hacer. 00:45:57
El base de datos properties está aquí con todo. 00:45:59
Solamente he cambiado el de implementación y el singleton. 00:46:02
Vale. 00:46:07
Pues voy a ejecutar esta copia y vosotros también, a ver si... 00:46:08
Porque no va a pegar error 00:46:16
No, confía, confía 00:46:18
Venga, vamos a cruzar los dedos 00:46:20
El Tomcat ha arrancado 00:46:26
Ahí está la aplicación 00:46:28
Listar ventas 00:46:30
Míralas, que bonita 00:46:31
Me salen los logs del sprint 00:46:33
JDBC 00:46:36
¿Vale? En la consola 00:46:36
Uno puede configurar la herramienta 00:46:39
Para que no muestre los logs 00:46:42
¿Vale? Y aquí sale todo tan estupendo 00:46:43
Sí, el delete 00:46:46
Aquí está 00:46:52
Vale, pues quien quiera ir al baño 00:46:54
Y cualquier cosa 00:46:56
Aprovechamos a quien hacer la paradinha 00:46:57
Un momentito 00:47:00
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:
11 de diciembre de 2025 - 17:27
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
47′ 02″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
200.72 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid