Saltar navegación

20250516 IntrodBd - 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 19 de mayo de 2025 por Raquel G.

9 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, pues a lo que íbamos. 00:00:00
Esto es una pequeña contestabilización solamente para que tengáis de dónde tirar 00:00:04
y porque haréis la aplicación desde cero vosotros, claro. 00:00:07
Todos sabéis lo que es una base de datos relacional, lógicamente. 00:00:12
Es una base de datos en la que la información está estructurada en tablas, 00:00:16
donde las tablas son colecciones de registros. 00:00:20
Y ya está, cada registro es, a su vez, un conjunto de campos, 00:00:22
donde cada campo es un dato 00:00:26
de ese registro 00:00:28
que representa 00:00:31
un objeto en realidad 00:00:31
es lo que representa un registro 00:00:33
y la tabla que representa en realidad 00:00:35
una clase 00:00:38
cuando nosotros trabajamos 00:00:39
con la clase coche 00:00:41
y luego tenemos un montón de objetos 00:00:44
coche, el SEAT, el Renault 00:00:46
pues lo que tenéis es una tabla 00:00:47
coche en la que hay un montón de registros 00:00:50
el SEAT, el Renault, el no sé cuántos 00:00:53
y no sé qué, ¿verdad? 00:00:55
¿Para dar la coche a la isla a propósito? 00:00:55
Sí, porque me parece que es la... 00:00:57
Sí, pues estaba en la mesa y ya estaba en la mesa. 00:00:59
Bueno, pues entonces, 00:01:02
eso es una base de datos relacional. 00:01:04
¿Vale? Así está estructurada 00:01:10
y ya está. 00:01:12
Entonces, 00:01:14
¿cómo estructurar los datos solamente así? 00:01:15
Se queda muy pobre, pues por eso se meten claves. 00:01:17
¿Vale? Claves primarias 00:01:19
que identifican de forma única 00:01:21
a cada registro, así la información es más manejable 00:01:22
y tiene una estructura un poquito más real 00:01:26
y luego como la información siempre está relacionada 00:01:29
un coche siempre pertenece a 00:01:32
una marca, la marca a su vez 00:01:34
puede pertenecer a un proveedor, lo que sea, pues por eso 00:01:38
desde cada registro podemos decir, oye y este registro 00:01:40
además tiene una información añadida que no la pongo 00:01:44
aquí porque es que me iría hasta el infinito con este 00:01:47
registro, no la pongo aquí, sino que salta aquí. Salta aquí, la añadida la tienes 00:01:50
aquí. Pues esto es lo que habéis estudiado y luego habéis hecho un lenguaje de consultas 00:01:56
para obtener la información que hay aquí, modificarla, etcétera, etcétera. Vale, pero 00:02:00
normalmente el SQL no se utiliza directamente desde un cliente de SQL en el que no hace 00:02:07
las consultas, un humano, porque entonces ese humano, pues ya con todos esos resultados, 00:02:13
tendría que manualmente 00:02:16
volcarlos a la aplicación 00:02:19
que fuera, etcétera 00:02:21
tiene sentido, lo natural es que la base de datos 00:02:22
acceda a una aplicación 00:02:25
nuestra aplicación de gestión, la que sea 00:02:27
pues esta pequeña 00:02:29
aplicación de gestión que hayáis vosotros 00:02:38
accederá, modificará 00:02:39
consultará lo que vosotros 00:02:42
decidáis 00:02:43
de esta base de datos que vosotros habéis 00:02:44
decidido, ¿vale? con dos, tres tablas 00:02:47
como mucho, relacionadas con claves 00:02:49
ajenas a ser posible, bueno, a ser posible y aunque no sea posible, ¿vale? Bueno, pues 00:02:51
entonces, la aplicación de gestión, ¿qué es? Pues una aplicación exactamente igual 00:02:57
que la que hemos hecho, una aplicación normalucha y corrientucha que tiene que, como todas las 00:03:02
aplicaciones, pues tendrá su modelo de datos con sus clases. ¿Qué va a ocurrir aquí 00:03:08
en particular? Pues que va a resultar, si esta aplicación está diseñada, va a resultar 00:03:14
que cada clase 00:03:21
cada clase 00:03:22
va a resultar 00:03:25
que tiene una tabla 00:03:28
equivalente 00:03:30
tiene sentido 00:03:33
si esta aplicación gestiona 00:03:35
coches, que otras cosas 00:03:37
habíamos hablado hace un rato 00:03:40
marcas 00:03:41
marco 00:03:43
que es la que une marcas con coches 00:03:45
bueno, concesionarios, por ejemplo 00:03:47
pues entonces 00:03:49
la aplicación que gestiona esto 00:03:51
tendrá una clase coches 00:03:54
donde las propiedades 00:03:56
serán los campos del coche 00:03:57
tendrá una clase 00:03:59
marca 00:04:01
donde cada propiedad 00:04:02
será cada uno de los campos de esa tabla 00:04:07
¿verdad? 00:04:10
pero no 00:04:10
en Java no tiene sentido que exista la tabla Marco 00:04:11
la relación de muchos a muchos 00:04:14
O sea, que decís una tabla que está hecha para hacer una relación de muchos a muchos, ¿no? 00:04:19
No, es de 1 a 1 00:04:24
O de 1 a 1, vale, de muchos a muchos o de 1 a 1 00:04:27
No, ahí no, porque la información se va a representar de otra manera 00:04:31
Ahora mismo vamos a imaginar, ahora mismo solamente, el escenario de que las claves 00:04:35
Sí, que las claves son de 1 a muchos 00:04:39
Vamos a poner el escenario de 1 a muchos ahora mismo 00:04:43
Un coche pertenece a una marca 00:04:46
Pero una marca 00:04:49
Tiene muchos coches 00:04:51
Entonces esta sería de uno a muchos 00:04:52
Justo 00:04:54
Aquí también sería de uno a muchos 00:04:56
Porque un concesionario tiene muchos coches 00:04:58
No sé cómo será vuestra tabla 00:05:01
Pero imagino que será así 00:05:02
Y un coche pertenece a un solo concesionario 00:05:03
Suponemos 00:05:06
Bueno pues entonces 00:05:07
Esto 00:05:08
Una vez que tengáis 00:05:10
Vuestras tablas decididas 00:05:12
porque lo primero 00:05:15
que uno modela cuando hace una aplicación 00:05:16
es esto 00:05:19
eso es lo primero, los datos 00:05:20
que estará normalmente en una base de datos 00:05:23
relacional, si está en una base de datos de otro tipo 00:05:25
pues lo modela como sea esta base de datos 00:05:27
pero esto es lo primero, el punto de partida 00:05:29
es esto, mis datos son estos 00:05:31
¿dónde van a estar guardados? 00:05:33
una base de datos, esta base de datos 00:05:34
¿cuál es su mejor diseño? 00:05:36
para guardar esta información de forma 00:05:39
consistente, coherente, manejable 00:05:40
escalable, de forma que si yo incorporo 00:05:43
un dato nuevo, no tenga que hacer 00:05:45
aquí una remodelación de todas las tablas 00:05:47
entonces lo primero es hacer un buen diseño 00:05:49
de la base de datos 00:05:52
y cuando ya esa base de datos 00:05:53
está, uno ya va 00:05:55
a la aplicación, la aplicación es la segundona 00:05:57
si no hay datos, la aplicación no 00:05:59
existe y tiene ningún sentido 00:06:01
bueno, pues en este caso, como he hecho una relación 00:06:03
de muchos a uno 00:06:05
aquí como lo ponéis, un coche 00:06:06
tiene una sola marca, lo ponéis así 00:06:09
o al revés 00:06:11
y un 00:06:12
y esto también así, ¿no? 00:06:14
Un coche, un concesionario 00:06:18
que tiene muchos coches. 00:06:20
Pues entonces, en una situación como esta, por ejemplo, 00:06:21
¿lo he puesto al revés? 00:06:24
No, creo que es el elemento. 00:06:25
Porque un coche puede estar en más de un concesionario. 00:06:27
Ah, bueno, vale, pero vamos a nosotros, ahora mismo, 00:06:29
como estamos con el ejemplo de uno a muchos, 00:06:31
vamos a suponer que un coche está en un concesionario 00:06:34
solamente, en uno solo. 00:06:35
Bueno, pues vosotros una vez que tenéis elegida 00:06:37
vuestra base de datos, 00:06:39
ahora ya hacéis el diseño de la aplicación 00:06:40
y claro, el diseño de la aplicación 00:06:44
siempre parte de primero 00:06:45
las clases, como siempre 00:06:48
lo que pasa es que ahora, en lugar de hacer las clases 00:06:49
como las hacíamos nosotros, que era pensando 00:06:52
directamente en la realidad 00:06:53
y en representarla, pues ahora 00:06:55
es que lo tenemos más fácil, porque ahora nuestras 00:06:57
clases van a mapear, tienen que mapear 00:06:59
directamente estas tablas 00:07:01
entonces eso, se puede 00:07:03
hacer a mano 00:07:05
o en función del framework 00:07:06
de acceso a base de datos que se utilice 00:07:09
que nosotros ahora en este trabajo no vamos a utilizar 00:07:11
lógicamente, pues 00:07:13
se te lo cuenta derecho 00:07:14
se te monta automáticamente 00:07:17
no, no, no 00:07:20
bueno, sí, se te puede 00:07:22
incluso montar si tú haces, bueno 00:07:23
digamos que todo esto es muy complejo 00:07:25
pero que se te 00:07:27
tú puedes 00:07:29
porque es verdad, tú puedes saber 00:07:31
tú puedes tener un escenario en el cual 00:07:33
tú has pensado primero tu modelo de clases 00:07:35
y luego dices, y ahora quiero una base de datos 00:07:37
que encaje con este modelo de clases 00:07:40
también lo puedes generar automáticamente 00:07:41
no tienes que... 00:07:44
todo esto es muy interesante 00:07:45
claro, pero cuando hablo de generar automática 00:07:48
y todo eso, siempre está 00:07:50
el humano por encima 00:07:51
que tiene que verificar que todo eso 00:07:53
tiene algún sentido 00:07:56
porque claro, las cosas que generan 00:07:57
los frameworks, luego hay que irlas cogiendo 00:08:00
un poquito con pinzas, luego estará el humano 00:08:02
por encima, o dentro de 4 o 5 años 00:08:04
el robocito 00:08:06
que lo haga mientras vosotros estáis en el sofá 00:08:08
esperemos que en lugar 00:08:11
de en paro, controlando el robocito 00:08:13
esperemos 00:08:15
eso dependerá de vosotros 00:08:16
de lo que os hayáis 00:08:19
adaptado al sistema 00:08:21
bueno, pues entonces 00:08:22
sí, de lo que el sistema 00:08:24
haya permitido que nos adaptemos 00:08:27
pero bueno, vuestra parte tenéis que interhacerla 00:08:29
esperemos que sea suficiente 00:08:31
vale, bueno, pues entonces en nuestro caso 00:08:33
hora en particular, la base de datos 00:08:35
es lo primero que haréis. Y ahora ya tenéis que 00:08:37
hacer las clases. Bueno, pues en este caso 00:08:39
habrá una clase coche. 00:08:40
La clase coche pues tendrá 00:08:43
todas las propiedades 00:08:45
que tiene 00:08:48
cada registro de coche. Tantas propiedades 00:08:50
como campos. Pero ¿qué ocurrirá? 00:08:53
Que uno de esos campos 00:08:55
resulta que es una clave 00:08:57
ajena. Entonces, ¿eso qué 00:08:59
significa? Que el coche 00:09:01
tiene una marca asociada 00:09:03
que tiene un montón de información. Luego esta propiedad en realidad 00:09:05
es una propiedad objeto, porque 00:09:09
a su vez tiene dentro un montón de información. Luego cada vez que 00:09:13
hay una clave ajena, la propiedad correspondiente dentro de la clase 00:09:17
coche será a su vez un objeto. Es decir, tendrá 00:09:21
las propiedades primitivas normales de aquí y luego tendrá 00:09:25
una propiedad marca. 00:09:28
y esta propiedad es la que representa 00:09:30
el hecho de que aquí hay un campo 00:09:36
que me conduce a un registro entero 00:09:39
con un montón de propiedades 00:09:42
y lo mismo pasará con concesionarios 00:09:44
habrá otra clave ajena por aquí 00:09:49
que lleve a concesionarios 00:09:51
entonces eso significará que el coche tiene dentro 00:09:53
algo que tiene un montón de información 00:09:57
luego tiene dentro un objeto 00:10:00
luego significará esto 00:10:02
vale, pues con estas 00:10:04
directrices, lo otro ya podéis hacer 00:10:08
diseñar vuestras clases 00:10:10
luego ya vendrá el problema 00:10:11
el siguiente problema 00:10:14
que es, vale, pero cuando yo hago, cuando vos hacéis una consulta 00:10:16
de SQL 00:10:18
vosotros sacáis directamente 00:10:18
aunque hagáis un inner join 00:10:21
hagáis una multita, hagáis lo que sea 00:10:24
lo que saquéis es una colección de campos 00:10:25
¿qué va a tocar hacer 00:10:27
luego por código? 00:10:30
pues de esa colección de campos 00:10:31
que habéis obtenido con el SQL 00:10:33
separarlos, los que sean 00:10:35
de marca, construir un objeto 00:10:37
con ellos e instanciarlo 00:10:39
para meterlo a la propiedad de coche 00:10:41
los que sean de concesionario 00:10:42
extraerlos 00:10:44
e instanciar con ellos un objeto concesionario 00:10:47
para meterlo a la propiedad de coche 00:10:49
el resto de campos ya los metéis aquí 00:10:51
con eso ya se puede instanciar un coche, etc. 00:10:53
entonces todo eso es 00:10:56
trabajoso, porque tú tienes 00:10:57
simplemente unos datos ahí que has sacado 00:11:00
una consulta, un montón 00:11:01
y con ellos tienes que ir instanciando objetos 00:11:02
para reproducir ya tu objeto 00:11:06
coche, ¿vale? 00:11:07
Y todo esto ya casi lo hice a principio de curso 00:11:09
cuando estaba haciendo el videojuego 00:11:11
y todo este tipo de cosas 00:11:13
lo que no hice es la base de datos como tal, pero me la hice a mano 00:11:15
Pues más fácil 00:11:17
Vale, pues entonces así es como se trabaja 00:11:19
Entonces esto, si uno lo hace 00:11:21
a mano, que es como nosotros lo vamos a hacer ahora 00:11:23
tiene el máximo control 00:11:25
de la aplicación, entonces esa va a ser nuestra forma 00:11:27
a hacerlo ahora, que es con la capa base 00:11:29
que es la que se llama JDBC 00:11:31
de la que ahora vemos rápidamente 00:11:33
las directrices para que busquéis a través de ella 00:11:35
y ya está, JDBC, vale 00:11:37
pero claro, si uno tuviera que hacer una aplicación enorme 00:11:39
gigante, siempre así a mano 00:11:41
con JDBC 00:11:43
pues perdería una cantidad de tiempo 00:11:44
entonces por eso es por lo que se van poniendo capas adicionales por encima 00:11:47
es decir, frameworks o clases 00:11:49
que uno importa 00:11:52
que te esconden esta complejidad 00:11:53
tú configuras 00:11:56
ciertas cosas de ellas, configuras 00:11:58
que no es sencillo configurarlas 00:12:00
y luego le dices, oye, sácame un coche 00:12:02
de la base de datos 00:12:04
y esa herramienta que tú has configurado 00:12:05
es la que te hace el SQL 00:12:08
tú ni ves SQL ni nada, el SQL no lo ves jamás 00:12:10
sácame un coche 00:12:12
entonces, esa herramienta 00:12:14
por dentro te hace 00:12:16
el SQL, te saca 00:12:18
todo lo que haga falta, te construye 00:12:20
los objetos, te los instancia 00:12:22
y te da el objeto coche ya hecho, tú le dices 00:12:24
oye, herramienta, dame un coche 00:12:26
con el ID tal 00:12:28
y te da el coche, que tiene dentro la marca 00:12:29
tiene dentro todo 00:12:31
pero primero, configurarla 00:12:32
para que realmente entienda 00:12:35
donde está cada parte 00:12:37
del coche, no es fácil 00:12:39
hay que hacerlo bien 00:12:41
y segundo, pierdes un poco el control 00:12:42
porque si tú haces el SQL directamente 00:12:45
a lo mejor consigues 00:12:47
una aplicación de mejor rendimiento 00:12:49
porque la base tradicional es 00:12:51
estructurar la información de manera muy 00:12:53
gráfica y todo muy bonito 00:12:55
pero estas son pesadísimas 00:12:56
un sistema gestor de base de datos 00:12:59
es súper pesado 00:13:01
muchas veces es el cuello de botella de una aplicación 00:13:02
eso, el sistema gestor de bases de datos 00:13:05
por eso es por lo que se han incorporado 00:13:07
bases de datos no relacionales 00:13:09
al mercado 00:13:11
para intentar que dejen de ser el cuello de botella 00:13:12
de las aplicaciones 00:13:15
pero claro, como esto está tan desarrollado 00:13:16
está ya tan currado, tan trabajado 00:13:18
pues siguen siendo todavía 00:13:20
normalmente 00:13:22
las que se usan en la mayoría de aplicaciones 00:13:24
pero son muy pesadas 00:13:25
aunque sean los que más se usan 00:13:29
son muy pesadas 00:13:31
entonces, ¿qué es lo que estaba diciendo? 00:13:32
que usar esa herramienta, ese framework que digo 00:13:35
aparte de la dificultad de configurarlo 00:13:37
pierdes el control de la aplicación 00:13:39
porque ella hace el SQL que Dios le da a entender 00:13:41
tú no controlas como lo está haciendo 00:13:43
y no digo puede ralentizar 00:13:45
no, ralentizan 00:13:47
ralentizan una barbaridad la aplicación 00:13:49
pero bueno, una aplicación comercial normal 00:13:51
pues hombre 00:13:53
tampoco 00:13:54
eso tiene por qué ser un problema 00:13:55
entre esperar un milisegundo 00:13:58
a que te den la respuesta de tu venta 00:14:00
y esperar un milisegundo y medio 00:14:02
pues bueno, tampoco es crítico 00:14:03
¿vale? 00:14:05
depende del contexto 00:14:06
si es una aplicación pequeña, pues sí 00:14:11
¿vale? por ejemplo, vosotros no os acordaréis 00:14:13
pero el chico que vino aquí 00:14:16
a principio de curso y os contó un montón 00:14:18
de cosas de lo que hacía, en algún momento mencionó 00:14:20
y dijo, en esta parte de la aplicación 00:14:22
estoy haciendo directamente 00:14:24
JDBC, pues se refería a esto 00:14:26
que estaba haciendo directamente desde la aplicación 00:14:27
las consultas SQL, la reconstrucción 00:14:30
de los objetos y todo eso 00:14:32
pero no es lo habitual 00:14:33
lo habitual es que una aplicación grande 00:14:36
se haga con otra capa por encima 00:14:37
que es esa herramienta que os digo 00:14:39
que es en Java 00:14:41
y en muchos otros lenguajes 00:14:44
es esta, es la que se usa prácticamente siempre 00:14:45
por si os suena de nombre 00:14:48
y luego normalmente encima de esta capa 00:14:51
Como esta es tan pesada de configurar, pues desde hace ya bastante tiempo se le ha puesto otra capa por encima, que es la capa que se llama Sprint. 00:14:53
Sprint es una bolsa enorme donde cabe de todo, una bolsa enorme que vale para todo, pero parte de para lo que vale es para ponerse por encima de Ibernate en teoría para facilitarnos las cosas. 00:15:07
pero de nuevo sprint es relativamente 00:15:20
complicado de configurar, conclusión 00:15:23
uno puede llegar a una situación en la cual 00:15:25
hacer un simple select 00:15:27
para sacar un coche 00:15:29
que en JDBC 00:15:30
son cuatro líneas de código 00:15:32
pues se puede 00:15:34
si tú le pones toda la arquitectura 00:15:37
de JDBC que es hacerlo a mano 00:15:39
por encima de esto, por encima de esto 00:15:41
le pones toda la arquitectura 00:15:43
tienes una aplicación de mil 00:15:44
dos mil clases 00:15:47
que están ocultando 00:15:48
en realidad un único select 00:15:50
es lo único que están ocultando 00:15:52
entonces claro, si la aplicación te hace un select 00:15:53
pues no pones todas estas capas 00:15:55
pero si la aplicación es una aplicación de gestión 00:15:57
que te hace un montón de cosas con la base de datos 00:16:00
y encima tu intención es que vaya escalando 00:16:02
y cada vez haga más cosas 00:16:04
pues entonces sí que montas 00:16:06
esta arquitectura desde el principio 00:16:08
porque sí que te va a facilitar el incorporar 00:16:09
nuevas funcionalidades y todo eso 00:16:12
porque una vez que la tienes configurada 00:16:13
ya está, el meterle funcionalidades nuevas es inmediato 00:16:15
el problema es la configuración de partida 00:16:18
y tener toda la arquitectura que te funcione 00:16:20
y ahí 00:16:22
ahora mismo, chat GPT no es de mucha ayuda 00:16:23
¿vale? porque chat GPT 00:16:26
pues bueno, no 00:16:29
casa las versiones 00:16:30
porque aquí sobre todo es, si pongo esta versión 00:16:32
esta no funciona, tengo que buscar otra 00:16:34
entonces chat GPT es de ayuda 00:16:35
para saber por dónde van ciertos tiros 00:16:38
pero en estas cosas no es de mucha ayuda 00:16:40
¿vale? entonces 00:16:42
no vamos a montar la arquitectura 00:16:44
nosotros ahora, la montaremos el año que viene 00:16:45
simplemente en vuestro 00:16:48
trabajito de ahora vais a hacer 00:16:50
esto que os he dicho a mano 00:16:52
y hacerlo a mano 00:16:53
significa hacerlo con esto 00:16:55
de aquí, ¿vale? 00:16:58
entonces palabra clave de la que tenéis que tirar 00:16:59
para hacer vuestro trabajito 00:17:01
bueno, está claro hacer la base de datos 00:17:03
la aplicación Java con el modelo de datos 00:17:05
pues 00:17:07
ya sabéis las directrices para hacerlas 00:17:08
si hay claves ajenas 00:17:12
bueno 00:17:13
las directrices apenas hemos dado 00:17:15
porque hemos dado en la clase coche 00:17:17
pero que pasaría en la clase 00:17:19
marcas por ejemplo 00:17:21
la clase marca 00:17:23
que está en el extremo 1 00:17:25
la clase marca pues tendría 00:17:27
todas las propiedades 00:17:30
de aquí y ya está 00:17:32
y no tiene más todas sus propiedades 00:17:33
pero que le pasa a marcas 00:17:35
que como tiene una clave ajena 00:17:37
marcas en realidad 00:17:39
tiene un montón de coches dentro 00:17:41
aquí esa información no está 00:17:43
aquí solamente están las propiedades de la marca 00:17:45
pero nosotros sabemos 00:17:47
porque tenemos la visión de toda la base de datos 00:17:49
nosotros sabemos que hay un montón 00:17:51
de coches, un montón que están tirando 00:17:53
de ella, hay un montón 00:17:55
entonces, ¿eso cómo se debería reflejar 00:17:57
en la base de datos? 00:18:00
pues como una colección 00:18:02
efectivamente, como una colección 00:18:03
de coches 00:18:05
Entonces, cuando hay una clave ajena 00:18:06
Si en coche 00:18:14
Hay un objeto marca 00:18:15
Y es una clave de uno a muchos 00:18:17
En marca habrá una colección de coches 00:18:21
En una clave de uno a muchos 00:18:23
¿Vale? 00:18:24
Otra cosa es que nos interese rellenarlos 00:18:28
A lo mejor queremos 00:18:30
Obtenme los datos de la marca 00:18:32
Pero no nos interesan los coches 00:18:36
Pues hacemos simplemente el select 00:18:37
de los datos y rellenamos los campos de arriba 00:18:39
y este no le rellenamos 00:18:42
no tenemos por qué 00:18:44
porque para rellenar este 00:18:45
hay que seguir anidándosele aquí 00:18:47
hacer las subconsultas que sean 00:18:49
para sacar todos los coches 00:18:52
que llevan a la marca 00:18:53
de la que yo estoy haciendo sele 00:18:55
de irlo rellenando aquí 00:18:57
entonces por ejemplo 00:18:58
las herramientas esas que os digo 00:19:00
si yo le digo sacame una marca 00:19:02
solo te hacen las subconsultas 00:19:05
de la tabla de la que tira 00:19:07
para además rellenar los coches 00:19:09
si ven 00:19:11
que tú vas a usar ese dato 00:19:13
si no vas a usar ese dato 00:19:14
porque solamente vas a usar estos de arriba 00:19:17
esta no la rellena 00:19:19
solo la rellena si tú lo vas a usar 00:19:20
entonces, esos son los tipos de cosas que hay que configurar 00:19:22
etcétera 00:19:25
entonces, aunque el modelo de datos real 00:19:26
sea este 00:19:29
luego cuando vosotros hagáis las funcionalidades 00:19:30
de recupera 00:19:32
la marca que tiene más coches 00:19:34
ahí sí que 00:19:37
os rellenaríais esto, porque luego haríais el máximo 00:19:38
de la que tiene 00:19:41
la lista esta más larga 00:19:42
o recupérame las marcas para enseñarme 00:19:44
cuáles son, pues ahí no 00:19:47
os recuperaríais esto, porque esta información no interesa 00:19:49
y es un rollo 00:19:51
¿vale? haríais el select de los datos 00:19:52
los pondríais aquí y ya está 00:19:55
y nos recorreríais las marcas y se acabó, este link no os hace 00:19:56
falta para nada 00:19:59
lo único que digo es que 00:20:00
que existan aquí estas propiedades 00:20:02
representa esta clave 00:20:04
ajenas, lo que la representa. Y lo que decías tú, cuando hay una clave de uno a uno o de 00:20:07
muchos a muchos. Una clave de uno a uno o de muchos a muchos se hace con una tabla adicional. 00:20:13
Y esa tabla, efectivamente, no es una entidad propia. Por ejemplo, esta, imaginaos que esta 00:20:19
la cambiamos de muchos a muchos. Entonces, ahora ya necesitamos otra tabla, coche, concesionario, 00:20:26
lo que sea 00:20:34
necesitamos otra tabla 00:20:34
que representa 00:20:38
que un coche puede pertenecer a muchos 00:20:40
concesionarios y que un concesionario 00:20:43
puede tener muchos coches 00:20:45
o algo así 00:20:47
¿vale? 00:20:47
entonces 00:20:54
ese hecho 00:20:55
de que un coche 00:20:57
puede tener muchos concesionarios y al revés 00:20:59
ese hecho 00:21:00
en las clases es mucho más fácil 00:21:04
no tenemos que hacer efectivamente 00:21:07
una clase para esta 00:21:09
no hay que hacerlo 00:21:11
simplemente eso como se representa 00:21:12
pues 00:21:15
si este es el concesionario 00:21:17
claro, se pone una lista en ambos 00:21:21
y este es el coche 00:21:24
pues este tendrá 00:21:26
una lista de concesionarios 00:21:28
y este tendrá 00:21:30
una lista de coches 00:21:32
ah, porque eso es de muchos a muchos 00:21:33
Claro, porque es de muchos a muchos. 00:21:36
¿Qué es de uno a uno? 00:21:38
Un objeto aquí y un objeto aquí. 00:21:39
Y ya está. 00:21:41
Y se acabó. 00:21:42
Más los guetes y los setes, tu stream, lo que haga falta. 00:21:44
Entonces, hacer las clases que representan eso es fácil. 00:21:48
¿Vale? 00:21:53
Luego ya, uno ya hace las funcionalidades que le toca hacer. 00:21:55
Que las que seleccionéis. 00:21:59
Pues, mostrar la película que más se ha visto. 00:22:01
las tres, cuatro 00:22:04
digamos tres, cuatro funcionalidades 00:22:07
de centillas, ¿vale? 00:22:09
si haces 20.000, pues 20.000 00:22:10
¿eh? 00:22:12
pues desarrollalas 00:22:16
así no te aburres 00:22:17
en casa 00:22:19
y no juegas tanto a videojuegos 00:22:20
¿no? ¿te puedes hacer esto? 00:22:22
¿qué tiene malo? 00:22:24
bueno, nada, pero todo el rato 00:22:26
o sea, hacer algo todo el rato 00:22:27
si tiene algo de malo 00:22:29
menos 2000, eso es estupendo 00:22:31
Vale, entonces vosotros ahora ya 00:22:33
Seleccionáis las funcionalidades que queráis hacer 00:22:38
¿Vale? 00:22:40
Y esas funcionalidades 00:22:41
Pues por ejemplo, las podéis recoger 00:22:43
En una clase 00:22:46
En los métodos correspondientes 00:22:49
Para que luego ya 00:22:51
Vuestra interfaz gráfica 00:22:53
Los llame cuando le hagan falta 00:22:54
Entonces podéis hacer una clase 00:22:56
Pues de como la queráis llamar 00:22:58
Tienen un 00:23:00
Estas clases tienen un nombre específico, pero bueno, dentro de una arquitectura más completa, que ya veremos el año que viene, ahora mismo la podéis llamar como queráis, funcionalidades o como sea. 00:23:02
Y ahora, esta clase, pues tendrá los métodos, vamos a ponerlos, por ejemplo, estáticos, para que se llenen fácilmente. 00:23:13
Y aquí lo que seleccionéis, pues por ejemplo aquí, consultar concesionario con más coches. 00:23:22
entonces, este método 00:23:28
el concesionario con más coches 00:23:30
tendría como valor de retorno 00:23:32
un objeto concesionario 00:23:34
el nombre que fuera 00:23:36
y este en particular no tendría datos 00:23:39
de entrada, este método 00:23:42
se devolvería al concesionario con más coches 00:23:44
lo que sea 00:23:46
por ejemplo, recuperar 00:23:46
los datos de un coche, pues ese método 00:23:50
se le pasaría la clave primaria 00:23:52
lo que hayáis seleccionado para el coche 00:23:55
y te devuelve un objeto coche 00:23:56
con todos sus datos rellenos 00:23:57
pues lo que vosotros seleccionéis 00:24:00
mostrar el concesionario 00:24:02
los concesionarios en los que puedo comprar un coche 00:24:06
pues entonces ese método devolvería 00:24:08
una lista 00:24:10
de objetos concesionario 00:24:13
y se le pasaría un ID del coche 00:24:14
entonces eso es, coges el coche 00:24:15
si has mapeado ya la lista 00:24:18
de su propiedad lista, la devuelves 00:24:20
y ya está, lo que seleccionéis 00:24:22
más o menos 00:24:24
¿Vale? Bueno, pues el asunto es que una vez ya seleccionado las funcionalidades que vais a hacer, ahora ya el código de dentro, ese ya sí que sí, tiene que hacer algo para ejecutar el SQL con la base de datos. 00:24:25
Ahora ya sí que llegamos a, vale, ¿y cómo hago yo una consulta SQL desde Java? Ahora ya sí que sí hay que hacer una consulta SQL desde Java. 00:24:41
Vale, pues estamos ya en el método que sea y este método tiene que entenderse con la base de datos para ejecutar SQL y en el caso de que sea una consulta, recoger los resultados, porque si es un insert, un delete, no hay nada que recoger, pero si es una consulta, pues además tiene que recoger. 00:24:51
ya llegamos al punto en el que hay que ejecutar SQL 00:25:21
vale, pues aquí tenemos 00:25:23
el problema 00:25:25
de que esto es Java 00:25:26
y esto es la base de datos que sea 00:25:28
Oracle 00:25:31
MySQL 00:25:33
SQLite, Postgre, la que sea 00:25:34
¿vale? podéis seleccionar 00:25:37
la base de datos que queráis 00:25:39
en realidad la forma de trabajar es 00:25:40
igual con todas 00:25:43
¿y si lo ponemos en la relación? 00:25:44
no, no, no 00:25:46
No, con las relacionales no. 00:25:47
¿Vale? 00:25:50
Con las relacionales no. 00:25:52
Estamos, nosotros se supone que vamos a hacer el trabajo con las relacionales. 00:25:54
¿Vale? 00:25:57
Bueno, seleccionéis la que os dé la gana. 00:25:57
¿Vale? 00:26:00
Entonces, ¿cuál es el problema? 00:26:00
Seleccionéis la que seleccionéis. 00:26:02
Esto habla chino y esto habla japonés, con lo cual no se parece absolutamente nada. 00:26:04
¿Verdad que no? 00:26:10
¿A que no se parecen en agua? 00:26:11
A que no se parecen en agua. 00:26:12
¿Por qué? 00:26:13
Porque en el agua hay calles criminales. 00:26:13
ya, pero un chino y un japonés 00:26:15
no se entienden entre ellos ni de lejos 00:26:19
claro 00:26:21
por ejemplo 00:26:22
como un andaluz y un gallego 00:26:25
tampoco se entienden 00:26:27
pues, entonces, ¿qué necesitamos? 00:26:28
necesitamos un traductor 00:26:32
no hay más remedio 00:26:33
hace falta un traductor 00:26:35
entonces el traductor 00:26:37
tiene que saber Java 00:26:39
y tiene que saber 00:26:41
la arquitectura interna 00:26:43
con la que está desarrollado esto 00:26:45
entonces, ese traductor 00:26:46
ese traductor 00:26:50
son clases de Java 00:26:52
son clases de Java 00:26:54
que son capaces, que están construidas 00:26:55
para saber hablar el idioma Java 00:26:57
y este otro, entonces esas clases de Java 00:26:59
no están en la máquina virtual de Java 00:27:01
pues la máquina virtual de Java no puede tener traductor 00:27:03
en falta de la base de datos del mundo 00:27:05
la máquina virtual de Java no tiene nada de eso 00:27:06
entonces 00:27:09
Entonces, para la base de datos que uno haya seleccionado, sea la que sea, tiene que buscar las clases y esas clases estarán como siempre en un punto HAB, tiene que buscar las clases que son capaces de hacer la traducción. 00:27:10
Esas clases se llaman el driver, para más en datos, el driver JDBC, porque esto que estamos nosotros hablando ahora, entra dentro de la arquitectura JDBC, que es Java Database Connectivity. 00:27:25
conectividad pues hay que buscar el driver jdbc el driver jdbc que es 00:27:39
un jar que tiene las clases que son capaces de hacer la traducción bueno pues entonces 00:27:49
como incorporamos nosotros clases nuevas a nuestra aplicación pues lo hemos hecho a veces con él 00:27:54
build path claspada 00:28:01
de external hard etc 00:28:04
estas son las cosas que tienes que refrescar o mirar 00:28:05
o preguntarle a alguien 00:28:08
que lo sepa 00:28:10
por ejemplo 00:28:12
o quien sea 00:28:15
bueno pues una vez que esas clases 00:28:15
están ya incorporadas al 00:28:18
claspad de la aplicación porque las habéis 00:28:20
agregado con ad external hard etc 00:28:22
que esas las forman 00:28:24
chapuzas 00:28:26
la forma buena es con maven con un gestor de dependencia 00:28:27
pero esa la dejamos para el año que viene 00:28:30
vamos a quedarnos con la chapuza 00:28:32
que es incorporar el hard directamente 00:28:33
¿por qué digo que chapuza? 00:28:36
porque tú llevas tu aplicación a tu ordenador 00:28:38
y la has cagado 00:28:40
porque no tira 00:28:43
o te llevas el hard a la misma ubicación 00:28:44
a ese nuevo ordenador 00:28:47
o esa aplicación te va a decir 00:28:48
oye, estás tirando de un hard que yo aquí no lo tengo 00:28:51
entonces es la forma chapuza 00:28:53
pero bueno 00:28:55
hay una forma menos chapuza 00:28:55
que es, en lugar de agregarlo 00:28:58
como addExternalHard y que el hard 00:29:00
esté en tu sistema de archivos, 00:29:02
que el hard esté dentro de tu proyecto, 00:29:04
dentro, y lo agregas 00:29:07
como addHards. Entonces, él lo agrega 00:29:08
como ruta relativa. Entonces, 00:29:10
tú mueves la aplicación enterita con el hard dentro 00:29:12
a otro ordenador. Como está agregado 00:29:14
como ruta relativa, no hay ningún problema. 00:29:16
Pero la aplicación 00:29:19
va engordando, va engordando, va engordando, va engordando, 00:29:20
porque si le metes todo el hard dentro... 00:29:22
Bueno, hay otra 00:29:28
arquitectura para hacerlo, en la que 00:29:30
no lo llevas dentro 00:29:31
sí, pero está automatizado 00:29:32
entonces al estar todo automatizado 00:29:37
tú le dices, necesito este 00:29:39
hack, es lo que dices a Maven 00:29:42
a Gravel, a esos sistemas 00:29:43
y lo único que le dices es, esta aplicación 00:29:44
necesita este hack 00:29:47
y la aplicación cuando arranca 00:29:48
sea en el equipo que sea 00:29:51
te hace toda la gestión 00:29:52
eso si hace falta internet para que la aplicación arranque 00:29:54
te lo descarga, te lo pone en un repositorio interno 00:29:57
que tú no sabes ni dónde está, ni te importa 00:29:59
y trabaja con él, entonces es transparente para ti 00:30:01
lo único que necesitas es que haya internet 00:30:03
cuando arrancas la aplicación, es la manera 00:30:05
en la que se suele hacer, pero la primera 00:30:07
vez que la arrancas, porque una vez que ya te lo 00:30:09
ha descargado un repositorio interno, las siguientes veces 00:30:11
bueno, pues 00:30:13
nosotros lo vamos a hacer así 00:30:15
buscáis el driver 00:30:16
correspondiente a la base de datos que sea 00:30:19
el driver JDBC y lo importáis 00:30:21
bueno, una vez que esas clases ya están 00:30:23
ya podemos desde 00:30:25
aquí usarlas para ejecutar el SQL 00:30:27
entonces aquí se podrían haber hecho las cosas 00:30:29
bien o mal 00:30:33
pero afortunadamente desde hace ya 00:30:33
bastante tiempo 00:30:36
desde que, no desde los comienzos de Java 00:30:37
sino desde que se dieron cuenta de que 00:30:41
esto va creciendo, creciendo, creciendo 00:30:42
y como no nos organizamos va a ser un pifoste 00:30:44
pues desde hace ya bastante tiempo 00:30:46
dijeron, vamos a ver 00:30:48
si todo el mundo va a hacer 00:30:49
accesos a bases de datos 00:30:52
aunque con diferentes 00:30:55
hard, vamos a unificar 00:30:57
la forma de hacerlo, aunque 00:30:58
tengan que usar hard distintos 00:31:00
vamos a hacer una cosa 00:31:02
vamos a meter en nuestra 00:31:04
máquina virtual, en la JRE 00:31:06
que es la que tienen todas las aplicaciones 00:31:09
todas las aplicaciones 00:31:11
tienen la JRE con clases dentro 00:31:12
pues vamos a meter 00:31:15
unas clases vacías 00:31:16
que es una, o sea con métodos 00:31:18
vacíos, que es una clase 00:31:21
con métodos vacíos, una interfaz 00:31:22
como bien sabéis 00:31:24
pues vamos a meter 00:31:25
yo que sé 00:31:28
pues por ejemplo 00:31:29
una clase que se llame 00:31:32
driver manager 00:31:34
y que esta clase te meta 00:31:36
métodos vacíos del tipo 00:31:41
crea conexión 00:31:43
no pongo el nombre del método 00:31:45
ejecuta sentencia 00:31:50
entonces 00:31:52
vacíos, entonces 00:31:55
tu aplicación que va a hacer 00:31:58
tu aplicación va a llamar a estos 00:31:59
métodos, entonces todo el mundo 00:32:02
me da igual que esté usando 00:32:04
Oracle, MySQL, todo el mundo 00:32:05
hace la aplicación de la misma manera 00:32:08
que es llamando a los métodos 00:32:11
de la interfaz, que está en la máquina virtual 00:32:12
que es una especie de paraguas común 00:32:15
que usan todos, pero claro 00:32:16
estos métodos están vacíos 00:32:18
entonces 00:32:20
estos métodos 00:32:21
se llenan 00:32:24
automáticamente con el código 00:32:26
que trae este driver 00:32:28
claro, sin que hagamos nosotros nada 00:32:29
entonces cuando tú importas 00:32:32
el driver de una base de datos 00:32:34
automáticamente 00:32:36
esta, no es que se llenen 00:32:39
es que esta clase 00:32:40
trae las implementaciones de estas interfaces 00:32:42
entonces cada driver 00:32:45
trae las implementaciones 00:32:47
los implements 00:32:49
de estas que aquí están vacías 00:32:50
pero como bien sabéis por el tema de la herencia 00:32:52
uno en su aplicación llama 00:32:55
a los métodos de la interfaz 00:32:56
y automáticamente ¿qué es lo que se ejecuta? 00:32:58
lo que se ejecuta es la implementación 00:33:01
de abajo 00:33:03
bueno, pues entonces 00:33:03
tú importas el driver 00:33:05
y ya está, y estás importando 00:33:07
la implementación, pero tú llamas a los métodos 00:33:10
que al año que viene 00:33:12
tu aplicación cambia y has cambiado de base 00:33:13
de datos, lo único 00:33:16
que tienes que cambiar es el hard 00:33:18
solo cambias el hard, no tienes que cambiar nada más 00:33:19
porque la llamada a los métodos 00:33:21
todo es igual, gracias a que 00:33:23
está todo 00:33:25
oculto, envuelto 00:33:27
en que hay una interfaz 00:33:29
es una interfaz 00:33:31
o un conjunto de interfaces 00:33:33
es lo que se llama API 00:33:34
¿vale? 00:33:36
de Application Program Interface 00:33:38
esto se llama API 00:33:41
entonces ¿qué es un API? 00:33:46
un API es un conjunto de métodos 00:33:48
para hacer algo en concreto 00:33:51
a lo que tu aplicación llama 00:33:52
tu aplicación llama a una API para hacer cosas 00:33:54
pero las APIs 00:33:57
luego alguien las tiene que implementar 00:33:58
Bueno, pues en este caso la API JDBC, porque estas clases de aquí, estas interfaces se llaman la API JDBC, pues a la API JDBC que nosotros llamamos para crear conexión, ejecuta sentencia, etcétera, etcétera, esta API la rellena por dentro este driver. 00:34:00
simplemente por el hecho 00:34:19
que importemos 00:34:21
entonces ahora vuestra tarea 00:34:22
pues aparte de hacer la base de datos 00:34:25
mapear las clases, una vez 00:34:27
seleccionadas 00:34:29
las funcionalidades que queréis 00:34:30
pues ver 00:34:33
a qué métodos y cómo 00:34:35
tenéis que llamar de esta API 00:34:37
para 00:34:39
hacer las cosas, que os adelanto 00:34:40
que es siempre la misma arquitectura 00:34:43
crear conexión 00:34:45
Para crear conexión 00:34:47
Veréis que hay que dar 00:34:50
Pues la IP donde está mi base de datos 00:34:51
El puerto en el que escuche, etc. 00:34:53
Si la base de datos está en vuestro mismo equipo 00:34:55
Pues la IP será localhost 00:34:57
Vale 00:34:59
Crear conexión 00:35:00
Ejecutar la sentencia SQL que sea 00:35:02
Para lo cual habrá que llamar a otro método 00:35:05
De esta API 00:35:07
Y luego cerrar conexión 00:35:08
Ejecutar la sentencia 00:35:10
Si ha sido un insert, un delete o lo que sea 00:35:12
Pues ya está 00:35:14
Si ha sido un seller, pues te devolverá algo y dentro de ese algo tendréis que meteros para sacarlo y ya rellenar las propiedades de los objetos. 00:35:14
Y ya está. 00:35:24
Entonces tenéis que ver cuáles son los métodos de esta API para usarlos para crear la conexión dentro de cada funcionalidad, 00:35:26
ejecutar la sentencia que toque, cerrar conexión y ya está. 00:35:36
y una vez ejecutada la sentencia, pues los datos manejarlos 00:35:41
claro, manejarlos, pero eso ya es hard 00:35:44
¿no se deja la conexión abierta hasta que vayas a terminar 00:35:45
y trabajar? 00:35:47
a ver, no es lo recomendable 00:35:50
lo normal, como 00:35:52
estas son 00:35:53
son funcionalidades atómicas, digamos 00:35:55
tú cuando las usas, creas una conexión y ya está 00:35:57
se puede hacer a veces, una cosa que se llama 00:36:00
un pool de conexiones, que es tener varias abiertas 00:36:01
para cada método 00:36:04
te selecciona una y luego la suelta 00:36:05
pues un poco para optimizar 00:36:07
la rapidez de los 00:36:09
accesos, cuando se usa una herramienta de esas 00:36:11
ella ya se crea su propio pool 00:36:13
pero lo habitual es que 00:36:15
tú no la dejes abierta 00:36:17
porque eso 00:36:19
siempre puede tener efectos colaterales 00:36:20
para los commit, para todo eso 00:36:22
para los rollback 00:36:25
pues nada, esto es lo que tenéis que hacer 00:36:25
que guay 00:36:29
ya está 00:36:30
ya habéis pensado que vais a gestionar 00:36:31
uy 14 00:36:34
que suerte 00:36:37
dime 00:36:37
pues ya veréis que interesante es el año que viene 00:36:39
esto 00:36:44
divertidísimo 00:36:44
no, que sí, que sí 00:36:46
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
9
Fecha:
19 de mayo de 2025 - 13:32
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
36′ 52″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
1.28

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid