Saltar navegación

20260108 Repaso_UD2_2_SpringBoot - 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

pues el jueves 00:00:00
en vacaciones, antes de irnos 00:00:05
vale 00:00:08
hicimos 00:00:12
os planteé dos enunciados 00:00:14
uno para hacer con JDBC 00:00:16
sin más y otro para hacer 00:00:18
ya con Spring y con Spring JDBC 00:00:20
que además tenía una transacción que había que gestionar 00:00:22
vale, entonces hicimos el jueves 00:00:25
este de aquí, con JDBC 00:00:28
normal y corriente 00:00:30
y la idea es que 00:00:31
si lo habéis hecho con Spring 00:00:36
y lo uséis este o cualquier otro enunciado 00:00:39
que le pedís a GPTO a quien sea 00:00:41
que uséis cualquier otro 00:00:42
pero este al menos 00:00:44
para aseguraos desde cero 00:00:45
que todo lo de gestión de transacciones 00:00:48
lo tenéis claro 00:00:50
y Spring JDBC también 00:00:51
intentáis hacer este 00:00:52
todo desde cero 00:00:53
vosotros hay pipipi 00:00:54
¿cómo? 00:00:55
tratando de apoyaros 00:00:58
en los proyectos 00:00:59
que hemos hecho nosotros, en lugar 00:01:01
de en ChaGPT, lógicamente, si os apoyáis 00:01:03
en ChaGPT, aparte de que os lo va a hacer 00:01:05
él, pues en el 00:01:07
examen 00:01:09
vais a trabajar apoyándoos en los 00:01:10
otros proyectos, no en ChaGPT, 00:01:13
con lo cual, pues tratad de hacer esos enunciados 00:01:15
apoyándoos en los proyectos 00:01:16
que ahí tenéis la información necesaria. 00:01:19
Se puede sacar el siguiente 00:01:21
ejercicio con la anterior. 00:01:23
Claro, claro. Pero otra cosa es que luego, 00:01:24
por supuesto, si es que queréis hacer lo mismo, 00:01:26
este con JBC, que lo hicimos el jueves, 00:01:28
antes de irnos y este era el 00:01:30
con Spring JBC, que no lo 00:01:32
resolvimos, que la idea es que lo resolváis 00:01:34
ya no dio tiempo, por los pobres ya 00:01:36
aguantasteis una hora 00:01:38
y media, creo, o una hora 00:01:40
vale 00:01:42
pues nada, lo hacéis como 00:01:44
autoevaluación, a ver si 00:01:46
lo que hemos repasado hasta aquí 00:01:48
está claro 00:01:50
¿vale? 00:01:52
bueno, pues entonces, antes de pasar a esto 00:01:54
de aquí abajo 00:01:56
Ya que estamos con lo de los bins 00:01:57
Y todo esto 00:02:00
¿Vale? Pues 00:02:00
Spring teóricamente 00:02:02
Nos ha facilitado 00:02:05
Un poquito la vida 00:02:08
En la inyección de 00:02:09
¿Dónde tengo el ejemplo? Aquí 00:02:12
Pero hemos tenido que hacer esta clase 00:02:19
Eso sí 00:02:22
Hemos tenido que hacer esta clase 00:02:23
La cual hemos marcado los bins, etc. 00:02:25
bueno, pues como arrastrar esta 00:02:28
configuración, arrastrar esta clase 00:02:32
todo el rato, es feo 00:02:34
o da pereza o lo que sea 00:02:36
pues entonces 00:02:37
viene Spring Boot 00:02:39
que Spring Boot es 00:02:42
el que te lo detecta 00:02:44
todo, te lo hace todo 00:02:46
te elige 00:02:48
te instancia los bits cuando hagan 00:02:50
falta, etc, Spring Boot 00:02:52
entonces, ¿cómo podemos 00:02:54
a hacer una aplicación con Spring Boot que nos permite 00:02:56
ya ahorrarnos todo este rollo 00:02:58
de aquí. 00:03:00
Pues venga, a ver. 00:03:02
Esta misma aplicación. 00:03:05
A ver, es que la tenía hecha con la del taller, 00:03:06
pero esa quiero que la hagáis vosotras. 00:03:08
Vosotros. Y vosotres. 00:03:10
Venga, pues arrancáis 00:03:15
el Spring Tools. 00:03:16
En realidad 00:03:19
se puede hacer con el Eclipse igualmente, 00:03:20
pero creando el proyecto 00:03:22
con el Spring Tools, pues ya te 00:03:24
da la arquitectura, te da 00:03:26
la carpeta 00:03:28
de resursos con un properties 00:03:30
que tú ya añades lo que 00:03:32
sea, te mete 00:03:34
ya unas dependencias el solo 00:03:36
por eso es lo de usar sprint tools 00:03:38
en realidad, podríamos usar cualquier 00:03:40
entorno de desarrollo 00:03:42
que lo integre, venga 00:03:43
lo tenéis abierto, si 00:03:58
vale, pues 00:04:01
por ejemplo, esto mismo 00:04:03
de aquí, que nos va a permitir hacer copias 00:04:06
y pegas y así lo acabamos rápido 00:04:07
El ejemplo este de transacciones 00:04:09
Si lo hacemos con Sprintools 00:04:12
¿Vale? La idea es ahorrarse esta clase 00:04:16
Hemos dicho 00:04:18
Pues vamos a hacer este mismo ejemplo 00:04:19
Que era el de la venta de coches 00:04:21
Que tenía el 00:04:23
Servicio este 00:04:25
Que tenía el servicio con una transacción 00:04:27
Este mismo 00:04:31
Con Sprintboot 00:04:33
¿En qué cambiaría? 00:04:35
Pues venga 00:04:36
Vamos a hacerlo 00:04:38
Hacemos un nuevo 00:04:39
Spring Starter Project 00:04:41
Esto ya lo hicimos 00:04:46
Cuando hicimos una aplicación web 00:04:47
Con Spring 00:04:50
¿Vale? Que no tuviera 00:04:51
Serlet, sino que tuviera el controller de Spring 00:04:53
Ya lo hicimos 00:04:56
Esto ya lo hemos hecho 00:04:57
Hacer un proyecto así ya lo hemos hecho 00:04:58
Para hacer una aplicación web 00:05:01
Con un controller 00:05:03
Que es el que 00:05:05
Crear el serlet y todo ese rollo 00:05:06
Bueno, ya volveremos a eso 00:05:09
Vale, pues venga 00:05:10
Esta new sprint, pues, nombre 00:05:12
Unidad didáctica 2 00:05:15
Para que se llame 00:05:18
Igual que el otro y así no nos liemos 00:05:20
JDBC 00:05:22
Ejemplo 2, trans 00:05:25
Vale, todo lo podemos dejar así 00:05:26
¿Cómo? ¿Dónde tengo? 00:05:42
Ah, vale, vale 00:05:47
Venga 00:05:48
pues ventas 00:05:49
venga, no app 00:05:53
porque así queda más bonito 00:06:01
vale, el paquete 00:06:03
es este 00:06:06
esta ya todo cambiado 00:06:08
y bien puesto, ¿no? 00:06:11
entonces, en realidad este ¿qué hace? 00:06:13
pues se conecta 00:06:16
a esta web 00:06:17
que esta web 00:06:19
es la web que te ofrece Spring 00:06:21
para crearte un primer proyecto 00:06:23
con su estructura básica 00:06:25
Y que tú te lo descargues en un zip 00:06:26
Pues el Sprintus o el Intel IES 00:06:29
Si usáis ese que lo trae integrado 00:06:31
Y todo eso, pues hacen eso 00:06:33
Cogen ese proyecto 00:06:34
Lo desempaquetan y te lo colocan aquí 00:06:36
¿Vale? 00:06:38
¿Perdón? 00:06:43
Bueno, este en particular en Hardware 00:06:45
Sería así con una aplicación web 00:06:47
Esto no es una aplicación web 00:06:49
Vale, pues venga 00:06:50
Ahora, ¿qué dependencias vamos a usar aquí? 00:06:53
Pues la de JDBC 00:06:55
Sin duda 00:06:58
Y el driver también 00:06:59
Sin duda 00:07:02
Me ofrece estas de aquí porque son las que usamos 00:07:03
Cuando hicimos el controlador 00:07:06
Spring Web 00:07:07
Me ofrece estas 00:07:08
Pero si no las tenéis porque nunca jamás habéis usado 00:07:10
Spring Tools, pues las buscáis aquí 00:07:13
En particular aparecerán 00:07:15
En SQL 00:07:18
En SQL 00:07:19
Aparecen las dos 00:07:22
Y aquí tenéis tropecientas 00:07:23
Vale, pues estas dos básicas 00:07:27
Otra cosa es que luego haga falta poner más 00:07:33
Pues ya se verá 00:07:35
Venga, next 00:07:36
Y finish 00:07:38
Y ahora ya se pone a 00:07:40
Crearlo 00:07:42
Está todavía 00:07:45
Bueno, mientras termina voy a ir abriendo 00:07:48
La base de datos 00:08:02
API JDBC 00:08:03
Y MySQL Driver 00:08:29
Están, si no las tiene en el epígrafe 00:08:31
SQL 00:08:33
Bueno, ya está 00:08:34
Es este de aquí abajo 00:08:37
Vale, entonces 00:08:38
Veis que automáticamente ha metido aquí 00:08:42
Pues ya él un montón de dependencias 00:08:45
Y de rollos, vale 00:08:47
De Spring Boot, ya ha metido cosas 00:08:48
Y el driver 00:08:51
Otra cosa es que luego 00:08:53
Nosotros necesitamos más, bueno, necesitamos más 00:08:54
Las metemos 00:08:56
Venga, pues nuestra aplicación 00:08:57
Me ofrece ya 00:09:00
esta clase main 00:09:02
que yo lógicamente puedo cambiar 00:09:04
entonces, para lanzar la aplicación 00:09:07
este me devuelve 00:09:09
el famoso inversor 00:09:12
de control, lo que pasa es 00:09:15
que él lo tira a la basura 00:09:17
yo lo voy a recoger en algún 00:09:18
sitio para luego a través de él pedirle 00:09:21
bins o lo que sea, porque lo estoy haciendo en una aplicación 00:09:23
de escritorio, podría hacerlo en otra 00:09:25
arquitectura, hacer aquí un command 00:09:27
runner o no sé qué, hacerlo de otra manera 00:09:29
pero bueno 00:09:31
vale, entonces voy a recoger 00:09:31
el, veis aquí 00:09:34
tiene la anotación de que es una aplicación 00:09:36
Spring Boot, esta anotación es fundamental 00:09:39
para que se lance 00:09:41
solo ese bicho 00:09:43
ese inversor de control que lo detecta 00:09:44
todo y lo hace todo 00:09:46
esa anotación es fundamental, entonces vamos a 00:09:48
recoger antes de nada 00:09:50
el inversor de control que me devuelve esto 00:09:52
que creo que se llama 00:09:54
así y si no lo copiamos de 00:09:56
el otro proyecto 00:09:58
Que lo teníamos ahí en el otro 00:10:02
Está 00:10:03
Es que esto nunca me lo ofrece 00:10:12
Pero 00:10:13
El punto arranque 00:10:14
De un 00:10:17
Configuration 00:10:18
Sí, pero 00:10:20
Creo que es una implementación de esto 00:10:22
Configurable 00:10:25
Application 00:10:27
Context 00:10:29
O sea 00:10:31
Bueno, venga, se lo pongo 00:10:32
Esa directamente 00:10:35
Figurable 00:10:36
Vale, pero 00:10:41
ApplicationContext también existe, juraría 00:10:47
Que es una super clase 00:10:49
Voy a ponerlo un poco por curiosidad 00:10:51
Porque es que 00:10:53
A ver 00:10:54
Spring Framework 00:11:00
Punto 00:11:05
Con 00:11:07
Punto Context 00:11:08
.applicationContext 00:11:13
Es que yo no sé, nunca me lo ofrece 00:11:15
Y sí que existe, pero bueno, da igual 00:11:16
Ponemos esa y se acabó 00:11:19
Vale 00:11:21
¿Eh? 00:11:22
ApplicationContext 00:11:27
Es la super clase 00:11:27
Entonces yo siempre por comodidad 00:11:28
Siempre pongo esa, pero vamos 00:11:31
Vale, pues ya está 00:11:33
Entonces ahora ya vamos a 00:11:35
El resto de cosas vamos a copiarlas 00:11:37
La básica, el modelo, pues venga 00:11:38
Aquí 00:11:40
primera cosa 00:11:44
si yo hago esto 00:11:47
y pongo ahí el modelo 00:11:49
la he 00:11:52
jodido pero bien 00:11:54
porque Spring Boot 00:11:55
necesita 00:11:58
que todo cuelgue 00:11:59
de la clase que está anotada con Spring Boot 00:12:01
Application, es decir 00:12:04
esta, entonces tendré 00:12:06
que hacer com.andos.app.model 00:12:08
es decir, Spring Boot 00:12:10
hace cosas solo, pero tienes que respetar 00:12:12
sus reglas estrictamente, como alguna 00:12:14
regla te la saltes 00:12:16
es imposible 00:12:17
entonces, cuando no usas 00:12:19
Spring Boot, la estructura 00:12:22
de paquetes haces la que te da la gana 00:12:24
porque tú ya haces en la configuración 00:12:26
pones en bin la clase y le dices 00:12:28
donde está y todo, pero aquí 00:12:30
no, entonces 00:12:32
este com.dam2.model 00:12:34
no lo queremos 00:12:37
entonces 00:12:38
vale, ahí vamos a copiar 00:12:43
y pegar 00:12:53
Las de este 00:12:53
Que era una solo 00:12:56
Copiamos 00:13:00
Pegamos 00:13:04
Ahora 00:13:09
Este es el modelo nuestro 00:13:10
Vale 00:13:13
Acordaos de cambiar el paquete y ya está 00:13:14
Nuestro modelo, la clase venta 00:13:19
Que se corresponde a la base, a la tabla de aquí 00:13:21
La habíamos llamado coches, ¿verdad? 00:13:24
Sí 00:13:37
Se corresponde 00:13:38
Con esta 00:13:40
Esta de aquí 00:13:44
Vale, el modelo 00:13:45
Bueno, pues ahora vamos a hacer un DAO 00:13:47
Para acceder a esta base de datos 00:13:49
Entonces 00:13:51
El DAO, también vamos a hacer un copia y pega 00:13:53
¿Podré copiar y pegar un paquete entero? 00:13:56
Yo creo que no, ¿no? 00:13:59
¿Puedo copiar y pegar un paquete? 00:14:00
¿Y luego cambiarle el nombre? 00:14:02
Vamos a ver 00:14:04
Copio 00:14:05
Y lo 00:14:07
Es que no me va a hacer algo raro 00:14:14
En la estructura de carpetas 00:14:16
Es que me lo ha copiado 00:14:18
Pero bueno, le puedo cambiar el nombre aquí, ¿no? 00:14:20
A ver, refactor rename 00:14:22
Con punto 00:14:24
Dan 2, punto dao 00:14:30
A punto 00:14:32
Punto dao 00:14:35
Y ahora, venta dao 00:14:37
Vale, muy bien 00:14:41
El venta dao implementación 00:14:42
Pues lo mismo, vamos a copiarlo 00:14:46
Y pegarlo y cambiarlo de nombre 00:14:47
copiar 00:14:49
pegamos 00:14:53
y cambiamos 00:15:00
punto app 00:15:02
punto dao 00:15:10
implementación 00:15:12
por ejemplo 00:15:14
vale 00:15:15
aquí voy a cambiar 00:15:19
esto 00:15:28
y esto 00:15:30
y luego aparte 00:15:37
ya está, no tengo que cambiar nada más 00:15:39
vale 00:15:42
Ya está 00:15:43
Entonces este va a necesitar este de aquí 00:15:45
Va a necesitar este 00:15:48
Spring lo va a tener que inyectar 00:15:50
Pero todavía no hemos puesto ningún 00:15:52
Ninguna clase de configuración 00:15:53
Ni de nada 00:15:56
Venta de implementación, ya está 00:15:57
Sería esto 00:15:59
Vale, y nos falta 00:16:00
El servicio de la otra 00:16:03
Porque el main 00:16:06
No nos hace falta, ya tenemos nuestro propio main 00:16:09
Y la clase de configuración esta 00:16:11
Es de la que vamos a pasar completamente 00:16:13
Luego nos falta solo el paquete de servicio 00:16:15
Pues a ver 00:16:18
Con punto 00:16:34
Dan 2 00:16:52
Punto app 00:16:52
Punto service 00:16:53
Y ahora esta clase 00:16:56
Ventas service 00:17:01
Le cambiamos esto 00:17:02
Y todo lo demás ya se queda bien 00:17:10
Vale, pues la aplicación es la misma 00:17:13
Pero nos estamos olvidando de toda la parte 00:17:17
configuración 00:17:20
de los bins, ahora 00:17:24
vamos a llamar al servicio desde aquí 00:17:25
vale, pues vamos a sacar 00:17:31
el bin, vale 00:17:33
entonces, si yo quiero 00:17:37
llamar 00:17:41
a la operación correspondiente 00:17:43
pues me voy 00:17:45
a crear el 00:17:47
context 00:17:48
sí.get 00:17:52
bin 00:17:58
y ahora 00:18:00
ventas, un segundo 00:18:02
ventaservice 00:18:06
se llama punto 00:18:08
class 00:18:10
es ventas, seguro 00:18:11
no es venta 00:18:16
que querías que abriera 00:18:17
vale 00:18:27
entonces yo ahora ya con el servicio 00:18:39
pues ya haría lo que me diera la gana 00:18:42
que en este caso 00:18:43
el único método que me ofrece es este 00:18:46
¿No? Pues por ejemplo 00:18:47
Vamos a cambiar 00:18:49
El 5 por el 6 00:18:50
5, 6 00:18:53
Vale 00:18:58
Pero aquí 00:19:03
Lógicamente echáis algo 00:19:05
Y la aplicación se ha acabado 00:19:07
Ya está 00:19:08
Y hemos hecho en un pispás el DAO y todo 00:19:10
Pero echáis algo en falta 00:19:12
Toda la parte engorrosa relacionada con la conexión 00:19:14
Es decir, pero vamos a ver 00:19:17
Este da implementación 00:19:19
Usa un JDBC template 00:19:21
Pero ¿y este JDBC template de dónde sale? 00:19:24
Este JDBC template hasta ahora lo hemos hecho a mano 00:19:27
Lo hemos hecho a través de una conexión 00:19:29
De un data source 00:19:32
¿Dónde lo hemos hecho? 00:19:33
O a mano directamente 00:19:35
O si teníamos sprint 00:19:37
En la clase de configuración de sprint 00:19:38
Pero en algún sitio 00:19:42
Lo hemos puesto 00:19:43
¿Vale? 00:19:45
Bueno, pues aquí sprint no hace falta 00:19:46
Spring lo va a crear solo 00:19:48
cuando haga falta 00:19:51
y decimos, vale, muy bien, lo va a crear 00:19:52
él solo, pero ¿dónde sabe 00:19:55
a qué conexión tiene que engancharlo? 00:19:57
Yo no le he dicho ni URL 00:19:59
ni puerto ni base de datos, ¿cómo lo sabe? 00:20:01
Pues desde luego no se lo decimos 00:20:04
por código, se lo decimos 00:20:05
a través de este fichero que 00:20:07
él me ha metido aquí al que yo no le he hecho ni caso 00:20:09
cuando hemos hecho el proyecto 00:20:11
él me ha creado este fichero 00:20:13
pues aquí es donde 00:20:15
tenemos que ponerle a través 00:20:17
de unos nombres estándar de propiedad, 00:20:19
los tengo que respetar para que Spring Boot 00:20:22
se entere, le tengo que dar los datos. 00:20:23
Vale, pues por ejemplo 00:20:26
se lo podría escribir así. A ver, un momento 00:20:27
que los 00:20:29
copio de por aquí. 00:20:30
Vale, pues estos serían los básicos. 00:20:45
Luego yo puedo 00:20:49
configurar Spring Boot con muchas más propiedades 00:20:50
y más cosas, con un montón de cosas. 00:20:53
Esto es el básico, que es la 00:20:55
conexión, la url 00:20:56
username, password y driver 00:20:59
y ya está 00:21:00
y él instancia 00:21:01
ya lo que necesite relacionado 00:21:03
con la conexión, entonces aquí voy a 00:21:06
cambiar porque esto no era taller mecánico 00:21:08
sino que era coches 00:21:10
estas propiedades las voy a quitar 00:21:11
si luego me da error se las pongo 00:21:22
si, yo creo que si, pero vamos a 00:21:24
esperar que nos vaya pidiendo 00:21:31
vale, pues entonces esto sería 00:21:32
lo básico 00:21:39
conexión, o sea, 00:21:41
URL, password, 00:21:43
contraseña y driver. 00:21:45
¿Vale? Ahora que lo tengáis copiado, 00:21:47
comentamos una cosa. 00:21:49
Vale, está. 00:22:48
Si no, siempre le podéis decir a esta GPT, 00:22:59
dame un B de Properties Standard. 00:23:01
Copiáis y pegáis y lo voy a cambiar. 00:23:03
Pero vamos, yo creo que ya lo tenéis copiado. 00:23:08
Vale, pues como veis, 00:23:13
solo le estamos informando de esto. 00:23:14
De los datos de la conexión. 00:23:17
Y no le hemos dicho 00:23:19
absolutamente nada más. 00:23:20
Nuestra aplicación, ¿dónde arranca? 00:23:22
Arranca aquí, creando el servicio. 00:23:24
Esto se podría hacer dentro de un control, 00:23:28
en una aplicación web, en un montón de sitios. 00:23:30
Aquí lo tenemos puesto a lo bestia en un main, 00:23:32
que es bastante horroroso. 00:23:34
Crear un servicio directamente en un main es un poco feo, 00:23:36
pero bueno, lo que nos importa es probar. 00:23:39
Vale, pues entonces la aplicación arranca aquí. 00:23:41
Y lo primero que hace Spring Boot es, 00:23:43
ah, necesitas un ventaservice. 00:23:47
No te preocupes que te lo voy a instanciar. 00:23:49
Es el que se instancia. 00:23:51
Vale, pues entonces, cuando intenta instanciar un venta 00:23:52
service, ve que necesita un venta dado. 00:23:56
Bueno, vale, pues instancia la implementación que encuentre 00:24:01
de venta dado. 00:24:05
Aquí está puesta la interfaz, pero él busca, lógicamente, 00:24:06
una implementación de esa interfaz. 00:24:08
Pues se va a esta implementación de venta dado. 00:24:11
Aquí ve que necesita un JDBC template. 00:24:14
Pues instancia un JDBC template. 00:24:18
y aquí es donde vienen las dudas 00:24:20
porque, vamos a ver 00:24:23
un JDBC template está asociado a una conexión 00:24:24
o a un pool 00:24:27
¿cómo lo hago? 00:24:28
pues él por defecto, creo recordar 00:24:30
pero lo podemos comprar ahora mismo 00:24:33
por defecto, a menos que tú 00:24:35
no lo cambies en el properties 00:24:37
él te va a instanciar un pool 00:24:38
ICARI 00:24:41
asociado a la base de datos que le has puesto 00:24:42
en el properties, por defecto 00:24:45
un pool de ICARI 00:24:47
asociado a conexión 00:24:48
Claro, tú no escribes, tú no construyes 00:24:49
el pool, no construyes 00:24:54
nada. Tú dices 00:24:56
cuando quieras un ventadado 00:24:58
no hay uno de estos. 00:24:59
Pues Spring Boot te lo instancia 00:25:01
con los datos que hayamos puesto aquí. 00:25:03
Con estos. 00:25:07
Que si tú no has puesto nada más 00:25:08
es un pool y cari 00:25:09
hace esta conexión. Que queremos que no sea un pool 00:25:11
sino una conexión única. 00:25:14
Pues a través de la propiedad correspondiente se lo ponemos. 00:25:16
Que es un data show, no sé qué 00:25:18
Si queremos que sea un pool de otro tipo 00:25:19
En lugar de ICAR y le ponemos aquí 00:25:21
Es un pool de otro tipo 00:25:23
Aquí esto ya admite un montón de configuraciones específicas 00:25:24
Pero esto es lo más básico 00:25:28
Y por defecto te dice, vale 00:25:30
Pues la aplicación ya está 00:25:31
Hemos hecho todo esto 00:25:34
Olvidándonos completamente 00:25:36
De toda la parte sucia 00:25:38
De crear las conexiones 00:25:40
Los trycatch, etc 00:25:43
La parte sucia 00:25:45
Y esto teóricamente debería funcionar a falta de que aquí efectivamente a la conexión le falten parámetros que seguramente le falte, pero vamos a ver si nos los pide. 00:25:46
Venga, la vamos a arrancar como aplicación Spring Boot Application y arranca como aplicación Spring Boot y procesamos, provocamos error en cambio de escaparate. 00:26:00
Ah bueno, pero este es el error que hemos provocado nosotros 00:26:14
Provocamos el error 00:26:21
¿Vale? Pero la aplicación 00:26:22
Claro, para que hiciera el rollback 00:26:23
¿Vale? Entonces, espera, voy a quitarlo 00:26:26
Voy a quitarlo 00:26:28
Este throw fuera 00:26:33
¿Vale? Le ha gustado la cadena de conexión 00:26:35
No nos ha pedido ningún parámetro 00:26:38
Vale, entonces vamos a 00:26:40
Asegurarnos de que hace el cambio 00:26:42
Cambia el 5 por el 6 00:26:44
Ahora mismo están 00:26:51
0 y 1 00:26:52
Tendrán que ponerse a 1, 0 00:26:54
Pues venga, vamos a 00:26:56
Vale 00:26:59
Lo ha hecho, no ha salido ningún error 00:27:06
Eso sí, no nos ha cambiado esto 00:27:09
No le cambies el estado 00:27:15
Le dices si esto es 0 y esto es 1 00:27:17
O sea, no dices si es 0 eso ni si es 1 00:27:21
Ah, ¿no hacíamos eso en el método? 00:27:23
Sí, pues el primero, lo pongo cero y el siguiente. 00:27:25
¿Cómo se exporta la base de datos? 00:27:28
Que yo no tengo base de datos creada y me la quería pasar a la. 00:27:29
Vale, te puedes hacer en data, aquí, en database, 00:27:32
lo mismo que hacíamos para la ingeniería inversa, 00:27:40
pero no haces lo de, a partir de aquí, por ejemplo, coches. 00:27:43
Bueno, te haces ingeniería inversa. 00:27:50
o sea, dices el script 00:27:54
que hace el esquema 00:27:59
sí, pero el script que hace las tablas 00:28:00
el create table y todo eso, te refieres 00:28:05
pues con la ingeniería 00:28:07
inversa, con la que hacíamos 00:28:09
el diagramita 00:28:11
entonces te vas aquí a coches 00:28:12
esta es la forma con la que yo lo hago siempre 00:28:14
y ahora 00:28:16
que no me los coloque 00:28:20
patatines, finis 00:28:25
Y ahora aquí 00:28:27
Tú haces 00:28:29
Copy SQL to Clipboard 00:28:35
Y ya lo tendrías ahí 00:28:37
Te haces el CreateTable 00:28:40
Pero 00:28:43
Eso sí, lo tienes que hacer 00:28:45
De una por una 00:28:48
Bueno, aquí hay una tabla solo 00:28:50
Pero si hubiera más de una tabla, te aparecerían varias tablas 00:28:51
Y de una a una 00:28:54
Tendrías que ir haciendo CopySQL 00:28:56
Para tener todos los CreateTables 00:28:57
Y luego todos esos CreateTables 00:28:59
Lo vas pegando en un ficherito y ya está 00:29:01
¿Vale? 00:29:03
Entonces, bueno, la aplicación ha funcionado, pero no nos ha hecho nada porque lo único que hacía el método este, hemos dicho, es poner el primero a cero y el segundo a uno. 00:29:04
Vale. 00:29:15
Vale. 00:29:17
Entonces, si cambiáramos este a uno y este a cero, ahora ya sí veríamos algo. 00:29:17
Vale, ahora sí lo ha cambiado. 00:29:38
Vale, pues ya está. 00:29:40
Como veis, hacer una aplicación con Spring Boot es muy fácil. 00:29:41
Eso sí, tienes que configurar el fichero base de datos de properties. 00:29:44
bien configurado y luego hacer la parte 00:29:48
de código, que es la que importa, 00:29:50
lógicamente, la implementación es de los DAO 00:29:51
y de los servicios bien hechas. 00:29:54
Dime. 00:29:56
El main, 00:29:58
¿vale? Tiene esto de aquí. 00:30:03
Bueno, un segundito, que 00:30:06
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:
30′ 07″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
153.22 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid