Saltar navegación

20260108 Repaso_UD2_1 - Contenido educativo

Ajuste de pantalla

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

Subido el 12 de enero de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, está grabando, así que no digáis cosas raras. Vale, entonces, tenemos la base de datos. ¿Y qué tenemos? El... Silencio por ahí. Y tenemos el lenguaje Java, que es nuestra herramienta para construir aplicaciones que accedan a los datos y den resultados a los usuarios. 00:00:00
Bueno, pues entonces 00:00:22
Como se trata de estandarizar 00:00:24
Como siempre, ya lo sabéis 00:00:26
Tenemos que hacer estándares 00:00:27
A los que todos nos adaptemos 00:00:28
Para uniformizar las aplicaciones 00:00:29
Permitir su mantenimiento, escalabilidad, etc 00:00:32
Que estándar nos ofrece Java 00:00:35
Para el acceso a bases de datos relacionales 00:00:37
JDBC 00:00:41
Java Database Connectivity 00:00:42
¿Vale? 00:00:44
Entonces sabemos que es JDBC 00:00:45
Es una API 00:00:47
Que ofrece unas clases 00:00:48
Entre ellas, Driver Manager, una de las que ofrece, ¿vale? Pero ofrece más clases como Statement, Prepare Statement, Connection, dime. 00:00:52
el 22 00:01:05
vale, entonces 00:01:10
esta API 00:01:14
nos ofrece unos métodos 00:01:17
a los cuales nosotros llamamos para hacer 00:01:19
esencialmente tres cosas 00:01:20
crear conexiones, ejecutar 00:01:22
sentencias, el CRUD 00:01:25
completo 00:01:26
y cerrar conexiones 00:01:27
entonces 00:01:30
nosotros hemos visto un poco 00:01:32
lo básico, porque da un poco igual 00:01:35
a partir de ahí explorar el resto de métodos 00:01:37
no tiene más interés 00:01:39
entonces, ¿qué es? crear una conexión 00:01:40
o crear un pool de conexiones 00:01:43
teníamos las dos opciones, ¿verdad? 00:01:47
conexión única 00:01:48
creo esa conexión 00:01:49
hago lo que tenga que hacer y la cierro 00:01:52
o si tengo una aplicación 00:01:55
multi hilo, lo ideal sería 00:01:57
creo un pool de conexiones 00:01:59
lo que pasa es que 00:02:01
el objeto 00:02:03
pool de conexiones 00:02:05
no me lo ofrece la API 00:02:06
JDBC, me lo ofrece 00:02:09
muchos 00:02:10
proveedores 00:02:13
el más usado 00:02:13
para javar 00:02:16
era el Icari, este 00:02:19
entonces, pues bien 00:02:20
un pool de conexiones, una colección 00:02:22
única, el pool de conexiones 00:02:24
se instanciaba y sacábamos de él 00:02:26
una conexión cada vez que 00:02:28
quisiéramos, las dos opciones 00:02:30
pues eso, crear conexión 00:02:32
única o pool, hacer las sentencias 00:02:34
que quisiéramos hacer para 00:02:36
hacer el CRUD correspondiente a esa 00:02:38
base de datos y cerrar conexiones 00:02:40
o liberarlas si se trataba 00:02:42
de un pool, ¿vale? liberarlas para que 00:02:44
estén ahí en el pool disponibles, esencialmente es eso 00:02:46
entonces nosotros 00:02:48
hemos hecho, pues hacer sentencias 00:02:49
tanto sin 00:02:52
precompilar como precompiladas 00:02:54
que era el prepare statement 00:02:56
y ya está 00:02:57
no hemos hecho más que eso, entonces ahí sobre todo 00:03:00
la complejidad está en 00:03:02
recordar el SQL y construir 00:03:04
buenos SQL 00:03:06
porque 00:03:08
JDBC lo que hace es llamar a esos 00:03:10
SQL, entonces si uno construye 00:03:12
buenos SQL, pues la aplicación no será 00:03:14
un joyo de botella, funcionará mejor que si no 00:03:16
¿vale? 00:03:18
Luego, JDBC por supuesto 00:03:20
permite hacer muchas más cosas 00:03:22
en las que uno se podría 00:03:24
meter, pero nosotros no tenemos tiempo 00:03:26
y como ya son cosas que una vez que ya estéis en el contexto 00:03:28
se trata de decir, a ver, ¿cómo hago esto con JDBC? 00:03:31
Pues con estos dos métodos, punto, pelota, te lo dice 00:03:34
chaje, peteo, te lo dice quien sea, siempre y cuando uno ya esté 00:03:37
en el contexto de lo que quiere. ¿Qué otras cosas permite hacer? 00:03:40
Pues, por ejemplo, sacar información 00:03:44
sobre la base de datos, pues ¿cuántas tablas tiene? 00:03:46
¿Las tablas qué columnas tienen? Etcétera. Eso a través 00:03:49
de el objeto database, metadata 00:03:52
que también se puede sacar de aquí 00:03:55
pues cuando tengo un ResultSet 00:03:57
sacar información de él 00:03:59
como los nombres de las columnas 00:04:01
porque no los conozco, el tipo de dato porque no lo conozco 00:04:03
a través de un objeto 00:04:06
también de aquí que es el ResultSetMetadata 00:04:07
¿qué otra cosa se puede hacer 00:04:09
que no hemos hecho? 00:04:11
en lugar de ejecutar sentencias sueltas 00:04:13
SQL sin más 00:04:15
ejecutar procedimientos o funciones 00:04:17
¿no? en SQL 00:04:19
se pueden hacer procedimientos 00:04:21
y funciones 00:04:23
¿Vale? ¿Los hicisteis el año pasado? 00:04:25
Bueno, pues se pueden 00:04:29
hacer como en cualquier otro lenguaje de 00:04:30
programación, como en cualquier otro 00:04:31
lenguaje, se pueden hacer procedimientos 00:04:33
y funciones, y si uno tiene 00:04:35
su gestor de, tu gestor de 00:04:37
base de datos, tú, por ejemplo 00:04:39
si has visto que con esa base de datos 00:04:41
haces muchas veces 00:04:44
no sé qué acción que implica 00:04:45
hacer varias sentencias, la metes 00:04:47
en un procedimiento y le das 00:04:50
un nombre, y ahí se queda en la base de datos 00:04:51
y luego ya en tu script SQL 00:04:54
llamas ese procedimiento almacenado 00:04:56
y se acabó, pues ese procedimiento 00:04:58
almacenado también podría ser llamado 00:05:00
desde aquí, desde la aplicación 00:05:02
siempre y cuando esté 00:05:04
guardado y creado 00:05:06
ya en la base de datos 00:05:07
entonces hay muchas cosas 00:05:09
relacionadas con el acceso a la base de datos 00:05:12
que se pueden hacer desde aquí 00:05:14
más allá de 00:05:16
crear una sentencia simple sin más 00:05:18
sea de insert, update, delete 00:05:20
¿vale? pero son cosas muy puntuales 00:05:22
que son fáciles de averiguar como se hacen y ya está 00:05:24
¿vale? no nos vamos a meter aquí en ellas 00:05:26
por falta de tiempo 00:05:28
por ejemplo también los 00:05:30
result set, recordad que era un objeto 00:05:32
result set, un objeto result set 00:05:34
era un objeto de esta API 00:05:36
que recogía 00:05:38
todos los resultados de una consulta 00:05:39
¿verdad? de una query 00:05:42
pues el objeto result set lo hemos usado 00:05:43
exclusivamente para recorrerlo y mirar 00:05:46
lo que tenía, pero tiene 00:05:48
muchas más posibilidades, pues por 00:05:50
ejemplo, a través del objeto result set, podemos actualizar la base de datos sin hacer queries. Es 00:05:52
decir, tú has hecho una query y tienes aquí tus registros en Java. Pues esos registros puedes 00:05:58
configurar de forma muy sencilla el result set para que estén conectados a la base de datos. Y a 00:06:06
través de Java, pues eliminar algunos de esos registros, insertar un registro nuevo a través 00:06:11
del result set sin tener que hacer 00:06:17
otra sentencia SQL 00:06:18
por ejemplo, entonces eso te facilita 00:06:21
un poco el trabajo 00:06:23
bueno, pues cosas 00:06:23
que se pueden hacer para 00:06:26
hacer más 00:06:28
interesantes, o sea, tenemos 00:06:31
más herramientas dentro de esto 00:06:33
bueno 00:06:35
pues esta es la herramienta 00:06:36
ah bueno, el driver manager 00:06:39
el driver manager era el que 00:06:40
el gestor que manejaba los drivers 00:06:42
Entonces, el driver manager necesita que haya un driver lógicamente en la aplicación, driver cargado, un objeto driver instanciado. Ese objeto driver lógicamente depende de la base de datos con la que estemos. Si es MySQL será un driver para MySQL, si es Postgre pues un driver para Postgre, lo que sea. 00:06:45
Entonces ese driver lógicamente 00:07:08
Nosotros lo poníamos como dependencia 00:07:11
De la aplicación, ¿verdad? 00:07:13
Lo poníamos como dependencia 00:07:14
Y entonces cuando la aplicación arranca 00:07:15
Se instancia automáticamente 00:07:18
Un objeto de esa clase 00:07:21
No tenemos que hacerlo a mano 00:07:24
Como antes, que sí que había que hacerlo a mano 00:07:25
Se instancia, se queda ahí cargado 00:07:26
Y el driver manager ya 00:07:29
Tira de él y lo coge 00:07:31
Lo coge para rellenar 00:07:33
Los métodos vacíos de la API 00:07:36
Porque en JDBC los métodos están semivacíos, porque se tienen que implementar con el driver concreto que se haya incorporado como dependencia en la aplicación. 00:07:37
Entonces, aquí por ejemplo, vimos una pequeña situación extraña, entre comillas, y es que cuando la aplicación era de escritorio, una aplicación de escritorio de Java, estupendo, 00:07:50
porque todos los objetos estaban en el mismo 00:08:02
contexto de carga 00:08:06
porque solo había un proceso, entre comillas 00:08:07
solo había un proceso que es mi aplicación de escritorio 00:08:09
entonces 00:08:12
hay un único contexto de carga 00:08:14
de objetos 00:08:16
pero si movíamos esto 00:08:16
a una arquitectura de aplicación web 00:08:19
que con un ejemplito 00:08:21
para incorporar pedidos o coches 00:08:23
o yo que sé, rollos de ventas 00:08:25
que habíamos hecho en escritorio, lo movimos 00:08:27
a serle 00:08:29
para que no se os olvidara 00:08:30
y acabaríais de entender bien lo que era un servlet 00:08:32
pues cuando lo movimos a servlet 00:08:34
¿qué pasó? que aunque poníamos como 00:08:35
dependencia nuestro driver 00:08:38
de MySQL y ahí estaba puesto en el 00:08:40
POM como dependencia, aunque lo poníamos como 00:08:42
dependencia, el driver 00:08:44
manager no lo encontraba y nos decía 00:08:46
todo el rato 00:08:48
no encuentro un driver 00:08:49
no encuentro un driver, no encuentro un driver y la aplicación 00:08:52
no arrancaba, ¿por qué 00:08:54
ocurría eso? porque 00:08:56
en una aplicación web tenemos 00:08:58
dos contextos de carga de objetos 00:09:00
el contexto de la propia 00:09:02
aplicación y el contexto 00:09:04
del servidor de aplicaciones del Tomcat 00:09:06
que también está ahí ejecutándose 00:09:08
porque el Tomcat es el que tiene que cargar 00:09:10
el servlet para que se ejecute 00:09:12
entonces teníamos dos contextos 00:09:14
de carga 00:09:16
entonces el driver manager 00:09:17
estaba en el contexto 00:09:20
de carga del Tomcat 00:09:23
y sin embargo la dependencia 00:09:24
el objeto driver en sí 00:09:27
el objeto driver estaba en el contexto 00:09:28
de carga de la aplicación 00:09:31
entonces driver manager no lo podía encontrar 00:09:32
pues entonces que teníamos que hacer 00:09:34
forzar que se cargara 00:09:36
en el contexto de carga también 00:09:39
y eso forzar que se cargue 00:09:41
cualquier objeto se hacía 00:09:43
con estas enter 00:09:45
class for name ya que poníamos el nombre 00:09:46
de la clase 00:09:49
vale 00:09:51
entonces con esto forzábamos la carga 00:09:52
entonces esto era como un detalle 00:09:54
para que veamos una situación 00:09:56
curiosa de alguna manera 00:09:58
entonces esta sentencia 00:10:01
el class formame este 00:10:02
si uno mirara aplicaciones 00:10:04
antiguas o legadas 00:10:06
de JDBC, pues se ponía 00:10:08
por sistema, porque 00:10:11
antes el driver 00:10:12
incluso una aplicación de escritorio cualquiera 00:10:14
el driver no se cargaba 00:10:16
automáticamente, en los drivers 00:10:18
del 8 hacia atrás 00:10:20
en MySQL en particular 00:10:22
no se cargaba automáticamente 00:10:23
entonces siempre se ponía esto 00:10:25
Para que el driver se cargara siempre 00:10:27
Entonces lo veréis en muchos sitios 00:10:29
Incluso en tutoriales antiguos 00:10:31
Que ya no veis tutoriales o lo que sea 00:10:33
Pero desde cierta versión de los drivers 00:10:34
Ya está hecha el contexto estático 00:10:37
Del driver 00:10:39
El contexto estático está hecho para que se caiga automáticamente 00:10:41
Con lo cual ya esto no se pone 00:10:43
Pero 00:10:44
En la aplicación web sí tuvimos que ponerlo 00:10:46
Porque se había cargado 00:10:49
En un contexto y en el otro no 00:10:51
Entonces tuvimos que ponerlo para que se cargara 00:10:52
Bueno, todo esto 00:10:54
está subido en las sucesivas aplicaciones 00:10:56
que están en el aula virtual 00:10:59
que están ahí todas seguidas 00:11:01
y en todos los comentarios de la aplicación 00:11:02
está todo el chorizo explicado todo eso 00:11:04
primero teníamos subido 00:11:06
una de, a ver 00:11:08
vamos a abrir aquí el aula virtual 00:11:10
para irnos situando porque si alguien 00:11:13
decide que va a estudiar en algún momento 00:11:15
de su vida 00:11:17
que debería ocurrir 00:11:17
bueno pues es que por eso estamos 00:11:20
haciendo un poco esto 00:11:25
Para reenganchar 00:11:26
El que no se va a ver 00:11:30
No lo he grabado 00:11:34
No, ¿cómo que no lo he grabado? 00:11:35
A ver, la grabación está capturando pantalla todo el rato 00:11:37
Sí, por eso, está capturando el escritorio 00:11:40
Entonces 00:11:44
Esto no se oye mi voz 00:11:44
Vale, entonces la voz se oye 00:11:46
Pero a ver, que tampoco es tan interesante 00:11:49
Y se oye la voz 00:11:51
Lo que esté aquí 00:11:52
Vale, pues a ver 00:11:53
Venga, pues nos vamos a JDBC 00:11:57
Vale, pues esta es 00:12:11
La aplicación de escritorio básica 00:12:15
De uso de JDBC sin más 00:12:19
¿Vale? 00:12:21
Vale, eso sí 00:12:22
Eso sí, lo que sí que hicimos 00:12:24
Por supuesto que eso sí que nos tenemos que acostumbrar 00:12:26
Que eso sí que nos tenemos que acostumbrar 00:12:29
Es que uno puede hacer 00:12:33
Un main, ahí, ah, alegremente 00:12:34
Y hacer la aplicación, no, hombre 00:12:37
tenemos que incorporar un patrón de diseño 00:12:38
más o menos organizado, cuando hacemos 00:12:40
patrones de diseño hay que meter, si no te queda una aplicación 00:12:42
que nadie la quiere 00:12:44
vale, entonces en esta aplicación 00:12:46
de escritorio, simplemente para 00:12:48
ilustrar, crear conexiones 00:12:50
tanto únicas como pool de conexiones 00:12:52
ejecutar sentencias, tanto sin precompilar 00:12:54
como precompiladas y cerradas 00:12:56
pues lo hicimos lógicamente 00:12:57
con un patrón dado 00:12:59
metiendo también un singleton 00:13:02
para asegurarnos 00:13:04
de que tanto la conexión 00:13:06
como el patrón de conexiones eran únicos 00:13:08
¿vale? entonces programamos 00:13:11
el singleton, hicimos 00:13:12
el DAO que sacaba ya la 00:13:14
implementación del DAO, saca la 00:13:16
conexión, en el DAO 00:13:18
están los métodos que hacen el CRUD 00:13:20
¿vale? y luego 00:13:22
ya teníamos 00:13:24
el servicio 00:13:26
que ya es la clase 00:13:27
que tiene las funcionalidades de la aplicación 00:13:30
ya más 00:13:32
en lenguaje natural, pues 00:13:34
recuperar coches que se les ha roto una rueda 00:13:36
eso no lo metes en el DAO, eso lo metes 00:13:38
en el servicio, y ese método 00:13:40
del servicio, recuperar coches 00:13:42
a los que se les ha roto una rueda 00:13:44
ese método del servicio ya sí que tiene 00:13:46
que tirar del DAO, lógicamente, porque el DAO 00:13:48
es el sota, caballo y rey, el cruz 00:13:50
y bueno, algunas cosas más se hacen falta, recuperar 00:13:52
por IDE, find by IDE, find all, lo que sea 00:13:54
entonces, hombre, el patrón sí que 00:13:56
lo hicimos, pero luego 00:13:58
la parte de JDBC era la que 00:14:00
estaba metida en el DAO implementación 00:14:02
ahí metidita, crear la sentencia, lo que fuera 00:14:04
y ya está, vale, entonces luego 00:14:06
pasamos 00:14:08
esto a una aplicación web 00:14:10
vale 00:14:11
con un serle 00:14:13
y aquí ya es cuando ya me comprometí 00:14:15
a que ya a partir de aquí ya suponía 00:14:18
que todos entendíais 00:14:20
lo que eran los serles y sus particularidades 00:14:21
y ya no hacíamos más aplicaciones web 00:14:24
con serles, vale, sino poniéndoles 00:14:26
una capa para vagos por encima 00:14:28
vale 00:14:30
Entonces, aquí es donde os he dicho 00:14:31
En esta aplicación que vimos 00:14:34
Lo de los dos contextos de carga 00:14:36
Porque tuvimos que hacer el class for name, etc 00:14:37
¿Vale? 00:14:39
Y aquí también nos sirvió 00:14:42
Esta aplicación que también está escrito 00:14:44
Como comentarios en el proyecto 00:14:46
Nos sirvió esta aplicación 00:14:47
Pues para recordar o revisar 00:14:48
Los formularios 00:14:52
HTML 00:14:55
La diferencia entre get y post 00:14:55
¿Vale? 00:14:58
post cuando se producen actualizaciones 00:14:59
en el servidor 00:15:01
porque esas no se cachean 00:15:02
entonces 00:15:05
get cuando estamos haciendo consultas 00:15:06
y más, pues 00:15:09
en fin 00:15:11
algunos detallitos de esos aprovechamos 00:15:13
para verlos aquí 00:15:16
vale, entonces una vez hecho esto 00:15:17
fue donde dijimos que 00:15:20
¿eh? 00:15:21
¿qué decido? 00:15:27
Pues una vez 00:15:28
Hecho esto 00:15:34
Fue cuando dijimos 00:15:37
A ver, desde aquí ya empezamos a ver 00:15:38
Qué farragoso 00:15:41
Y qué pesado y qué todo 00:15:42
Cosas como 00:15:45
Sobre todo 00:15:48
Convertir 00:15:49
De los campos de mis results 00:15:51
A los objetos 00:15:54
Teníamos que hacerlo lógica de toda mano 00:15:56
Instanciar el objeto 00:15:58
sacar los campos con el 00:16:00
result set de las consultas 00:16:02
con cada campo setear la propiedad 00:16:04
del objeto, eso ya era un rollo 00:16:06
que teníamos que hacer a mano siempre 00:16:08
que es lo que se llama el mapeo 00:16:10
el mapeo objeto 00:16:12
relacional, el mapeo objeto 00:16:14
relacional es transformar 00:16:16
los resultados de los 00:16:18
campos de la consulta 00:16:20
en propiedades del objeto 00:16:23
pues ese mapeo hay que hacerlo a mano 00:16:24
lógicamente cuando uno trabaja con JDBC 00:16:26
Y además había ahí un montón de try-catch 00:16:28
Porque lógicamente 00:16:31
Si uno usa JDBC desde la base 00:16:32
Ahí hay un montón de excepciones 00:16:35
En tiempo de compilación 00:16:37
Que hay que capturar 00:16:39
Entonces hay un montón de try-catch 00:16:40
Ahí también revisamos el try con recursos, etc. 00:16:42
Vale 00:16:46
Pues sí, muy pesado 00:16:46
De desarrollar código JDBC 00:16:48
Pero lógicamente 00:16:50
Es el que nos permitiría 00:16:51
Si solo usáramos JDBC 00:16:53
Hacer la aplicación 00:16:55
Perfecto 00:16:56
Pero muy pesado. 00:16:58
Entonces, primera capita que pusimos por encima. 00:16:59
Spring JDBC. 00:17:04
Entonces, al poner Spring JDBC, 00:17:06
conseguíamos algunas cosas. 00:17:09
Primera, poder crear unos mapeadores básicos, 00:17:13
unos mapeadores básicos, 00:17:18
que nos permitían decir, 00:17:20
oye, espera, vamos a abrir esta aplicación, 00:17:23
Esta aplicación, ahora ya sí que la vamos a abrir. 00:17:26
Esta, que está aquí. 00:17:30
Debe estar en 2023-2025. 00:17:33
Web Developers. 00:17:38
Aquí tiene que estar. 00:17:39
Ahora lo digo. 00:17:44
Porque con la aplicación abierta es más fácil de... 00:17:45
¿Qué pasa? 00:17:48
Sí, sí, a mí también. 00:18:03
Que alguien está mirando la Fórmula 1 00:18:05
Vale 00:18:15
Esta 00:18:22
Debía ser 00:18:25
Debía ser esta de aquí 00:18:27
A ver 00:18:32
Un momento que la localice 00:18:34
Pero 00:18:35
Lo único que habíamos dicho de aquí, así muy rápido, era que con Spring JDBC incorporábamos este objeto que se asocia a una conexión, bien conexión única o bien pool de conexiones, a través de esta sentencia. 00:18:37
esa instancia sí asociado a una conexión la que sea 00:18:58
y luego el JDBC template 00:19:01
pues se usa para ejecutar la sentencia sin más 00:19:03
y si son queries 00:19:06
si le damos un mapper 00:19:07
además te lo transforma al objeto correspondiente 00:19:09
pero ese mapper lo tenemos que haber creado nosotros 00:19:12
lo tenemos que haber creado como nos dé la gana crearlo 00:19:15
bueno 00:19:18
entonces 00:19:20
la otra 00:19:22
ahora ya de nuevo 00:19:23
como asunto de diseño 00:19:25
Cuando uno gestiona las acciones que se van a hacer 00:19:27
Sobre una base de datos 00:19:29
Es importante identificar cuáles van en transacción 00:19:30
¿Vale? 00:19:33
Y de hecho con un ORM 00:19:35
Que ya veremos después 00:19:37
Se trabaja siempre 00:19:39
Se puede trabajar fuera de una transacción 00:19:41
Pero lo recomendable es 00:19:44
Trabajar siempre dentro de transacciones 00:19:45
Siempre, que esa transacción 00:19:48
Tiene solo una sentencia SQL 00:19:49
Vale, pero es una transacción 00:19:50
Recordad que una transacción es 00:19:52
Bueno 00:19:55
Ya, pero bueno 00:20:01
Como pauta de alguna manera de diseño 00:20:03
Para evitar que te confundas 00:20:05
Para habilitarte siempre la opción de un rollback 00:20:06
Aunque 00:20:09
Bueno 00:20:10
Pero 00:20:16
Siempre te vas a poder poner un rollback 00:20:17
Si se ha ejecutado mal 00:20:21
Esa sentencia porque ha dado una excepción 00:20:23
Fuera de control 00:20:25
entonces pues puedes hacer un rollback 00:20:26
porque se supone que si ha habido una excepción 00:20:28
esa sentencia no se habrá ejecutado 00:20:31
pero oye, siempre puedes poner un rollback 00:20:32
por si se hubiera ejecutado en parte 00:20:35
que no creo 00:20:36
entonces 00:20:37
una transacción, recordad que es un conjunto 00:20:40
de sentencias que necesitamos que o se hagan 00:20:43
todas o no se hagan ninguna 00:20:45
entonces si se hace la primera, la segunda y la tercera 00:20:46
falla, entonces queremos 00:20:49
que la primera y la segunda se anulen 00:20:51
eso es una transacción, ¿vale? y ahí viene el concepto 00:20:52
de rollback y commit 00:20:55
Si cuando hay una transacción 00:20:56
Se van ejecutando las sentencias SQL 00:20:59
Una tras otra 00:21:01
Pero en la base de datos no pasa nada 00:21:02
No pasará algo hasta que no hagamos el commit final 00:21:04
Entonces cuando se hace el commit final 00:21:07
Cuando todas las SQL hemos verificado 00:21:09
Que se han ejecutado 00:21:11
Sin dar excepciones 00:21:13
Si en alguna ha habido una excepción 00:21:14
Se hará un rollback que significa 00:21:16
Vuelve al principio de todo 00:21:18
Con lo cual las SQL que sí que hiciste bien 00:21:20
Sin excepción 00:21:23
Besarlas, nada 00:21:24
Bueno, pues entonces 00:21:26
Para incorporar el poder 00:21:28
Hacer transacciones, que es básico 00:21:30
Seguimos utilizando Spring 00:21:32
¿Vale? Para eso ya volvimos 00:21:36
A un 00:21:38
Proyecto de escritorio 00:21:39
Que era este, ¿vale? 00:21:41
Entonces este mismo de coches y de no sé qué 00:21:44
Pues lo hicimos 00:21:46
Con 00:21:48
Spring en el escritorio 00:21:49
Y era este 00:21:52
Sería 00:21:54
Ah, no, es que aquí estoy en 00:21:57
Aquí 00:22:02
Sería este 00:22:03
Vale 00:22:05
Pues aquí ya 00:22:07
Ya incorporamos 00:22:18
La gestión de bins de Spring 00:22:19
¿Vale? 00:22:22
Aprovechamos ya 00:22:25
Este proyecto, que lo podríamos haber incorporado 00:22:26
Antes también, porque son cosas independientes 00:22:28
La gestión de bins de Spring 00:22:30
Y el Spring JDBC 00:22:32
Y son cosas independientes 00:22:33
Pero bueno 00:22:34
ahí no lo habíamos incorporado todavía, lo incorporamos aquí 00:22:36
entonces 00:22:39
repito, además de en sí 00:22:42
el uso de las transacciones 00:22:45
que era para anotaciones y ya está 00:22:47
incorporamos, ya que usábamos 00:22:48
Spring y el Spring Core 00:22:51
la dependencia de, o sea, la gestión 00:22:52
de bins de Spring 00:22:55
y la gestión de bins de Spring 00:22:56
¿qué nos ahorraba? 00:22:59
nos ahorraba dejar de instanciar 00:23:01
cosas para inyectárselas a quien las 00:23:03
necesita 00:23:05
es lo que se llama 00:23:05
la inversión de control 00:23:08
es decir, cuando hacemos 00:23:11
las aplicaciones sin la gestión 00:23:29
de bins de sprint 00:23:31
tenemos 00:23:32
sí, tenemos 00:23:34
hablando de JDBC 00:23:36
o de acceso a datos 00:23:39
como estamos hablando nosotros 00:23:41
tenemos la conexión o el pool 00:23:42
el DAO que necesita la conexión 00:23:44
o el pool, el servicio 00:23:47
que necesita el DAO 00:23:48
la aplicación, sea la que sea 00:23:50
que necesita el servicio 00:23:53
O sea, tenemos ya una cadena de necesidades, unos se necesitan a otros y nosotros, si no usamos la gestión de sprint, tenemos que preocuparnos de instanciar todos los objetos de esa cadena para que la aplicación al final funcione. 00:23:54
Tenemos que instanciar la conexión 00:24:10
Tenemos que instanciar el DAO 00:24:11
Tenemos que instanciar el servicio 00:24:14
Para que recoja el DAO 00:24:16
Tenemos que instanciar la aplicación 00:24:18
Que recoja el servicio, en fin 00:24:20
Pues eso nos desborda 00:24:21
Entonces, ¿qué hacemos? 00:24:24
Le cedemos el control 00:24:26
De la instancia 00:24:28
De la instanciación de objetos 00:24:31
Le cedemos el control 00:24:32
A Spring 00:24:34
Y eso es lo que se llama 00:24:35
hacer la inversión 00:24:37
de control 00:24:40
le cedemos el control 00:24:40
por eso 00:24:44
el corazón de sprint 00:24:46
es que no sé cómo se dice esto en inglés 00:24:50
es el inversor de control o algo así 00:24:53
el corazón de sprint es el 00:24:55
que se llama el inversor de control 00:24:57
que no sé cómo se dice en inglés 00:24:59
pues inversión 00:25:00
que feo ¿no? 00:25:03
inversión of control 00:25:05
muy feo pero vale 00:25:06
bueno, pues el inversor de control 00:25:07
es el 00:25:10
es que no sería 00:25:11
control inversor o algo así, es el más bonito 00:25:13
no sé, bueno, da igual 00:25:15
no mandamos en eso, ¿no? 00:25:17
el IOC, pues este 00:25:23
entonces, este es el corazón 00:25:25
de Sprint, en realidad, del que todo 00:25:29
nació, luego a partir de ahí empezaron a meterse 00:25:31
ahí morraya para aburrir, pero el corazón fue 00:25:33
este, que es, no te 00:25:35
preocupes, yo soy una clase 00:25:37
maravillosa, soy una clase estupenda 00:25:39
que según vea 00:25:41
tú vas a instanciar 00:25:43
lo último, el servicio por ejemplo 00:25:45
que es el último 00:25:47
tú instancias, no, más que 00:25:49
instancia, tú pídeme el servicio, tú pídemelo 00:25:51
a mí, y yo cuando tú 00:25:53
me lo pidas, me ocuparé de instanciarlo 00:25:55
que veo que el servicio te ha dado un dado 00:25:57
instancia el dado, que veo que el dado te ha dado 00:25:59
una conexión, instancia la conexión, o sea 00:26:01
yo ya me ocuparé de instanciar 00:26:03
todo lo que haga falta, tú pídeme lo que quieres 00:26:05
entonces le cedemos el control a él 00:26:07
al inversor de control 00:26:10
vale, pero hay que configurarle 00:26:12
hay que decirle cuáles son 00:26:14
los beams que él va a tener 00:26:16
que controlar e instanciar cuando le 00:26:18
hagan falta, vamos a tener que configurarlo 00:26:20
eso era lo 00:26:22
que antiguamente pues se hacía con un 00:26:24
xml o no sé si muy 00:26:26
antiguamente, pero bueno, ya no aplica 00:26:28
un fichero beams xml para marcarlo 00:26:30
se hace con anotaciones 00:26:34
dentro del código Java que es lo habitual 00:26:36
entonces 00:26:38
hablo antes de Spring Boot 00:26:40
bueno 00:26:42
antes de Spring Boot 00:26:43
había 00:26:45
y puede seguir habiendo 00:26:47
una clase en la cual 00:26:50
tú marcas 00:26:52
los objetos que Spring 00:26:54
va a tener que instanciar 00:26:56
y le dices como instanciarlo porque hombre 00:26:57
el tan listo no va a ser 00:27:00
entonces por ejemplo como aquí 00:27:01
ya en esta aplicación de transacciones 00:27:04
estábamos usando Spring y el inversor de control, 00:27:06
pues teníamos esta clase, esta clase de aquí, 00:27:09
donde yo empiezo a crear, a anotar con bin e indicar los 00:27:13
objetos que Spring va a necesitar instanciar. 00:27:20
Pues un data source, el pool, pues este puede que ni te 00:27:25
instanciarlo. 00:27:31
Si mi DAO usa el pool, si mi DAO usa el pool, pues nada, 00:27:32
Yo le instancio y le digo cómo, ¿vale? 00:27:35
Aquí yo estoy sacando las propiedades, 00:27:40
lógicamente para la conexión, 00:27:44
las estoy sacando de un archivo de propiedades. 00:27:46
Aquí lo estoy haciendo a pelo, a lo bestia, 00:27:50
sacándolo con el properties. 00:27:52
Spring te ofrece también una posibilidad 00:27:54
de sacar las propiedades de un properties más fácilmente, 00:27:56
pero bueno, eso en el siguiente proyecto lo incorporamos, ¿vale? 00:27:59
las anotas y él ya 00:28:03
por la anotación asume que las tiene que buscar 00:28:05
en el property, pero bueno, solo en commerce no necesitan 00:28:07
proyectos, vale, pues entonces 00:28:09
oye tú, sprint, inversor de control 00:28:11
que puede que necesites instanciar 00:28:13
tú en algún momento porque yo 00:28:15
porque haga falta este 00:28:17
cuando necesites hazlo así, vale, este era 00:28:19
el pool, vale, ¿qué más? 00:28:21
oye, puede que necesites instanciar un 00:28:24
template, pues cuando necesites 00:28:25
hazlo así, vale 00:28:27
puede que necesites instanciar 00:28:29
un gestor de transacciones 00:28:31
porque esta aplicación tenía transacciones 00:28:33
pues cuando lo tengas que instanciar 00:28:35
el gestor de transacciones 00:28:37
que estará siempre asociado a un data source 00:28:39
lógicamente instanciarlo así 00:28:40
bueno, pues estos serán 00:28:42
los tres únicos bin 00:28:44
que había en esta clase 00:28:47
y ahora me diréis 00:28:48
pero bueno, también va a necesitar 00:28:50
la aplicación instanciar el DAO 00:28:53
instanciar el servicio, que menos 00:28:54
claro, pero es que no hace falta ponerlos aquí 00:28:56
yo puedo 00:28:59
como esas clases 00:29:01
tanto el DAO como el servicio 00:29:03
tienen una personalidad propia muy particular 00:29:05
el DAO es un repositorio 00:29:08
un repositorio es todo aquello que me permite 00:29:11
recuperar datos o consultarlos 00:29:14
y el servicio es todo aquello que me permite hacer cosas 00:29:17
¿vale? pues tienen esa personalidad 00:29:21
la clase servicio me permite hacer cosas 00:29:23
la clase DAO me permite trabajar con datos 00:29:26
tiene una propia personalidad, la clase DAO es un repositorio 00:29:29
y la clase servicio es un servicio. 00:29:32
Entonces, Sprint te ofrece unas anotaciones propias 00:29:37
para esas clases. 00:29:41
Exacto. 00:29:43
Entonces, en el DAO implementación, 00:29:44
este de aquí, 00:29:46
le poníamos esta anotación. 00:29:48
Esta anotación sustituye 00:29:51
hacer el bin en la clase configuración. 00:29:53
La sustituye. 00:29:57
Yo podría no poner esto, 00:29:59
pero entonces me tengo que hacer 00:30:00
aquí en conexión 00:30:02
un get 00:30:05
¿vale? 00:30:06
para este, con un return new 00:30:09
data no sé qué 00:30:12
un return new con el implementación 00:30:13
en el siguiente proyecto está puesto así 00:30:16
entonces 00:30:18
si yo no tengo aquí un bin que me permite 00:30:19
recuperar, que me permite recuperar 00:30:22
así con un return new no sé qué 00:30:24
que me permite recuperar el venta 00:30:26
de la implementación, entonces tengo 00:30:28
que anotarlo aquí 00:30:30
¿vale? 00:30:31
Entonces, anotándolo aquí, además, además, le hago ser repositorio, que algunas particularidades le darán. 00:30:33
Bueno, pues nada, este era mi repositorio con los métodos, esto estaba, ¿vale? 00:30:44
vea entrada a implementación 00:30:51
y aquí 00:30:54
pusimos 00:30:55
como esta aplicación era 00:30:57
precisamente para 00:30:59
escenificar, para 00:31:01
ejemplificar lo de las transacciones 00:31:03
nos inventamos 00:31:05
un método 00:31:07
del DAO implementación 00:31:10
que necesitaba hacerse en transacción 00:31:11
que era cambiar en el 00:31:13
escaparate un coche por otro 00:31:16
entonces 00:31:17
o se hacían las dos 00:31:19
es decir, que era marcar 00:31:22
que este coche 00:31:25
no estuviera en el escaparate 00:31:26
y que este ya sí lo estuviera 00:31:28
o se hacían las dos o ninguna 00:31:30
porque si se hace solo una de las dos 00:31:32
podría ocurrir que aparezcan los dos coches en el escaparate 00:31:34
que no puede ocurrir o que no aparezca ninguno 00:31:37
y se quede vacío, que no puede ocurrir, siempre tiene que haber uno 00:31:39
siempre tiene que haber uno 00:31:41
entonces este método 00:31:42
es un método que tiene que hacer el transacción 00:31:44
vale 00:31:46
¿Hacemos aquí algo 00:31:47
Para indicar que esto es transacción? 00:31:50
Porque esto se marca en el servicio 00:31:53
¿Vale? 00:31:56
Es decir 00:31:59
La implementación del DAO tiene la capa de servicio por encima 00:32:00
Que es la que ya llama la aplicación 00:32:03
Y ahí es donde hay que decidir 00:32:05
Que es transacción y que no 00:32:06
Pero no lo vas a hacer 00:32:08
¿Vale? 00:32:14
Entonces 00:32:17
ahora ya teníamos el servicio 00:32:18
el servicio que estaba por aquí abajo 00:32:20
este servicio de nuevo 00:32:23
anotado así, porque si no tenemos 00:32:26
que hacer un bin en la configuración 00:32:28
en la clase de configuración 00:32:30
en esta clase de conexión que hemos hecho 00:32:32
vale, pues aquí 00:32:34
estaban los servicios que fueran 00:32:36
en particular este que llamaba 00:32:38
este de aquí 00:32:40
y ahora, aquí sí que le anotábamos 00:32:41
de esta manera 00:32:45
entonces anotándolo 00:32:45
de esta manera, esto se ejecuta 00:32:47
en modo transacción 00:32:49
que significa 00:32:50
no abro y cierro la conexión por cada 00:32:52
sentencia, que es lo que se hace 00:32:55
que es lo que se haría 00:32:57
si no estuviera en modo transacción 00:32:59
si estuviéramos en modo transacción 00:33:00
esto 00:33:03
abriría conexión y la cerraría 00:33:04
con lo cual se haría el cómic automático 00:33:07
esto abriría conexión y la cerraría 00:33:09
con lo cual se haría el cómic automático 00:33:12
no, desde el momento 00:33:13
en que ponemos esto 00:33:15
con transactional 00:33:17
la conexión permanece abierta 00:33:18
todo el tiempo de vida del servicio 00:33:22
todo el tiempo de vida 00:33:24
que esto luego va a tener más implicaciones 00:33:25
con el ORM como ya veremos 00:33:27
transactional significa 00:33:29
abierta la conexión 00:33:30
todo el rato hasta que no termines 00:33:33
todo esto no la cierres 00:33:35
que nos permite eso, hacer commit o rollback 00:33:37
si hace falta 00:33:39
vale, pues aquí ya vamos a cambiar este aparate 00:33:41
forzamos un fallo 00:33:43
para ver que 00:33:45
se hacía el rollback. 00:33:48
¿Vale? 00:33:50
Claro, si hay un fallo 00:33:52
se hace el rollback automáticamente. 00:33:54
Y si no, se hace el commit automáticamente 00:33:55
al terminar el servicio. 00:33:58
¿Vale? 00:33:59
Pues entonces, de aquí 00:34:02
no había nada más. 00:34:03
Lo de la gestión de bins 00:34:05
con el sprint normal y corriente. 00:34:07
Las anotaciones 00:34:11
y ya está. 00:34:12
porque el modelo no tenía nada 00:34:13
vale 00:34:16
como veis 00:34:18
esto 00:34:21
ni se anota 00:34:22
la clase de modelo 00:34:24
ni aparece como bin en conexión 00:34:25
porque los objetos 00:34:28
del modelo no los gestiona 00:34:30
Spring, eso lo gestiona la aplicación 00:34:32
porque es la que hace las cosas con los objetos 00:34:34
ahora tengo una lista de no se que 00:34:36
Spring gestiona los objetos de alguna manera 00:34:37
de acceso a datos 00:34:40
los de trabajo con la base de datos, 00:34:42
no los de negocio, 00:34:45
no los de la lógica de negocio, 00:34:46
esos no los gestiona Spring. 00:34:48
Hombre, podrías poner, 00:34:55
podrías anotarlo, 00:34:56
no va a pasar nada, ¿vale? 00:34:57
Entonces, en esta clase de conexión 00:35:01
y ya paramos un segundito, 00:35:03
pues había que decir además, 00:35:05
cuidado con esto, 00:35:07
bueno, primero decir 00:35:08
que era una clase de configuración de Spring, 00:35:09
había que decir que era una clase, 00:35:12
había que decir a partir 00:35:13
de qué árbol de jerarquía 00:35:15
del paquete 00:35:18
él tiene que buscar clases anotadas 00:35:19
¿por qué? 00:35:22
y de verdad que ya me callo, pero el gente 00:35:24
dejarlo a medias no mola 00:35:25
porque esta está anotada 00:35:27
con repositorio, entonces Spring 00:35:30
la tiene que detectar él solito 00:35:31
la tiene que detectar 00:35:33
esta está anotada, la tiene que detectar 00:35:34
entonces es imprescindible 00:35:38
hacer un component scan 00:35:40
para decirle, oye, aparte de los bin 00:35:41
que te doy yo a mano, que están todos aquí a mano 00:35:44
dados, aparte de estos, busca 00:35:45
tú, no vaya a ser que haya repositor 00:35:48
y service 00:35:50
controller, algunos otros que pueda haber por ahí 00:35:50
búscalos a partir de 00:35:53
esta raíz, y él se mete en todos los 00:35:55
paquetes que hay ahí y los detecta 00:35:57
si yo tuviera 00:35:59
todos los bins 00:36:01
puestos aquí, bin, bin, bin, bin, bin, bin 00:36:03
el component scan no haría falta porque Spring no tiene que 00:36:05
detectar nada al solito 00:36:07
¿vale? y bueno, esto lo pusimos 00:36:08
porque íbamos a habilitar 00:36:11
el uso de esta 00:36:13
transacción, de esta anotación 00:36:16
transaccional 00:36:17
¿vale? 00:36:18
aquí 00:36:21
aquí se ha hecho 00:36:22
una inyección 00:36:30
esto es una inyección 00:36:32
lógicamente 00:36:33
clavada 00:36:35
¿no? que es para crear 00:36:38
un objeto necesito 00:36:40
otro, esto es el concepto de inyección 00:36:42
para crear un objeto 00:36:44
por favor dame otro 00:36:46
esto es lo que Spring llama 00:36:47
inyección por constructor 00:36:50
que es lo que hemos hecho siempre 00:36:52
que el constructor 00:36:56
reciba 00:36:58
el objeto 00:36:59
¿vale? y ya es instable 00:37:02
pero Spring todavía 00:37:04
pues lo hace más, hay una anotación 00:37:05
lo digo por si lo veis por aquí 00:37:08
que se usa bastante habitualmente 00:37:09
te quitas el constructor directamente 00:37:11
y marcas esta propiedad 00:37:13
con una anotación 00:37:16
que es auto-wire, o sea, auto-cableada. 00:37:18
Lo marcas así. 00:37:20
Wired. 00:37:29
¿Vale? 00:37:30
Creo que era esta. 00:37:32
Esta, ¿vale? 00:37:35
Entonces, 00:37:37
esto, cuando Spring 00:37:38
ve que una propiedad está 00:37:40
auto-cableada, 00:37:41
cuando instancias un objeto de esto, 00:37:44
¡pum!, te lo instancia 00:37:47
automáticamente para meterla aquí. 00:37:48
¿Vale? 00:37:52
Con lo cual 00:37:52
Puedes llamar al constructor sin parámetros 00:37:56
¿Vale? 00:37:59
Puedes llamar al constructor sin parámetros 00:38:01
Porque Spring 00:38:02
Con las que vea que están autocableadas 00:38:03
Pim 00:38:05
De las instancias 00:38:05
Cuando las necesita 00:38:06
Y las pone ahí 00:38:08
¿Vale? 00:38:09
Sí 00:38:15
Pero el bin 00:38:15
Una cosa es que vea 00:38:16
Él hace el view y dice 00:38:18
necesito aquí 00:38:20
uno para meterlo, entonces te lo instancia 00:38:22
al solito y lo vas inyectando por constructor 00:38:25
aquí lo inyecta en otro momento 00:38:27
¿vale? 00:38:29
aquí instancia el objeto 00:38:31
y la primera vez que lo usa 00:38:32
vale, instancia 00:38:34
¿vale? no sé si es exactamente así 00:38:37
pero bueno, sobre todo es una cosa 00:38:39
a nivel de código ¿vale? 00:38:41
entonces, el inyectarlo 00:38:45
por constructor te permitiría 00:38:47
hacer a lo mejor aquí cosas 00:38:49
o sea, tunear 00:38:51
la inyección 00:38:53
tunearla, porque haces aquí más cositas 00:38:54
con el auto-wire 00:38:57
no la puedes tunear, porque lo va a instanciar 00:38:58
con el constructor de este de aquí 00:39:01
bueno, es una herramienta más para 00:39:03
jugar y esas cosas 00:39:05
cuando uno usa esto y trabaja 00:39:07
con esto, pues al final 00:39:13
sin entender muy bien 00:39:14
nunca jamás lo que realmente está haciendo 00:39:17
al final las cosas funcionan y 00:39:19
le ves en cierto sentido a todo. 00:39:21
Venga, y ahora sí que vamos a 00:39:23
parar aquí un... 00:39:25
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:
12 de enero de 2026 - 20:47
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
39′ 27″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
170.78 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid