Saltar navegación

20251204 UD2-BDR_2 - 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 6 de diciembre de 2025 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

música para animales 00:00:00
pues 00:00:03
para ver cómo ejecutar 00:00:04
sentencias, cómo acceder a una base 00:00:07
de datos relacional 00:00:09
con la capa básica 00:00:10
o sea, lo más a pelo posible 00:00:13
que se puede hacer 00:00:14
que te da el mayor control 00:00:16
mediante 00:00:18
JDBC, pues nos habíamos 00:00:21
hecho una aplicación chorra mínima 00:00:23
con un modelo que solo tenía una clase 00:00:25
con coches 00:00:27
y con ventas de coches 00:00:29
y ya está, entonces esta era 00:00:32
la entidad patatera que teníamos 00:00:34
solamente esta entidad 00:00:36
entonces el diseño 00:00:37
más habitual para 00:00:40
desacoplar lo más posible 00:00:41
la parte de acceso a datos con el resto 00:00:43
de la aplicación, el diseño más habitual 00:00:46
es el patrón DAO, en el cual 00:00:47
para cada entidad 00:00:50
persistente o que queremos que lo sea 00:00:51
nos hacemos una clase DAO 00:00:54
que aglutina 00:00:56
los métodos 00:00:57
de acceso a la base de datos 00:00:59
y luego 00:01:00
esa clase DAO a su vez le hacemos el split 00:01:02
interfaz 00:01:05
implementación 00:01:07
y así en la implementación 00:01:08
se esconde 00:01:11
todos los detalles técnicos 00:01:13
del acceso a la base de datos 00:01:15
y en la interfaz se da la referencia 00:01:17
y desde cualquier punto de la aplicación 00:01:19
tú tiras de la referencia y luego ya sabéis 00:01:21
que en tiempo de ejecución 00:01:23
se coge la implementación 00:01:24
claro, tiempo de ejecución, lo que sea 00:01:27
pues bueno, patrón habitual, pues ya está 00:01:28
pues bueno, hacemos ese patroncillo 00:01:31
adaptado a esto 00:01:33
y teníamos nuestra clase DAO 00:01:34
que habíamos decidido 00:01:36
estos cuatro métodos, por ejemplo 00:01:37
pero bueno, podrían ser más 00:01:40
estos cuatro métodos para hacer 00:01:42
con las ventas 00:01:44
y ahora teníamos que implementarla 00:01:45
y aquí nos habíamos quedado 00:01:48
entonces, ahora ya sí que vienen los detalles técnicos 00:01:50
entonces, nuestros detalles técnicos 00:01:53
Son acceso a la base de datos con JDBC 00:01:55
Eso está claro, porque es que es así 00:01:57
Sí o sí 00:01:59
Es así o sí lo que hay en la base 00:01:59
¿Cómo funciona? 00:02:01
Pues se crea 00:02:05
Conexión, se ejecuta 00:02:07
Sentencias y se cierra conexión 00:02:08
Es que eso es lo que se puede hacer con JDBC 00:02:10
Abrir conexión con la base de datos 00:02:12
Ejecutar sentencias, cerrar conexiones 00:02:15
Eso es lo que se puede hacer, sentencias de todo tipo 00:02:17
De creación de esquemas 00:02:19
Incluso no solo de consultas, etc 00:02:21
Sentencias de todo tipo 00:02:22
Vale, entonces eso se organiza llamando a métodos que como ya dijimos también se han diseñado conforme de nuevo al patrón API 00:02:23
Pues JDK te ofrece la API JDBC donde hay unos métodos que son a los que todos llamamos para hacer esto que acabo de decir 00:02:34
crear conexión, ejecutar sentencias y cerrar conexión, te ofrece unos métodos con un nombre unificado para hacer esto que acabo de decir 00:02:46
pero claro, cada base de datos tendrá que implementar eso de una forma o de otra 00:02:53
pues eso ya es responsabilidad nuestra 00:02:58
y darle la implementación a esa API que me da el JDK 00:03:01
y esa implementación como la damos a través del driver de la base de datos 00:03:05
entonces ese driver como siempre es un conjunto de clases 00:03:09
de las que dependemos y por tanto tenemos que inyectarlas 00:03:12
como dependencia, pues lo habíamos hecho aquí 00:03:17
Y ese driver era esto de aquí 00:03:20
Vale 00:03:24
Y ahora ya 00:03:27
Que ya tenemos todas las clases 00:03:29
Que necesitamos 00:03:31
Podemos empezar a hacer el detalle técnico 00:03:32
Bueno, primera cosa que hemos dicho 00:03:34
Hacer la conexión 00:03:36
Vale 00:03:38
Hacer la conexión ya 00:03:39
A nivel de código es nada, lógicamente 00:03:42
Una línea 00:03:44
Pero a nivel luego de 00:03:45
Ejecución 00:03:48
es de lo más pesado que hay 00:03:50
porque a crear una conexión te tienes 00:03:52
que entender con ese recurso 00:03:54
que está en esa IP, ese sistema gestor de bases 00:03:56
de datos y además todo lo que 00:03:58
son intercambios 00:04:00
orientados a conexión, pues son 00:04:02
muy costosos establecerlos, tienes que estar 00:04:04
ahí dándote la mano con el otro patatín 00:04:06
bueno, lo que viene a ser, vosotros como expertos 00:04:08
en redes 00:04:10
y en todo, pues de CPIP 00:04:12
el proceso hasta que estableces la conexión 00:04:14
hay un agreement por el otro, por el no 00:04:16
Pues en general, cualquier procedimiento que usa intercambios orientados a conexión son muy pesados. Vale, pues entonces, ¿cómo gestionamos eso de hacer la conexión? Pues la aplicación va a necesitar acceder a la base de datos muchas veces, muchas veces. 00:04:18
entonces, para empezar tenemos 00:04:40
dos 00:04:43
orientan dos posibilidades 00:04:44
que la aplicación sea multi hilo 00:04:47
o que no lo sea 00:04:48
si la aplicación no es multi hilo 00:04:49
y solo hay un hilo de ejecución 00:04:52
pues me puedo permitir 00:04:54
me creo una conexión 00:04:56
y dejo esa conexión ahí abierta todo el rato 00:04:57
¿vale? y ya está 00:05:00
¿por qué? porque si cada vez que yo voy a hacer 00:05:01
un acceso en cada uno de estos métodos 00:05:04
me conecto 00:05:06
hago lo que sea y cierro 00:05:08
bueno, vale, lo puedo hacer, pero 00:05:09
es más pesado para la aplicación 00:05:12
es más pesado, entonces en una aplicación 00:05:14
multihilo, pues esa podría ser 00:05:16
nuestra solución, creo la conexión 00:05:18
y ahí la dejo, claro, pues tendríamos 00:05:20
que ver luego en el contexto en el que trabajamos 00:05:22
si eso es 00:05:24
peligroso, no lo es, etcétera, pero sería 00:05:26
computacionalmente lo mejor 00:05:28
¿vale? si la aplicación 00:05:29
es multihilo 00:05:32
pues hombre, ahí se complica la vida 00:05:33
porque cada hilo 00:05:35
Necesita su propia conexión 00:05:37
No vamos a compartir ese recurso 00:05:40
Que se bloquea 00:05:41
Entonces, ¿qué solución nos...? 00:05:43
Esa sería una 00:05:46
Abrir y cerrar, pero leches 00:05:49
Lo que carga es la aplicación 00:05:51
Claro, hacer un 00:05:54
Pool de conexiones 00:05:58
¿Vale? Un pool de conexiones 00:05:59
Entonces, tú tienes un recurso 00:06:02
Que cada vez que te quieres conectar 00:06:04
Con él, tienes que hacer una conexión 00:06:06
así, pam, pam, pam 00:06:07
¿no? 00:06:09
¿puedes establecer varias conexiones al mismo tiempo? 00:06:12
claro, entonces 00:06:15
tú tienes 00:06:16
un recurso cualquiera 00:06:19
en nuestro caso 00:06:21
nuestra base de datos que está por ahí 00:06:23
y cada 00:06:25
hilo que necesita 00:06:27
conectarse, pues 00:06:29
ahí tiene que establecer una conexión 00:06:31
ahora aquí este otro hilo en paralelo 00:06:33
¿qué he hecho? 00:06:34
ah, que he movido con el codo 00:06:35
las pizarritas, vale 00:06:41
bueno, pues entonces 00:06:42
se puede 00:06:45
implementar, afortunadamente 00:06:47
no lo tenemos que implementar nosotros en Java 00:06:49
ya está hecho, como todo 00:06:51
todo está hecho en clases que yo importo 00:06:53
pues se puede implementar una clase 00:06:55
ojalá hubiera una clase Java 00:06:57
que me crea 00:06:59
un conjunto 00:07:02
de conexiones 00:07:04
que las mantiene ahí 00:07:05
y las va sirviendo 00:07:06
al proceso que se lo pide 00:07:08
¿vale? entonces esto pues bueno 00:07:10
te configura cuántas conexiones 00:07:13
más y más quieres cada vez, porque hombre 00:07:14
¿cuántas te dejas 00:07:16
en reserva siempre libres 00:07:19
por si... 00:07:21
no lo sé, eso sería otro tema 00:07:21
de estudio en el que podríamos entrar 00:07:26
pero vamos, tampoco vamos a entrar, es solamente 00:07:29
la idea de lo que es un pool de conexiones y ya está 00:07:30
entonces, esa clase 00:07:33
afortunadamente ya está hecha 00:07:35
nosotros la usamos y decimos 00:07:36
dame un pool, yo ya tengo ahí mi pool 00:07:38
y cada vez que quiera 00:07:41
una conexión, se la pido 00:07:43
al pool, entonces este 00:07:45
ya gestiona pues todo el tema de la carga 00:07:47
porque ya las tiene hechas, ya va cerrando 00:07:49
cuando proceda, gestiona 00:07:51
ya todo ese rollo, suponemos que bien 00:07:53
suponemos que lo gestiona bien 00:07:55
y nuestros silos le dicen 00:07:56
dame una, y ya está, y todo el tema de 00:07:58
sincronización, todo eso ya lo tiene gestionado 00:08:01
Entonces eso sería lo natural 00:08:03
En una aplicación multi 00:08:05
¿Vale? 00:08:07
Hacer un pool de conexiones y ya está 00:08:08
Está en la hora virtual 00:08:10
De todas maneras 00:08:17
La interfaz de venta dao 00:08:17
Tiene esos 00:08:21
Tiene estos cuatro métodos y ya está, vacíos 00:08:22
O sea, tenía estos métodos 00:08:25
Claro, tenía estos 00:08:26
Vale, pues entonces 00:08:28
Vamos a hacer las dos 00:08:31
Posibilidades 00:08:35
Entonces, ¿cómo podríamos diseñar esto? 00:08:36
¡Venga, copia! ¡Corre, corre, corre! 00:08:44
¡Se nos pasa la hora! 00:08:47
Sí, lo tengo en el aula 00:08:52
Vale, pues entonces 00:08:55
Ahora estos métodos ya sí que necesitan 00:08:59
O bien la conexión que yo voy a crear 00:09:02
Una única 00:09:06
¿Vale? Porque, repito, la opción de crearla aquí dentro 00:09:07
hacer lo que sea y cerrarla 00:09:11
sería una posibilidad, pero muy pesada 00:09:13
que cada método la cree, haga lo que sea y la cierre 00:09:15
creo, haga lo que sea y la cierro 00:09:18
como eso es muy pesado 00:09:20
pues hombre, mejor diseño 00:09:21
me creo aquí una conexión 00:09:24
que esta clase 00:09:26
implementación 00:09:28
pues tenga su objeto conexión 00:09:29
¿vale? que lo tenga 00:09:31
este objeto conexión 00:09:38
pues de donde viene 00:09:41
javasql 00:09:44
Que es la API 00:09:46
De JDBC 00:09:49
¿Cómo? 00:09:50
Hay más 00:09:53
Hay más importes 00:09:54
Supongo, pero el que nos importa es 00:09:56
Java SQL, con este nos quedamos 00:09:58
Que es la API JDBC 00:10:01
Mayoritariamente está metida ahí dentro 00:10:03
¿Vale? 00:10:05
Pues entonces esta conexión es ya la que van a usar 00:10:06
Estos métodos 00:10:09
Entonces esta conexión 00:10:10
Pues se la 00:10:13
Podemos pasar, se la podríamos pasar 00:10:15
Por parámetro 00:10:18
Aventada o implementación 00:10:19
Esto ya son 00:10:21
Elecciones de diseño 00:10:22
En el constructor 00:10:25
Por ejemplo 00:10:26
Public 00:10:29
Y aquí pues ya está 00:10:40
Conexión 00:10:48
Por ejemplo sería una posibilidad 00:10:49
¿Vale? 00:10:52
Cuando instanciamos este objeto 00:10:54
Le vamos a pasar la conexión que vamos a usar 00:10:55
y ahora aquí ya con esa conexión 00:10:59
cada método tira, hace las sentencias 00:11:01
lo que sea, porque es una única, porque no es 00:11:03
multi hilo, vale 00:11:05
entonces, ¿cómo creamos 00:11:07
esta conexión? pues en este diseño 00:11:09
que he hecho yo aquí, en este diseño 00:11:11
al pasársela por parámetro 00:11:13
la crearíamos en el punto en el que 00:11:15
la llamamos 00:11:17
¿y en qué punto? bueno pues 00:11:18
ahora es cuando ya nos viene a la cabeza 00:11:21
vamos a ejecutar estas cosas en algún sitio 00:11:22
claro, ¿dónde las ejecuta? me viene a la cabeza un main 00:11:25
Lógicamente de un main 00:11:27
Que es donde yo llamaré a venta de implementación 00:11:28
Pero bueno, si intentamos de nuevo 00:11:30
Organizar la aplicación como un poquito más 00:11:32
De elegancia 00:11:35
Pues cuando nos viene 00:11:36
La clase que ya hace las cosas 00:11:39
O sea que me ofrece 00:11:41
Los comportamientos que yo necesito 00:11:42
Pues nos viene la palabra 00:11:45
Servicio 00:11:46
Las clases de servicio 00:11:47
Son las clases que tienen 00:11:51
Los requisitos funcionales 00:11:53
la aplicación, lo que la aplicación va a hacer 00:11:56
dicho así resumido 00:11:59
y las clases 00:12:01
de servicio, parte de lo que tienen 00:12:03
que hacer, van a necesitar 00:12:05
hacer acceso a datos, por las clases de servicio 00:12:06
tendrán que implementar 00:12:09
este objeto 00:12:11
para llamar a los métodos 00:12:13
bueno, pues en lugar por tanto de hacer 00:12:14
esto desde un main, pues vamos a hacerlo desde 00:12:17
una clase servicio 00:12:18
yo que sé, la metemos 00:12:20
en cualquier paquetillo 00:12:24
pues por ejemplo 00:12:26
ventas 00:12:41
service, aquí van 00:12:44
a estar las funcionalidades 00:12:48
que realmente le interesan 00:12:50
a la aplicación, y ahora ya estas 00:12:52
funcionalidades las llamará quien sea 00:12:54
las puede llamar una 00:12:56
aplicación de sprint 00:12:57
una aplicación web, las puede llamar 00:13:00
un setlet, las puede llamar un main 00:13:02
las puede llamar una interfaz gráfica, quien sea 00:13:04
puede llamar ahora ya este servicio, que es un servicio 00:13:06
sin más 00:13:08
pues por ejemplo 00:13:09
¿Qué queremos hacer aquí? 00:13:11
Vamos a hacer algo que tengamos ya implementado aquí 00:13:14
Porque si no, pues vamos a crear una venta 00:13:16
Al servicio le interesa 00:13:19
El tío que me ha pedido la aplicación 00:13:21
Me dice, oye 00:13:23
Necesito crear una venta 00:13:24
Pues venga 00:13:27
Necesita la conexión 00:13:27
El tema es 00:13:41
Cómo acceder a ella 00:13:42
Vale, pues 00:13:44
La puedo poner 00:13:45
No necesita la 00:13:47
lo que necesita este para operar 00:13:48
es la implementación del DAO 00:13:52
claro 00:13:54
entonces 00:13:56
aquí podríamos poner 00:13:57
el servicio va a necesitar 00:13:59
como es el servicio de venta 00:14:04
va a necesitar el venta DAO 00:14:05
implementación 00:14:07
lo va a necesitar 00:14:10
y este pues le podemos poner 00:14:11
su constructor 00:14:26
vale entonces 00:14:27
ahora el problema de crear 00:14:51
la venta da implementación, está delegado 00:14:55
al que llame el servicio, ¿vale? 00:14:57
En nuestro caso ya sí que va a ser un main 00:14:59
¿Vale? 00:15:00
Esto, porque yo he hecho este diseño, podríamos 00:15:03
en este mismo servicio 00:15:05
darle valor a esta venta da implementación 00:15:07
y meter aquí la conexión, son posibilidades 00:15:09
¿Vale? 00:15:11
Ya, claro, pero es que realmente 00:15:13
suele ser así, ¿vale? 00:15:15
Por eso, para hacer un 00:15:17
getConnection de mierda, para hacer eso 00:15:19
estoy haciendo mil clases y mil 00:15:21
capas, pero es que suele ser así la estructura 00:15:23
de las aplicaciones, entonces pues para que 00:15:25
no, para que os sea familiar 00:15:27
tanto los términos como la estructura 00:15:29
tú en una aplicación normal es que 00:15:31
vas a ver estos paquetes, vas a ver el modelo 00:15:33
vas a ver los servicios, vas a ver los daos 00:15:35
estos paquetes los vas a ver 00:15:37
y cuanto antes especifiques 00:15:39
cuanto antes identifiques cada cosa que será 00:15:41
pues mejor, porque entonces si quieres ver 00:15:43
algo te vas ahí 00:15:45
claro, o sea una aplicación 00:15:46
que hace una chorrada 00:15:49
tiene un montón de paquetes, cada uno 00:15:50
para una capa distinta 00:15:53
pero claro, luego esa aplicación 00:15:54
si va engordando 00:15:57
pues van engordando cada cosita por separado 00:15:58
y cada una ocupándose de lo suyo 00:16:00
entonces luego es más fácil 00:16:02
entonces no engordas tampoco por separado 00:16:05
engordas el dado y tienes que engordar el dado 00:16:06
bueno ya, pero luego cambias 00:16:08
el modelo, sí, pero me refiero 00:16:11
que conceptualmente 00:16:13
se va engordando por separado 00:16:15
sí, claro, cada uno va a tirar del otro 00:16:17
si engorda el modelo y tú quieres 00:16:19
que todo sea en precisión, pues tendrás que 00:16:21
pero claro, que siempre se va a mantener esa separación 00:16:22
qué rebelde sois 00:16:26
ya, y también te gustan más los 00:16:31
que los streams 00:16:35
en fin 00:16:37
qué le vamos a hacer, así es como 00:16:40
yo sí que veo 00:16:43
yo sí que veo cierto sentido 00:16:45
hacer las cosas con esta estructura 00:16:49
orientada de cara a la reutilización 00:16:51
si tú tienes el servicio 00:16:54
aparte, pues bueno, te va a ser 00:16:56
más fácil ahí 00:16:58
conectar con la vista 00:16:59
entonces, ¿eh? 00:17:02
esto es un servicio, como que no hemos visto servicios 00:17:06
esto es un servicio, ¿ya has visto servicios? 00:17:08
ah, vale 00:17:11
claro, es que 00:17:12
no, no, no, pero me refiero 00:17:14
que las cosas 00:17:16
en realidad, en desarrollo son 00:17:18
nombres 00:17:20
Este año, en realidad, sobre todo 00:17:21
Entre otras cosas, estamos aprendiendo 00:17:24
Nombres, pero de conceptos que ya sabemos 00:17:26
¿Vale? 00:17:28
Venga, pues entonces 00:17:30
¿Dónde estamos? 00:17:32
Porque con tanta clase ya no sé dónde estamos 00:17:36
Sí, sí, yo no lo defiendo, pero yo tengo que hacer 00:17:37
Mi papel, esto es como 00:17:40
Como el presidente del gobierno, porque tiene que vender 00:17:41
Que él va a hacer algo bueno 00:17:44
Y tú eliges si te lo crees o no 00:17:45
Pues aquí, guay, yo te vendo esto 00:17:48
Porque es mi trabajo 00:17:49
Vale, ahora en crear venta 00:17:53
Pues esto sería 00:17:57
Dao.insert 00:17:58
¿Verdad? 00:18:00
Insert, venta 00:18:02
Perdón 00:18:04
Es que 00:18:05
Qué feo estoy haciendo esto 00:18:06
Claro, es que tal y como lo había hecho 00:18:10
Qué feo 00:18:17
Vale, fijaos 00:18:18
Que bonito, ahora está mucho más bonito 00:18:20
¿Vale? Ahora ya es que 00:18:23
Este servicio 00:18:25
Ni hace referencia a la implementación 00:18:26
Ni la hace, ni se entera, ni nada 00:18:29
¿Vale? 00:18:31
Que antes estaba muy feo 00:18:32
Bueno, pues 00:18:33
Esta sería la estructura 00:18:37
Pero ahora ya alguien tendrá que llamar al servicio 00:18:38
Alguien tendrá que crear 00:18:41
Ese servicio para llamarlo 00:18:43
Y tal y como lo hemos hecho nosotros 00:18:44
En el momento de crearlo 00:18:46
Es cuando hay que darle ese DAO 00:18:48
Y en el momento de crear ese DAB es cuando hay que hacer la conexión 00:18:50
Tal y como lo hemos hecho nosotros 00:18:52
¿Vale? Que yo que sé, a lo mejor le pides 00:18:54
Una aplicación así a HGPT 00:18:56
Te va a traer más estructura, casi seguro 00:18:58
Pero igual te crea la conexión 00:19:01
Aquí mismo, pues yo que sé, depende también 00:19:03
Un poco del contexto en el que trabajes 00:19:04
Ahora, vale 00:19:06
Vámonos ahora ya a nuestra 00:19:08
¿Qué le pasa a esto? Vale 00:19:10
Vámonos a nuestra aplicación 00:19:14
Sin más 00:19:16
Perdón, que hace un poco de daño 00:19:17
Sí, es amarillo ahí 00:19:21
Duele, vale 00:19:23
Pues venga, nos hacemos 00:19:25
Un paquetillo con la app en sí 00:19:27
Y en este caso nuestra app 00:19:29
Es un main 00:19:37
Pero podría ser pues la llamada 00:19:38
Spring Boot para que genere 00:19:41
Todos los bins, podría ser otras cosas 00:19:43
Ahora mismo olvidaros de eso 00:19:45
De nada, ahora mismo es un main 00:19:46
Ya está 00:19:49
Entonces, en el que por fin 00:19:50
Ya vamos a crear la conexión 00:19:52
La famosa línea para la cual hemos dado 00:19:54
Cientas mil vueltas 00:19:56
Pero 00:19:57
En el fondo os ha gustado 00:19:59
Lo que pasa es que os hacéis los duros 00:20:01
Pero 00:20:03
Reconoced que un poco 00:20:03
Os gusta abrir la mente 00:20:17
Y mover el cerebro 00:20:19
Y plantearos cosas 00:20:20
Porque es lo poquito 00:20:22
Si algo podemos daros nosotros 00:20:24
Es un contexto 00:20:27
En el cual os sentáis incómodos 00:20:29
Y tengáis que mover un poco el cerebro 00:20:31
Porque los contenidos 00:20:33
Van y vienen 00:20:34
Completamente, hay una base 00:20:36
Yo en seis años estudié unos contenidos 00:20:37
Que jamás nunca he aplicado 00:20:41
Pero no son seis años tirados a la basura 00:20:43
Mis años de carrera, para nada 00:20:45
No, y me lo creo 00:20:47
Me lo creo realmente 00:20:50
nos fueron tirados a la basura 00:20:52
aunque no he aplicado 00:20:53
jamás 00:20:55
ninguno de los fondos 00:20:55
tú te crees que yo 00:20:56
10 horas a la semana 00:20:57
de comunicaciones ópticas 00:20:58
¿alguna vez he usado 00:20:59
comunicaciones ópticas? 00:21:01
en la vida 00:21:02
no, por ejemplo 00:21:02
pero 00:21:03
todo eso 00:21:04
pues de alguna manera 00:21:05
me... 00:21:06
pues la asignatura 00:21:07
de comunicaciones 00:21:10
por decirte la primera asignatura 00:21:10
se me ha venido a la cabeza 00:21:11
que no he aplicado 00:21:12
jamás en la vida 00:21:13
bueno pues 00:21:14
toda la física 00:21:17
de la fibra óptica 00:21:18
de principio a fin 00:21:19
toda la matemática 00:21:20
de los modos, de los multimodos, todo de principio 00:21:22
a fin, todos los detalles 00:21:24
más mínimos, ¿tú crees que yo eso alguna vez 00:21:26
lo he usado? jamás 00:21:28
bueno, sí, claro 00:21:29
todo eso se supone que también la bioseguridad 00:21:32
física, entonces 00:21:34
pues aquí lo mismo 00:21:35
aunque os sintáis 00:21:37
incómodos y luego los 00:21:40
contenidos en concreto, a lo mejor no los apliquéis 00:21:42
es realmente 00:21:44
la mayor enseñanza que podéis sacar de un ciclo 00:21:45
el haber desarrollado 00:21:48
de alguna manera esa 00:21:50
capacidad de pensar en situaciones incómodas 00:21:51
en entender 00:21:54
en unir 00:21:56
además se te quedan unos conocimientos 00:21:57
básicos que seguramente al final acabes usando 00:21:59
pero sobre todo 00:22:02
la capacidad lógica, la memoria 00:22:05
y vencer la pereza 00:22:08
son las tres cosas que hay que aprender 00:22:09
estos dos años 00:22:11
desarrollar capacidad de pensamiento lógico 00:22:12
aplicado a esto que estamos viendo 00:22:16
aunque en el futuro igual lo apliquéis a otra cosa 00:22:18
tú en las prácticas seguramente hiciste algo 00:22:19
por lo que me contaste 00:22:22
no tiene nada que ver con nada lo que habías estudiado aquí 00:22:23
¿no? 00:22:25
se tenía que ver, vaya por Dios 00:22:27
ah, vale, creía que 00:22:28
vale, vale, no sé por qué me sonaba 00:22:33
pero bueno 00:22:35
hay gente que de repente tiene que rehacer una aplicación 00:22:37
completa que está en C++ o mil cosas 00:22:39
pero bueno, ya has desarrollado un pensamiento lógico 00:22:41
y pum, lo aplicas, entonces eso es lo más importante 00:22:43
entrenarlo con esto 00:22:45
entrenarlo con esto, la memoria 00:22:47
Entrenar la memoria 00:22:49
Y vencer la pereza 00:22:50
Que te va a ti muy bien 00:22:53
Lo de tengo que hacer una aplicación 00:22:55
Sé hacerla, me suena 00:22:57
Y además incluso puede 00:22:59
Que es que ni siquiera vaya a utilizar esto en la vida 00:23:01
Pero aún así vence la pereza y la haces 00:23:03
Porque eso es lo que te va 00:23:05
A preparar para el futuro 00:23:06
Bueno, después de este rollo 00:23:09
Que se ha quedado grabado 00:23:13
Una charla motivacional 00:23:14
Que se ha quedado grabado 00:23:16
ahora ya vamos a hacer la 00:23:19
vamos a insertar una venta 00:23:21
vamos a insertar una venta 00:23:24
pues para insertar una venta necesito 00:23:25
el objeto ventaservice, es que no hay tutía 00:23:27
que le tengo que pasar 00:23:30
lógicamente la conexión, le voy a poner ahora esto 00:23:45
perdón 00:23:47
perdón 00:23:49
a ver, le he puesto 00:23:51
ahora mismo null solamente para quitar el error 00:23:53
de compilación, ahora lógicamente 00:23:55
le damos la conexión 00:23:57
y ahora ya esta aplicación 00:23:58
Pues que yo quiero insertar una venta 00:24:01
Pues aquí, pues lo que sea 00:24:03
Dame datos 00:24:05
Dame datos 00:24:07
Se creará la venta 00:24:10
Y ahora ya 00:24:13
Service.createventa 00:24:19
Esta será nuestra aplicación 00:24:22
Y aquí ni vemos DAO 00:24:31
Ni vemos nada 00:24:33
Vemos el servicio, ya está 00:24:34
Pero ya está, no vemos DAO 00:24:37
Y DAO no ve DAO implementación 00:24:38
Me refiero al código ahí dentro 00:24:40
Entonces, pues bueno, de alguna manera sí que estamos desacoplando y facilitando la posible recompilación, aunque no te lo creas, pero tampoco te creas que yo me lo creo mucho, pero esto es como los, yo qué sé, como el cura, te suelta su película y tú crees que creen Dios, pues no, pues ya está, pues esto es igual. 00:24:42
Ahora ya sé que vamos a pasarle la conexión 00:25:01
Vale 00:25:07
Perdón, tenemos que pasarle el objeto 00:25:09
Implementación 00:25:12
Ventadao 00:25:14
Y a este ventadao 00:25:18
Implementación es al que 00:25:29
Tendremos que pasarle 00:25:31
Ahora ya sí 00:25:33
La conexión, vale 00:25:35
Entonces 00:25:46
Espera, estoy poniendo todo nul para quitar los errores 00:25:48
De compilación y ver la estructura 00:25:51
Ahora ya lo rellenamos 00:25:53
¿Dónde? 00:25:55
Uy, uy, uy 00:26:00
Venta 00:26:02
A ver 00:26:04
¿Qué he hecho mal? 00:26:06
Ahí, justo 00:26:07
Cándele el nombre por trabajo 00:26:08
Ah, vale 00:26:10
Vale, vale 00:26:14
Vale, vale 00:26:15
Es que es mucho más bonito que se llame así 00:26:18
Vale 00:26:23
Entrada de implementación 00:26:24
Aquí lo que pasa es que ya 00:26:34
Con la cosa rara que he hecho se me ha debido crear 00:26:37
Algo que no quería, este 00:26:39
Ah, se me ha quedado este que no le quiero 00:26:40
Sí, es que se me ha creado el uno 00:26:42
Que se adaptaba a ese 00:26:47
En fin, que ha hecho una tontería 00:26:48
Vale, ahora ya sí 00:26:50
Puedo 00:26:52
Vale, al final 00:26:55
No me he resistido 00:26:59
Y he cogido tu truco del 00:27:01
que es que ese truco se me ha dado siempre 00:27:03
muy mal rollo, lo de que él haga los import 00:27:05
y... pero bueno 00:27:07
confío en él 00:27:09
claro, por eso siempre me da un poco de angustia 00:27:11
pero bueno, como aquí lo tenemos arriba 00:27:16
rápidamente y si algo 00:27:17
vale, pues esta sería la estructura 00:27:19
entonces, aquí 00:27:21
aquí, sí que es cierto 00:27:22
perdón, aquí arriba 00:27:25
que ya 00:27:26
hemos perdido un poco el desacoplamiento 00:27:28
porque aquí estamos mirando directamente 00:27:31
el barro, estamos mirando 00:27:33
lo sucio, que es 00:27:35
la conexión y el 00:27:37
ventadao, estamos mirando aquí un poco ya lo 00:27:39
guarrete, lo del barro 00:27:41
lo ideal sería que yo hiciera el servicio y ya está 00:27:42
vale, lo que pasa es que 00:27:45
bueno, que es que no hay tutía, estoy que meterlo en algún sitio 00:27:47
lo ideal sería, o no 00:27:49
de nuevo va en opiniones y gustos 00:27:53
que yo tuviera alguna capita 00:27:55
por encima, que me limpiara 00:27:57
esto, y se dedicara 00:27:59
a qué, a ir 00:28:01
inyectando él los 00:28:03
objetos según los va necesitando 00:28:05
yo me hago mi venta service 00:28:07
y venta service se da cuenta de que 00:28:08
necesita una implementación 00:28:11
alguien mágico que está por ahí 00:28:12
va y lo genera, el de implementación 00:28:15
se da cuenta, ahí está una conexión, alguien 00:28:17
mágico que está por ahí va y se lo genera 00:28:19
y se lo mete y no sé qué, ojalá hubiera 00:28:21
alguien mágico por ahí que creara 00:28:22
lo que hace falta, lo va metiendo y yo no 00:28:24
tengo que hacer esta mierda 00:28:26
pero si hay alguien mágico que lo haga, que es 00:28:27
sprint, ¿vale? 00:28:30
entonces con esa capita de sprint 00:28:32
pues la parte de inyección de dependencias 00:28:33
que significa 00:28:36
si yo voy a crear un objeto y necesita algo 00:28:37
crealo tú y mételo tú 00:28:40
yo me voy a andar yo aquí creándolo 00:28:42
para meterlo 00:28:44
sprint, entre otras cosas 00:28:45
originalmente se creó 00:28:48
como un motor de inyección de dependencias 00:28:50
que se llama, ¿qué es inyección de dependencias? 00:28:52
se eligió una frase muy bonita para 00:28:54
poder venderlo, porque si no lo compra nadie 00:28:56
¿Qué significa? ¿Quieres un objeto? 00:28:58
Yo te lo creo 00:29:01
Y ya está, y para eso se hacían unos 00:29:01
XML de configuración donde 00:29:04
El que hacía la aplicación, pues había 00:29:06
Hecho algo con un caruto, porque 00:29:08
Se ahorraba hacer esto, pero luego se tenía que 00:29:10
Hacer un pedazo de XML en el que tenía 00:29:12
Que identificar, voy a usar este bin, y voy a usar 00:29:14
Este, y voy a usar este, cuando te haga 00:29:16
Falta lo creas solo, y voy a usar este bin 00:29:18
También, pero cuidado, este no va a ser 00:29:20
Duplicado el otro, entonces tenías que hacer un pedazo 00:29:22
De XML enorme 00:29:24
Bueno, se configuraba con XML 00:29:26
Bueno, y se sigue configurando 00:29:30
Depende de la parte de Spring en la que estés 00:29:32
Entonces, bueno, ahí tenías que configurar 00:29:35
Oye, que vas a necesitar esto, créalo cuando haga falta 00:29:37
Y ya Spring te hacía todos sus 00:29:39
Todos sus constructores 00:29:42
Para meterlo 00:29:44
Esa es la inyección de dependencias 00:29:44
Hacer news para crear objetos 00:29:46
Y meterlo donde haga falta 00:29:49
Es decir, lo que hemos hecho nosotros 00:29:50
Aquí hemos inyectado una conexión a este 00:29:52
Y aquí hemos inyectado 00:29:55
Un DAO a este 00:29:58
¿Vale? Queda más bonito decirlo inyectado 00:29:59
Pero lo que hemos hecho ha sido crearlo y meterlo 00:30:03
¿Por qué le pones aventada a la ventana de null en vez de con? 00:30:04
Porque, sí, porque estaba poniendo 00:30:06
Ahora los null sin más para quitar el error de conexión 00:30:08
Para quitar el error de compilación 00:30:11
No le regañes tampoco 00:30:13
A ver, que he puesto null 00:30:14
En todos los parámetros 00:30:17
Para quitar el error de compilación 00:30:18
Ahora ya 00:30:20
Sí, sí, sí, aquí yo puedo poner con 00:30:20
Y ahora ya aquí 00:30:24
Pondré DAO 00:30:26
Ya estos dos NULL los quito 00:30:28
Y ahora ya por fin todo esto 00:30:30
No tiene nada que ver con JDBC 00:30:33
Ahora ya sí que nos vamos a JDBC 00:30:34
Que es crear la conexión 00:30:36
No creo que haya dos corrientes sobre eso 00:30:37
No creo que haya dos corrientes 00:30:52
No lo sé 00:30:55
Yo sé pocas cosas 00:30:56
Como el abuelo de Kirikou 00:30:58
Pero 00:30:59
Yo creo que sí, lo que pasa es que 00:31:00
claro, depende del contexto, si es una 00:31:07
aplicación donde el rendimiento es crítico 00:31:09
pues en esa aplicación 00:31:11
cuantas menos 00:31:13
capas pongas mejor porque menos vas a perder 00:31:15
el control, pero eso es una aplicación 00:31:17
donde el rendimiento es crítico 00:31:18
no lo vas a hacer con Java, porque Java 00:31:21
ya sobre la máquina virtual te mete ahí 00:31:22
entonces Java es para 00:31:24
aplicaciones comerciales y esencialmente 00:31:26
Ahí el rendimiento no es tan importante 00:31:29
Es más importante que la aplicación sea escalable 00:31:31
Mantenible 00:31:33
Y para eso 00:31:35
Dime, hoy vas a decir algo, ¿no? 00:31:35
Sí 00:31:38
¿Qué es? 00:31:38
Grand 00:31:43
Ah, Graal 00:31:44
Que te quita los tiempos de arranque 00:31:45
Que te quita un montón de cosas 00:31:47
Y además te va a poner nuevo Spring Boot con el 4.0 00:31:48
Y a la 10 independencia 00:31:51
Se puede hacer de una forma programáticamente 00:31:53
Quitándote los componentes y las configuraciones 00:31:55
¿Lo habéis entendido? 00:31:57
Claro, pues 00:32:01
Conclusión que podemos sacar de lo que ha dicho 00:32:06
Que aunque pongas 00:32:09
No, ¿eh? 00:32:11
No, no, no, no 00:32:12
Sí, ¿qué sabéis? 00:32:14
A ver, justo 00:32:16
Claro 00:32:18
Efectivamente 00:32:20
Que hay trabajo hecho en relación a 00:32:22
Optimizar el tiempo 00:32:25
pero no quitar las capas 00:32:26
porque eso sí que, vale 00:32:28
entonces todo eso que dice la anotación de no sé qué 00:32:30
son anotaciones que se ponen para sustituir 00:32:32
ese XML, he dicho yo 00:32:34
entonces ahora ya si ni siquiera pones 00:32:36
¿Perdón? 00:32:37
Claro, que la aplicación 00:32:50
que ya tiene es una cebolla enorme 00:32:52
pues que bueno 00:32:54
Que sea una cebolla que funcione 00:32:55
Que no te pierdas 00:32:57
Pero bueno, son 00:32:58
Conversaciones 00:33:01
De alguna manera en las que yo tampoco 00:33:03
Tengo 00:33:05
Tengo mucha 00:33:06
Información realmente, porque yo estoy aquí 00:33:11
No estoy fuera, no estoy trabajando en Google 00:33:13
Entonces, no sé 00:33:15
Bueno 00:33:16
Pues ahora ya sí 00:33:19
Hemos completado toda la primera hora 00:33:21
Para llegar a la conexión 00:33:24
A esa unidad de conexión que vamos a hacer 00:33:25
Vale, pues 00:33:27
¿Cómo se hace una conexión? 00:33:29
Pues este objeto de aquí 00:33:37
Es un objeto de la API JDBC 00:33:39
Que os sonará del trabajillo del año pasado 00:33:43
Y este objeto pues tiene 00:33:45
Un getConnection 00:33:47
Donde tú, aunque está sobrecargado 00:33:49
Pues bueno, lo que vamos a usar nosotros 00:33:52
El método más usado 00:33:55
Tiene tres parámetros 00:33:59
Donde el primero sería 00:34:00
La URL donde está la base de datos 00:34:02
El segundo el usuario 00:34:05
Y el otro la password 00:34:06
¿Vale? 00:34:08
Entonces 00:34:15
Vale 00:34:16
Vamos a meterlo aquí en un 00:34:21
Try catch 00:34:24
Ahora, ¿qué hacemos? 00:34:26
Cableamos, hardcodeamos 00:34:31
Como lo queráis llamar 00:34:33
A mí me gusta más cablear porque soy 00:34:34
Antigua 00:34:36
aquí los datos 00:34:38
que feo, esto sí que sí 00:34:39
efectivamente 00:34:42
que feo, vamos a ponerlo como mínimo 00:34:46
en un properties, que es que es donde 00:34:49
se pone, ahí no 00:34:50
vamos a poner estos tres datos que necesitamos 00:34:52
en un properties, pues venga 00:34:54
vamos a hacernos un properties 00:34:56
aquí en recursos, por ejemplo 00:34:57
un fichero 00:35:01
properties 00:35:05
Y aquí, ¿qué tres datos nos interesan? 00:35:06
La URL de la base de datos 00:35:18
El usuario 00:35:20
Y la contraseña 00:35:23
Pues aquí los vamos a poner 00:35:26
El usuario y contraseña 00:35:29
Qué feo esto, deberíamos haber hecho en nuestro esquema 00:35:30
Cuando hicimos el esquema, la base de datos, ventas o coches 00:35:36
O como se llamara 00:35:40
teníamos que haber hecho un usuario para ella y poner aquí 00:35:40
ese usuario, ¿vale? pues muy bien 00:35:43
hecho, y es el usuario que habría 00:35:45
que poner aquí 00:35:47
¿vale? bueno 00:35:47
como no está hecho voy a poner esto 00:35:50
y aquí la url que necesita el 00:35:52
driver manager, pues la 00:35:55
API JDBC necesita que siga un 00:35:57
estándar, primero se pone 00:35:59
JDBC 00:36:01
luego se pone 00:36:04
la tecnología de la base de datos en la que 00:36:06
estás 00:36:08
y ahora ya sí que pones la url 00:36:09
En nuestro caso la base de datos está en localhost 00:36:12
Entonces 00:36:15
Aquí 00:36:16
Esto con las barritas siempre 00:36:18
Me hago un lío 00:36:21
Entonces 00:36:22
Yo creo que 00:36:24
Vamos a lanzarnos sin mirar la chuleta 00:36:27
Y si nos da un error de no encuentro 00:36:31
La conexión, pues ya la cambiamos 00:36:33
URL 00:36:34
La IP que fuera, claro, en mi caso 00:36:36
Está la base de datos aquí 00:36:39
puerto en el que escucha 00:36:40
lo hemos dejado en el puerto por defecto 00:36:41
de MySQL que es 3306 00:36:44
en el que lo dejamos 00:36:46
si dejamos el 3306 00:36:47
ya está, no tendríamos que hacer nada más 00:36:50
si le cambiamos, si hemos cambiado de puerto 00:36:52
al gestor de base de datos 00:36:54
pues pondríamos aquí el puerto nuevo 00:36:56
el que fuera 00:36:57
si está en el 3306 me da igual dejarlo así que no ponerlo 00:36:58
y aquí pues vamos a poner la base 00:37:02
de datos que creo que se llamaba 00:37:06
Coches 00:37:07
Entonces a la conexión se le pueden poner 00:37:08
Además parámetros 00:37:13
Pues la 00:37:14
Zona horaria, etc 00:37:16
Pero el resto de parámetros que le puedes poner 00:37:18
A la conexión 00:37:21
Puede que hagan falta, puede que no hagan falta 00:37:22
Depende del driver que estés usando 00:37:25
Depende de la versión de Java que estés usando 00:37:27
Depende de un montón de cosas random 00:37:28
Entonces vamos a no ponerle 00:37:31
Es que no sé en qué sentido 00:37:33
Es que puede que haya puesto la barra al revés 00:37:48
Porque si no 00:37:50
Efectivamente sería el carácter de escape barra C 00:37:52
A ver, venga 00:37:54
Vamos a mirar la chuleta 00:37:56
Pero la memoria la tenéis que desarrollar vosotros 00:37:58
Que a mí ya no me hace falta 00:38:00
Vamos a ver 00:38:01
Donde tenemos 00:38:06
Era al otro lado de como la he puesto 00:38:08
Efectivamente 00:38:11
Vale 00:38:12
Si es que puesta así 00:38:14
Como tu bien dices se convertiría en una 00:38:16
Claro 00:38:19
Vale 00:38:20
He puesto la interrogación 00:38:22
Porque he dicho que la cadena de conexión 00:38:26
Puede admitir parámetros 00:38:29
Pues no sé qué 00:38:31
Time, UTC, no sé cuántos 00:38:34
Que puede que hagan falta o no 00:38:35
También depende del driver en el que estés trabajando 00:38:37
En qué esquema estés 00:38:39
Entonces, por ahora yo no los pongo 00:38:41
Solo un error de ejecución nos lo pide 00:38:42
Pues pum, ahí tratamos de ensuciar el problema 00:38:44
Pues ya tenemos nuestro properties 00:38:46
Y ahora ya sí 00:38:51
Nuestra aplicación tendrá que sacar 00:38:53
Aquí del properties 00:38:56
Properties 00:38:57
Vale 00:39:04
De este objeto properties 00:39:04
Que creábamos así 00:39:08
Que la dejaba útil 00:39:12
Vale, pues esto era 00:39:15
Get input o algo así, ¿no? 00:39:24
Get 00:39:29
Del properties 00:39:29
No, lo add, ¿verdad? 00:39:32
Con este cargábamos un input string 00:39:34
Y el input string 00:39:36
Como esto está en recursos 00:39:38
no podemos hacer un FileInputString 00:39:39
tal cual, bueno podemos hacer un FileInputString 00:39:42
pero tenemos que poner toda la ruta 00:39:44
del proyecto, entonces 00:39:45
hombre, es feo porque entonces 00:39:47
le estamos dando una ubicación 00:39:49
del sistema de archivos 00:39:51
entonces esto podíamos sacar 00:39:53
cuando el recurso estaba en 00:39:55
resources, pues podemos 00:39:57
sacar, como resources 00:39:59
está en el path de la aplicación 00:40:01
cualquier cosa que está en el path de la 00:40:03
aplicación, podíamos convertir 00:40:05
la InputString con 00:40:07
poniendo, perdón, el nombre de la clase 00:40:09
si no lo miramos rápido en su momento cuando lo hicimos 00:40:18
el nombre de la clase en la que estoy 00:40:21
getResourcesStream 00:40:24
y aquí base de datos punto properties 00:40:26
vale, entonces 00:40:31
si yo aquí le doy un recurso a este método 00:40:44
cógeme recurso como flujo 00:40:48
conviérteme recurso a flujo 00:40:51
si yo a este método 00:40:52
le doy 00:40:55
algo que esté en el path 00:40:57
tiene que estar en el path 00:40:59
y esto está porque cuando el proyecto se pasa a hard 00:41:00
la carpeta resurfe se va al path automáticamente 00:41:03
si yo le doy algo que está en el path 00:41:05
de ahí me saca 00:41:08
un input string, que es justo lo que 00:41:09
necesita prod 00:41:11
a través de load para ahora ya sacar las propiedades 00:41:13
claro 00:41:15
y este método lo llamas 00:41:17
para la clase en la que 00:41:19
lo estás haciendo, o sea, la que sea 00:41:21
como estoy en esta, en esta 00:41:23
vale, y ahora ya 00:41:24
podemos poner aquí las tres cosas 00:41:27
prop.getproperty 00:41:29
url 00:41:34
aquí lo mismo 00:41:38
y aquí 00:41:47
lo mismo 00:41:58
pero no igual 00:42:00
user 00:42:02
y password 00:42:05
la verdad es que 00:42:11
Me está 00:42:12
Doliendo en el alma 00:42:14
Aquí, bueno, para que el compilador 00:42:17
Se calle 00:42:20
Con este de aquí 00:42:20
Y ya está, ya tengo la conexión 00:42:22
Que se la paso a este y se acabó 00:42:27
A ver, lo que me está doliendo aquí en el alma 00:42:29
Eh, 10 y 20 00:42:32
Joder 00:42:34
Vale 00:42:36
Lo que me está doliendo 00:42:37
Ah, no, que hoy 00:42:39
Ay, perdón, es que no es martes hoy, hoy es jueves 00:42:41
vale, vale, nos queda otra hora 00:42:44
y la de después, hemos consumido 00:42:46
una solo, vale, vale, vale 00:42:48
ya decía yo 00:42:49
Andrea, ¿por qué me miras así? 00:42:50
primero no me llamó Andrea 00:42:54
perdón, Ana 00:42:55
no sé, es que me mirabas como con desconfianza 00:42:57
vale, vale 00:43:00
no, es que has dicho 00:43:02
como que solo hemos terminado la hora 00:43:06
como que solo te quedas en mucho contenido 00:43:07
bueno, claro, queda 00:43:09
es que de repente he dicho, uy, han pasado ya dos horas 00:43:11
porque creía que estábamos a martes 00:43:14
pero no estamos a lunes 00:43:15
Llevo tres noches 00:43:16
prácticamente sin dormir, así que 00:43:21
tenéis que disculparlo todo 00:43:23
Vale, entonces 00:43:24
lo que decía es que me está doliendo aquí en el alma 00:43:26
y en el corazón 00:43:29
el haber hecho este chorizongo 00:43:29
aquí dentro del main, esto de verdad 00:43:33
que feo, tendríamos que haber 00:43:35
hecho una clase, que me permita 00:43:37
aquí con el red conectio sacar la conexión 00:43:39
una clase singleton 00:43:40
¿Qué menos? 00:43:42
es que esto, no tardamos nada en hacerlo 00:43:44
pero por favor, que menos, es que esto 00:43:46
me duele en el alma subir este proyecto a la 00:43:48
virtual así, pues eso 00:43:50
vamos a hacer, hombre, di que sí 00:43:54
oye, pues así le va a ir 00:43:55
bien 00:44:00
no sé yo, eh, venga, ¿a dónde vamos 00:44:00
la utilidad del no sé qué, del 00:44:08
conexión, de implementación 00:44:10
del service 00:44:12
Vamos a hacer otro paquete 00:44:13
Si será por paquetes 00:44:17
A ver, porque hemos puesto 00:44:20
Una base de datos coches de caca 00:44:24
Que solo tiene una tabla 00:44:25
Si tuviera muchas, cada paquete 00:44:27
Tendría un montón de clases 00:44:30
Un DAO por cada clase y tabla 00:44:31
No, no, no, por cada fila 00:44:34
No, por cada clase, por cada tabla 00:44:35
No, no, no, no 00:44:37
No, los paquetes serían los mismos, 00:44:42
pero cada paquete tendría más clases. 00:44:44
Eso, el DAO tendría un montón de clases. 00:44:46
El service tendría uno por tabla también. 00:44:50
Pues venga. 00:44:54
Sí, claro. 00:44:59
Sí, sí, sí. 00:45:00
Entonces, me he hecho un paquete con él. 00:45:01
No me gusta el nombre, muy feo. 00:45:03
Pero bueno. 00:45:05
Y ahora aquí nos vamos a hacer nuestra clase singleton. 00:45:06
Justo. 00:45:11
Pero veis, veis como la memoria se os va desarrollando 00:45:12
Claro, es que no es fácil 00:45:14
Acordarse de 00:45:16
Ya, pero es que útil es tan genérico 00:45:17
Ahí, es que no sé 00:45:23
No acabo de encontrar yo los nombres bonitos 00:45:28
Pero bueno 00:45:31
Pase usted 00:45:32
Sí 00:45:35
Clase Singleton para obtener la conexión 00:45:36
Sí, a un momento, un momento, pero lo copiamos bien 00:45:42
Clase singleton para obtener la conexión 00:45:46
Joder, no es que no atino ni con el este 00:45:51
Este 00:45:54
Vale, entonces la clase singleton 00:45:55
Su propiedad va a ser la conexión 00:45:58
¿Vale? Va a ser esta 00:46:02
Que inicialmente es null 00:46:03
Vale, y ahora esta clase singleton 00:46:06
Tendrá su getConnection 00:46:15
Su método 00:46:17
Su método 00:46:18
Get 00:46:25
Connection 00:46:26
Y ahora, este método es el que ya se asegura 00:46:28
Si es la primera vez 00:46:32
Que me llamas 00:46:33
Es decir 00:46:34
Si connection es igual a null 00:46:36
Entonces 00:46:39
Ahora ya sí que sí 00:46:41
Hay que hacer todo el mondongo ese del otro lado 00:46:42
Ese 00:46:45
Solo que hay que pasarle 00:46:47
Otro string 00:46:48
Sí, sí, sí 00:46:49
Pero ahora lo hacemos, a ver, ¿dónde estamos? 00:46:52
¿El main? ¿Dónde está el main? 00:46:54
He cerrado el main, ¿verdad? 00:46:57
He cerrado el main 00:46:58
Ah, no, es que era 00:47:02
Ah, es que se llama ventas app 00:47:03
Vale, vale, vale 00:47:04
Vale, pues entonces, todo este rollo patatero 00:47:06
Todo esto 00:47:09
Lo vamos a quitar de aquí 00:47:11
Ahora este ya está un poco más bonito 00:47:14
Porque es que era horroroso 00:47:16
No sé cómo no habéis dicho nada 00:47:17
Vale 00:47:19
Es que lo hemos pensado 00:47:21
Sois la generación de la de 00:47:22
Que me lo den todo, de hecho 00:47:24
A mí me vale todo 00:47:26
Claro 00:47:28
Entonces ahora 00:47:29
Aquí 00:47:31
Con igual a null 00:47:34
GetConnections 00:47:36
Y con es igual a null 00:47:39
La creo con todo este rollo que he hecho aquí 00:47:40
vale, a ver un momentito 00:47:51
que lo repase, hace la conexión 00:47:53
y ahora 00:47:55
ya, y ahora yo tengo mi else 00:47:56
de leave, entonces si es 00:47:59
null, la crea 00:48:01
vale 00:48:02
y si no 00:48:03
y si no nada 00:48:05
es decir, me falta aquí un return 00:48:08
con, y se acabó 00:48:11
vale, ya está este método, entonces 00:48:12
si es null, la crea, y si no es null 00:48:16
no hace nada, y en ambos casos 00:48:18
la devuelvo a orden de parámetro, vale 00:48:20
Luego este es un singleton para asegurarse de que la aplicación solo usa una conexión, un objeto conexión, no instancia cada dos por tres. 00:48:22
Y ahora ya sí que sí, a este le llamamos con, no me acuerdo cómo se llamaba la clase. 00:48:30
Bien, muy bien, muy bien, qué rápidos estáis, de verdad, muy bien. 00:48:47
Que quite el que 00:48:50
Ah, vale, vale, vale 00:48:56
Sí, sí, sí, vale, vale 00:49:01
Muy bien 00:49:02
Creo que ahora ya está bonito, ¿verdad? 00:49:05
Vale 00:49:11
Para que no se vea 00:49:11
¡Hala! 00:49:16
Hombre, por Dios, por Dios 00:49:19
Cómo ha mejorado la cosa 00:49:21
Qué bonito 00:49:22
De verdad, qué bonito 00:49:23
Vale 00:49:25
Aún así 00:49:27
Esto 00:49:30
Este 00:49:32
No, este troncho está bien 00:49:34
Vale, iba a poner un try con recursos 00:49:41
Pero no, porque es que no queremos cerrar la conexión 00:49:44
Vale, está bien 00:49:46
Bueno, a ver, está feo, perdón 00:49:48
Porque esto debería ser un log 00:49:51
Info, log de bug 00:49:54
Pero bueno, eso ya lo dejamos para otro momento 00:49:56
Claro, debería 00:49:58
Que menos que mandar a un log, pero bueno 00:50:01
Y ya está 00:50:04
Entonces, vamos a ver 00:50:06
Si por lo menos hace la conexión 00:50:08
Y podemos crear una venta 00:50:10
Vamos a crear una venta 00:50:12
Eh, venta 00:50:15
Vamos a crear una venta 00:50:16
New venta 00:50:19
Y ahora 00:50:21
Uy, que mal 00:50:25
Venta.set 00:50:29
Coche 00:50:32
Pues que coche queremos 00:50:33
Un Renault 00:50:35
Venta.set 00:50:37
Color 00:50:41
Pues queremos un 00:50:43
White 00:50:45
Blanco 00:50:47
No nos gusta ese color 00:50:50
Entrar en conexión 00:50:52
Aquí, hemos entrado en conexión 00:50:58
Un poco más arriba 00:50:59
Pues no, en set ID 00:51:02
Nos metemos en otro berenjenal 00:51:10
Aquí es un berenjenal tras otro 00:51:11
Pero este es fácil de resolver 00:51:13
Vale, está 00:51:16
Ahora, set ID 00:51:18
¿Dónde estamos? Aquí 00:51:20
Vaya patata de aplicación 00:51:23
sería esta, o no 00:51:26
depende del contexto, si yo fijo 00:51:30
el ID por programa, por código 00:51:32
porque voy a meter la pata sí o sí 00:51:34
y voy a tener 00:51:36
porque seguro que repito IDs, porque yo 00:51:37
no puedo verificar contra la base de datos 00:51:40
continuamente que el ID es único 00:51:42
claro, entonces, ¿qué pasa? 00:51:43
que es que ese ID 00:51:47
debería ser autoincrement, que es lo que 00:51:49
hacemos normalmente, mi tabla 00:51:52
tendrá todos los campos que sean, pero yo 00:51:54
le añade un id autoincrement para en el 00:51:56
peor de los casos tener siempre una clave primaria 00:51:58
con la garantía de que es única 00:52:00
entonces vamos a 00:52:01
voy a parar esto porque si no el vídeo 00:52:03
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:
6 de diciembre de 2025 - 11:14
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
52′ 06″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
209.56 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid