Saltar navegación

20260518 AccesoBD_1 - Contenido educativo

Ajuste de pantalla

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

Subido el 19 de mayo de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues entonces, hasta ahora, a lo largo de todo este curso, nuestra aplicación Java, que lógicamente trabajaba con datos, porque si no, no vale para nada, ¿verdad? 00:00:00
Nuestra aplicación Java, ¿de dónde tomaba los datos? Sí, bueno, pero de la RAM siempre. O sea, todos los datos con los que trabaja una aplicación están en RAM. 00:00:16
o cualquier proceso que esté lanzado 00:00:26
la pregunta es cómo han llegado a la RAM 00:00:29
porque en la RAM están las variables 00:00:31
que es lo único con lo que la aplicación puede trabajar 00:00:35
con lo que haya en variables, lógicamente 00:00:38
todo lo que no esté en variables la aplicación no puede tratarlo 00:00:39
pero claro, la pregunta es 00:00:42
cómo llega la información a las variables 00:00:45
para que la aplicación pueda manejar con ellas 00:00:49
operar, mostrar por pantalla, lo que sea 00:00:51
¿cómo llega? pues a lo largo del curso 00:00:54
hemos visto muy pocas 00:00:57
casuísticas, una 00:00:59
pues que haya un tío ahí 00:01:00
metiéndola por consola 00:01:02
¿verdad? se introduzca no sé qué 00:01:04
introduce por consola y ya se carga la variable 00:01:06
que sea 00:01:09
o que haya un tío ahí metiéndola en una 00:01:09
interfaz gráfica, en tu área 00:01:12
de texto, mediante el combo box 00:01:14
en el list view, como sea 00:01:16
tú marcas 00:01:18
un dato de entrada y desde ahí 00:01:20
llegan las variables de la aplicación 00:01:22
lo más 00:01:27
que hemos hecho para que no sea en tiempo real 00:01:28
porque esto que digo es en tiempo real 00:01:31
tiene que estar un tío ahí delante dando la información 00:01:33
si no la aplicación está ahí parada 00:01:35
y lo más que hemos hecho que no sea en tiempo real 00:01:37
pues es que la coja la aplicación 00:01:39
en ficheros 00:01:43
entonces la información 00:01:44
está escrita en ficheros 00:01:48
y la aplicación puede 00:01:50
abrir esos ficheros, llamar a los métodos correspondientes 00:01:52
de las clases de librería hechos para ello 00:01:57
para leer los datos, hacer un read, hacer un write, lo que sea 00:02:00
bueno, pues esto está bien, porque esto ya convierte 00:02:04
automáticamente la aplicación, la convierte ya en algo 00:02:09
persistente, y eso significa que cuando 00:02:12
la aplicación termina, los datos 00:02:16
sigue en algún sitio, que es aquí 00:02:20
porque hasta llegar a ficheros 00:02:23
todos los datos que generaba la aplicación 00:02:27
y todos los datos que tomaba y guardaba en variables 00:02:31
cuando la aplicación terminaba, esos datos son la basura 00:02:34
lógicamente, porque la RAM, toda la información de la RAM 00:02:37
que tiene el proceso lanzado 00:02:40
se ha perdido todo, entonces esa aplicación no era persistente 00:02:42
se supone que había alguien ahí que había visto en la pantalla 00:02:46
el resultado en no sé qué, pero era lo más 00:02:49
que podía ocurrir 00:02:51
con ficheros ya hemos dado un 00:02:52
pequeño primer paso, muy pequeñito 00:02:55
que es que la información 00:02:57
que la aplicación ha generado 00:02:59
se quede en algún sitio 00:03:01
y cuando la aplicación ha terminado 00:03:03
y la RAM se ha limpiado entera 00:03:05
de principio a fin, pues esto está aquí 00:03:07
vale, pues algo es algo 00:03:09
bueno, pues así se podría tirar 00:03:10
hasta el infinito 00:03:13
así se podría 00:03:15
tirar hasta el infinito, pero ¿cuál es el problema? 00:03:19
que sí, vale, si nos remontamos 30 años 00:03:22
o 40 años, todavía, 00:03:24
porque los volúmenes de datos que se manejaban 00:03:26
lógicamente eran 00:03:28
más bajos y estaban 00:03:30
menos estructurados, no necesitaban 00:03:32
tanta estructura. 00:03:34
Ahora ya, con aplicaciones 00:03:36
que trabajan con miles de usuarios, 00:03:38
cada usuario tiene un montón de datos distintos, 00:03:39
tu nombre, tu contraseña, tu no sé qué, 00:03:42
todas tus facturas, 00:03:44
con esos volúmenes y con 00:03:46
información tan estructurada, con tantos campos, 00:03:47
tantas cosas, trabajar 00:03:49
con ficheros es una locura 00:03:51
porque ¿qué hacemos? lo ponemos todo en un ficherito 00:03:52
de texto así tipo CSV 00:03:55
separados con datos, nombre, contraseña 00:03:57
pedazo de fichero enorme 00:03:59
y la aplicación va a tener 00:04:01
un cuello de botella aquí tremendo 00:04:03
hasta que lea del fichero todo 00:04:05
entonces, ¿qué? ¿un fichero 00:04:07
de objetos? jodines, vale, un fichero 00:04:09
de objetos, es menos cuello de botella 00:04:11
porque los ficheros de objetos 00:04:13
mandan la información serializada 00:04:15
es un poquito más rápido 00:04:17
pero ese fichero de objetos 00:04:18
es misterioso total 00:04:21
porque solamente lo puede ver 00:04:23
la aplicación Java 00:04:25
que lo ha creado 00:04:28
esa, lo lee y lo vuelca en sus clases 00:04:29
lo que hay aquí dentro 00:04:31
está absolutamente críptico 00:04:33
y nadie jamás nunca podrá entender eso 00:04:35
a menos que hagas una aplicación Java 00:04:37
con las clases, con esos campos, etc. 00:04:39
luego esta solución 00:04:42
para un contexto 00:04:43
pequeñito, muy bien 00:04:45
pero para un contexto actual, no 00:04:47
Bueno, luego, lógicamente, ¿cuál es el siguiente paso? Que ya lo sabéis, es, hombre, tengo unos sistemas gestores de bases de datos maravillosos, unas tecnologías de bases de datos estupendas, con un sistema gestor que está ahí gestionando un montón de tablas, con un montón de información, con miles de registros, que me da, además, me da un lenguaje SQL que conocéis perfectamente, que me permite a mí hacer consultas, optimizar consultas, sacar consultas, 00:04:49
multitabla, jolines, pues si esta 00:05:18
tecnología ya está 00:05:21
es decir, toda una capacidad de almacenamiento 00:05:22
y además un lenguaje 00:05:24
SQL para que 00:05:27
alguien desde fuera pueda 00:05:28
consultar, crear tablas, lo que sea 00:05:30
si toda esta tecnología está, hombre 00:05:32
pues vamos a hacerla 00:05:34
disponible para nuestras aplicaciones 00:05:37
lógicamente, vamos a hacerla disponible 00:05:38
y que mis aplicaciones puedan guardar aquí la información 00:05:40
¿vale? 00:05:43
es evidente, es un salto 00:05:44
natural 00:05:46
bueno 00:05:47
ahora, cuando tratamos de ver 00:05:50
vale, muy bien, ¿cómo ponemos en 00:05:53
comunicación nuestras 00:05:55
aplicaciones Java con las bases de datos? 00:05:57
porque cada uno de sus países humanos tiene nada que ver, son 00:05:59
tecnologías completamente distintas 00:06:01
cuando digo una aplicación Java, una aplicación Python 00:06:02
una aplicación lo que sea, tecnología 00:06:05
es distinta, ¿cómo las ponemos 00:06:07
en comunicación? 00:06:09
bueno, pues se podría pensar 00:06:11
jolines, pues voy 00:06:13
a ver cómo es mi base de datos 00:06:15
y voy a crear unas clases, un software específico que la entienda 00:06:17
para lo cual, pues lógicamente tendré que haberme empapado bien de cómo está hecho esto por dentro 00:06:22
y me hago yo mis clases cuando digo yo a alguien realmente profesional que pueda hacer esas clases 00:06:28
y ofrecerlas, me hago mis clases con métodos que permiten usar el SQL 00:06:35
Bueno, vale, pues sí, eso lo puede hacer lógicamente el propietario de esta tecnología, el propietario de la tecnología de la base de datos que sea, con unas clases, unas funciones de librería. 00:06:41
es decir, por ejemplo 00:07:00
este es oracle 00:07:03
y oracle dice, vale, yo no quiero estar aislado 00:07:03
en el mundo, quiero que los 00:07:08
desarrolladores java 00:07:10
quiero que puedan incorporar 00:07:11
nuestras aplicaciones y quiero que puedan 00:07:14
crear bases de datos y todo eso 00:07:15
pues entonces 00:07:18
oracle, el mundo de oracle 00:07:19
pues se puede hacer unas clases 00:07:21
y ya sabéis 00:07:24
que unas clases 00:07:26
se empaquetan todas en un paquete .jar 00:07:27
Entonces, se puede hacer unos cuantos JAR con un montón de clases y que esas clases tengan métodos que permitan ser llamados desde Java para hacer lo que toque hacer, ¿verdad? 00:07:30
Entonces, Oracle dice, no pasa nada, yo me hago aquí unas clases porque yo conozco cómo funciono por dentro, solo yo. 00:07:42
Entonces, solo él las puede hacer, yo conozco, sé cómo funciona por dentro estas bases de datos. 00:07:49
pues me hago mis clases, las meto en un 00:07:54
JAR y las pongo a disposición 00:07:56
de los desarrolladores 00:07:59
de la comunidad Java 00:08:00
por lo tanto la comunidad Java tendrá 00:08:01
que usar las clases 00:08:04
de esos JAR para 00:08:06
hacer lo que estos JAR 00:08:08
le permitan, que se supone que será 00:08:10
conectarte a bases de datos, crear 00:08:12
bases de datos, crear tablas, insertar 00:08:14
registros, lo que sea 00:08:16
¿pero qué ocurre? que tenemos 00:08:17
un montón de tipos de bases de datos 00:08:22
también está MySQL 00:08:24
también está Postgre 00:08:26
¿qué ocurre? 00:08:28
que internamente cada una es distinta 00:08:34
cada una funciona de una forma distinta 00:08:36
entonces MySQL 00:08:38
se tendrá que hacer sus propios 00:08:40
hard para ofrecerlos 00:08:43
y Postgre se tendrá 00:08:45
que hacer los suyos propios 00:08:47
y si seguimos añadiendo 00:08:48
bases de datos pues tendríamos 00:08:51
tropecientas mil bases de datos distintas 00:08:53
cada una de ellas 00:08:55
con su propio hat 00:08:56
que te ofrece las clases 00:08:58
para que tú las importes desde tu aplicación 00:09:02
ya veremos cómo 00:09:05
y puedas llamar a los métodos correspondientes 00:09:07
para conectarte, hacer consultas, lo que sea 00:09:10
esta es la primera idea 00:09:13
la primera idea 00:09:17
pero aquí ya rápidamente vemos un problema 00:09:19
ahora ya nosotros como mentes desarrolladoras 00:09:23
que somos, ya sabemos 00:09:26
que las aplicaciones para que tengan 00:09:28
un ciclo de vida largo 00:09:30
porque una aplicación, si tú haces una aplicación 00:09:31
y al año esa aplicación ya 00:09:33
deja de ser productiva por lo que sea 00:09:36
pues te has arruinado, tú como desarrollador 00:09:38
tienes que hacer aplicaciones 00:09:40
que tengan 00:09:42
que su fase de mantenimiento 00:09:43
se estire lo más posible, que no te dejes tirarla 00:09:46
a la basura y hacer otra nueva 00:09:48
desde el principio, porque eso es un gasto muy grande 00:09:50
de equipos de desarrollo y de todo 00:09:52
entonces nosotros ya que tenemos esa mente 00:09:54
desarrolladora y ya sabemos 00:09:56
ciertas cosas que son deseables en las 00:09:58
aplicaciones, como 00:10:00
que sean lo más desacopladas 00:10:03
posibles o lo que es lo mismo 00:10:06
que cada parte esté separada 00:10:08
de la otra, la parte de 00:10:10
interfaz gráfica 00:10:12
la parte del back, la parte 00:10:14
de acceso a datos, pues por ejemplo 00:10:16
cuanto más desacoplada esté todo mejor 00:10:18
porque si tengo que cambiar algo me voy 00:10:20
a esa parte, no tengo que cambiarlo todo 00:10:22
también 00:10:24
que sean fácilmente migrables 00:10:25
es decir, si cambia cualquier dato del exterior 00:10:30
que esa aplicación pueda migrar lo más fácilmente posible 00:10:34
sin tener que hacerla de cero otra vez 00:10:37
bueno, pues esto que he dicho yo 00:10:39
hace que las aplicaciones 00:10:41
si lo dejamos así, esta idea tal y como está 00:10:46
no sean fácilmente migrables 00:10:48
mi aplicación Java es una aplicación súper tocha 00:10:49
que hace un montón de cosas y tiene un montón de usuarios 00:10:53
de historias en la base de datos Oracle 00:10:55
y ahora 00:10:57
de repente yo ya no puedo pagar 00:10:59
Oracle por lo que sea 00:11:01
y necesito cambiarlo todo 00:11:03
a MySQL 00:11:05
bueno, ahora lo tengo todo a MySQL 00:11:06
las mismas bases de datos 00:11:09
las mismas tablas, todo igual 00:11:11
pero ¿qué pasa? que ahora ya 00:11:13
todas las clases que yo usaba 00:11:15
todas las clases que yo usaba 00:11:17
quedan las que estaban dentro de este jar 00:11:19
para acceder a Oracle 00:11:21
todas han cambiado y yo las uso desde un montón 00:11:23
de sitios, ahora tengo que retocar 00:11:25
un montón de cosas, tengo que retocar un montón 00:11:27
de cosas porque ahora tengo que usar 00:11:29
estas otras clases, entonces tengo 00:11:31
que retocar un montón, luego la migración 00:11:33
de esta aplicación 00:11:35
sería un galimatías y muy costosa 00:11:36
luego, mal 00:11:39
eso no, si eso 00:11:40
ocurre, somos un desastre 00:11:43
de desarrolladores y nos van 00:11:45
a tirar por tierra todos nuestros proyectos 00:11:47
vale 00:11:49
Pues entonces, a la vista de ese problema, ¿cómo se enfoca, cómo se soluciona este problema de los múltiples JAR? 00:11:51
De clases diferentes para Oracle, o para MySQL, o para Postgre, o para SQLite, para lo que sea. 00:12:00
¿Cómo se soluciona ese problema de los múltiples JAR? 00:12:07
Bueno, ¿eh? 00:12:10
Con un ser más universal, por decirlo así. 00:12:11
Esa es la idea. 00:12:14
Pues la comunidad de desarrollo Java, como los desarrolladores en general y todos normalmente son una comunidad solidaria, pues se trata de facilitar la vida. 00:12:15
¿Y cómo se facilita la vida de todo esto? 00:12:28
Es decir, oye, vamos a ver, vamos a unificar las llamadas a todas las clases para que se les llame igual. 00:12:32
otra cosa es lo que luego haga por dentro 00:12:41
cada uno hará una cosa 00:12:44
porque lo que tiene por dentro Oracle es diferente a lo que tiene 00:12:45
MySQL y es diferente a lo que tiene Postgres 00:12:48
pero vamos a unificar 00:12:50
vamos a unificar 00:12:51
para que las llamadas por ejemplo a 00:12:53
insertRegistro 00:12:55
sea exactamente el mismo 00:12:57
método con el mismo prototipo, la misma 00:12:59
cabecera en la clase que está aquí 00:13:01
o en la clase que está aquí o en la clase 00:13:03
que está aquí, que la llamada al método sea igual 00:13:05
y que la clase que 00:13:07
crea una base de datos sea la misma 00:13:09
con el mismo nombre, que los nombres 00:13:11
sean iguales, todos 00:13:13
que lo que ya sí que cambie 00:13:15
sea la implementación, que aquí 00:13:17
se implemente de una forma diferente 00:13:19
que aquí, que aquí 00:13:21
pero que las llamadas, los nombres sean 00:13:22
los mismos 00:13:25
bueno, pues eso que yo estoy diciendo 00:13:26
estoy definiendo 00:13:28
exactamente el concepto 00:13:31
de API, ¿verdad? 00:13:33
de Application Program Interface 00:13:35
entonces, una API 00:13:37
es un conjunto de interfaces 00:13:46
con métodos 00:13:49
y clases vacías, como son las interfaces 00:13:51
bueno, pues lógicamente pueden tener aparte 00:13:53
cosas, pero como definición 00:13:55
muy básica, una API 00:13:57
es un conjunto de interfaces 00:13:58
que unifican 00:14:00
describen, definen 00:14:02
la forma de llamar a las cosas 00:14:04
luego cuando tú 00:14:07
llames, ¿qué va a pasar por dentro? 00:14:09
depende de cómo implementes esas interfaces 00:14:11
ya sabéis que las interfaces 00:14:13
son en general 00:14:15
¿vale? en general 00:14:16
son clases con métodos vacíos 00:14:18
y luego yo ya tengo ahí mi interfaz 00:14:21
yo llamo a los métodos de la interfaz 00:14:23
instancio objetos 00:14:26
como si fueran de la interfaz 00:14:27
a mí me valen las interfaces 00:14:29
para declarar referencias ¿verdad? 00:14:31
tengo mi interfaz, por ejemplo 00:14:33
base datos, que es una interfaz con métodos vacíos 00:14:35
yo puedo declarar una referencia 00:14:38
base datos, claro que puedo 00:14:39
lo que pasa es que luego la tengo que instanciar 00:14:41
ahora ya con una implementación 00:14:43
concreta 00:14:45
entonces una API es un conjunto 00:14:46
de clases vacías 00:14:49
o lo que es lo mismo interfaces 00:14:50
que de alguna manera me comprometen 00:14:52
a una forma de llamar a las cosas 00:14:55
a una forma de llamarlas 00:14:57
entonces mi aplicación me da igual 00:14:58
que use oracle, que use java, que use postgre 00:15:01
el código va a ser 00:15:03
exactamente igual porque va a llamar a los métodos 00:15:05
de la misma manera 00:15:07
exactamente igual y va a usar las mismas clases 00:15:08
las mismas interfaces 00:15:11
si respeta esta API, claro 00:15:12
¿qué es lo que va a cambiar? 00:15:14
¿cómo decido yo implementarlas? 00:15:17
que estoy en Oracle 00:15:19
incorporo la implementación 00:15:20
de Oracle 00:15:23
que estoy en, que ahora de repente 00:15:24
cambio a MySQL 00:15:27
cambio las clases de implementación 00:15:28
las cambio unas por las otras, es cambiar las clases 00:15:31
que implementan, en lugar de 00:15:33
coger estas clases que implementan 00:15:35
estas a la basura y pongo las otras 00:15:37
clases, que estas son, que me las da 00:15:39
el fabricante. Me dice, ¿estas son las clases de implementación? 00:15:41
Me la va a dar un hard, claro. 00:15:44
Estas son mis clases de implementación. 00:15:46
Estas son mis clases de implementación. 00:15:48
Tú decides qué clases de implementación 00:15:49
colocas cada vez, qué clases de implementación. 00:15:51
Pero tu código, tu app, 00:15:54
tu aplicación, no se 00:15:55
toca, porque tu aplicación está llamando 00:15:57
a los métodos de la app. 00:15:59
Y esos son iguales para todas. 00:16:01
Son iguales para todas. 00:16:03
Pues esta es la arquitectura 00:16:07
de diseño 00:16:08
de cualquier aplicación Java. 00:16:11
por eso son tan importantes las interfaces 00:16:12
nosotros tenemos que diseñar también nuestras propias 00:16:14
aplicaciones, separando 00:16:16
prototipos 00:16:18
lo que es el contrato 00:16:21
lo que queremos hacer, separándolo de 00:16:22
implementación, para que la implementación se cambie 00:16:24
cuando nos dé la gana, pero 00:16:26
la forma de llamar a las cosas 00:16:28
sea siempre igual 00:16:30
pues a ese esquema de diseño, a ese patrón de diseño 00:16:31
se adapta a todo el mundo, porque el que no se adapta 00:16:34
pues no va a entrar a formar parte de toda 00:16:36
esa comunidad de desarrollo, pues las bases 00:16:38
de datos se adaptan y lo que nos dan son 00:16:40
las implementaciones de esta API 00:16:43
que es una API universal, estándar y que de hecho 00:16:46
la API la tiene ya el JDK, no tenemos que 00:16:49
sacarla de ningún lado, la API está en el JDK 00:16:51
lo que no está es la implementación, porque la implementación 00:16:55
me la tiene que dar cada uno de ellos. Bueno, pues esta es 00:16:58
la filosofía de acceso a la base 00:17:03
a cualquier base de datos desde la base 00:17:06
y es así y no hay otra 00:17:09
y es así, no hay más 00:17:12
tiene que ser así 00:17:14
¿vale? tiene que ser así 00:17:15
luego otra cosa es que vayamos poniendo capas por encima 00:17:17
como iremos viendo el año que viene 00:17:20
nosotros, ellos no, pues 00:17:21
vamos poniendo capas por encima, ahora primero ponemos 00:17:24
uno de rema, ahora ponemos sprint, ahora ponemos no sé qué 00:17:25
para ocultar un poquito esta 00:17:28
complejidad, pero lo que hay debajo 00:17:29
es esto 00:17:32
siempre esto 00:17:33
¿vale? pues entonces 00:17:34
¿qué es lo que vamos a hacer nosotros? 00:17:38
pues 00:17:41
primero 00:17:41
instalar, que yo creo que salgo Jimmy 00:17:45
y nadie la tendrá, imagino, en sus ordenadores 00:17:47
o instalar esta base 00:17:49
de datos para hacer las primeras pruebas 00:17:51
instalar MySQL 00:17:53
la recordamos de donde la podéis instalar 00:17:55
y luego ya hacer 00:17:58
una primera aplicación que use 00:17:59
esa API e incorpore 00:18:01
la implementación de MySQL 00:18:04
MySQL ¿por qué? 00:18:05
dijimos, pues porque tiene licencia 00:18:07
gratis, vamos 00:18:09
vale, entonces esto dijimos 00:18:12
que, ah, que esto 00:18:26
está desenchufado, un segundo 00:18:27
si dime 00:18:29
vale, pues venga, a ver 00:18:30
de que vamos a hacer la base de datos 00:18:36
que os gusta 00:18:44
vale, pues ahora ya si que toca 00:18:45
abrir 00:18:50
hacer nuestra aplicación 00:18:51
Ya está 00:18:53
Tu base de datos ya está guardada 00:18:58
No, las daré aquí 00:19:01
Porque es que como algunas tienen recuperación 00:20:08
Otra no, otra 00:20:10
Es más 00:20:11
Si fuera una nota, nota del examen 00:20:14
Pues sí, pero es que 00:20:16
Para algunos será 00:20:17
Nota de, en uno estará recuperada 00:20:20
En otro no 00:20:22
Pues hala 00:20:23
Aquí tenemos nuestro 00:20:26
ha pasado un humano 00:20:28
bueno 00:20:32
creemos que es humano 00:20:34
tal y como están las cosas 00:20:36
vale 00:20:39
pues venga 00:20:43
vamos a ser unos lanzados 00:20:44
porque nosotros ya hacemos las cosas bien 00:20:46
no somos 00:20:49
que ocurre 00:20:52
que nuestro proyecto 00:20:53
ahora sí que sí 00:20:56
va a necesitar 00:20:58
dependencias, lo que es lo mismo 00:21:00
depende de librerías externas 00:21:02
¿por qué? porque ya hemos dicho que 00:21:04
la implementación de la API 00:21:06
no la tiene el JDK 00:21:08
lógicamente, la implementación de la API 00:21:11
me la da Oracle, si es que trabajo 00:21:13
con Oracle, me la da MySQL, si es que trabajo 00:21:15
con MySQL, entonces la implementación 00:21:16
me la da quien sea, no está en el 00:21:19
JDK, eso significa que 00:21:21
nuestra aplicación tiene dependencias, depende 00:21:23
librerías externas, entonces podemos ser 00:21:24
cutres o no ser cutres 00:21:27
entonces si queremos ser cutres, pues me hago mi proyecto 00:21:28
Java, me busco el JAR y me lo descargo 00:21:31
que tampoco es tan complicado 00:21:33
lo incorporo al 00:21:34
classpath y todo eso 00:21:36
pero si cambia la versión 00:21:38
del JAR, si cambia cualquier cosa 00:21:40
pues me tengo que bajar el nuevo 00:21:43
JAR, sustituirlo por otro, es un poco 00:21:45
cutres, entonces 00:21:47
desde el momento en que una aplicación tiene 00:21:48
dependencias, lo mejor es hacerla con 00:21:50
el gestor de proyectos Maven 00:21:52
o Gradle o el que sea 00:21:54
porque una de las 00:21:56
facilidades 00:21:59
que nos ofrecen los gestores de proyectos 00:22:01
es gestionar de forma sencilla 00:22:03
esas dependencias 00:22:05
entre muchas otras cosas 00:22:07
pues entonces nos hacemos 00:22:09
un proyecto Maven 00:22:11
desde el momento en que decidimos que mi aplicación 00:22:12
tiene dependencias externas, me pongo en chip 00:22:17
de uy, esto Maven 00:22:19
me lo va a hacer guay 00:22:21
pues venga 00:22:23
¿Qué tipo de proyecto Maven? 00:22:24
Maven es como si fuera una especie de intermediario 00:22:28
entre nosotros y el proyecto Java. 00:22:32
Es un intermediario, entonces desde el momento en que hacemos un proyecto con Maven 00:22:36
nosotros ya configuramos Maven, le mandamos cosas a Maven 00:22:40
le decimos cosas a Maven y Maven ya se encarga de hacer la aplicación 00:22:44
de abajo con esas directrices. 00:22:48
Bueno, pues la primera directriz que nos pide Maven es 00:22:50
¿Este proyecto es un proyecto random? 00:22:54
¿O es una cosa muy concreta de tipo 00:22:57
sigue el modelo vista controlador, es un JavaFX 00:22:59
es un servicio 00:23:03
web rest, es una librería de clases 00:23:06
es un proyecto random 00:23:09
no responde a ningún arquetipo concreto 00:23:11
arquetipo para Maven es un tipo de proyecto concreto 00:23:15
pues entonces le decimos, venga tú 00:23:18
un proyecto normalucho y corrientucho 00:23:20
y mayores 00:23:23
ambiciones y expectativas 00:23:24
vale, pues ya está 00:23:27
vamos al siguiente 00:23:32
y ahora ya sí le ponemos 00:23:33
el grupo este 00:23:36
pues recordad 00:23:38
en terminología maven 00:23:39
y si queremos hacer las cosas bien 00:23:42
se supone que yo trabajo 00:23:44
para una empresa que tiene un nombre de dominio reservado 00:23:46
y para identificar 00:23:48
correctamente las aplicaciones de esa empresa 00:23:50
todos los paquetes de todas mis aplicaciones 00:23:52
deberían compartir un prefijo 00:23:56
en la arquitectura de paquetes 00:23:58
deberían compartir un prefijo 00:23:59
que fuera el dominio 00:24:01
pues entonces por eso, aunque uno puede poner 00:24:03
en GroupID lo que le dé la gana 00:24:05
nosotros ponemos pues el dominio 00:24:07
que más se adapte a 00:24:09
por ejemplo así 00:24:11
vamos a poner DAW por respeto 00:24:14
a los invitados 00:24:17
¿vale? 00:24:18
dime 00:24:21
simple 00:24:21
no, he creado un proyecto maven 00:24:25
no, no, no, eso que he hecho antes 00:24:27
era un working set, eso es como si no existiera 00:24:31
es una cosa que hago yo 00:24:34
para organizar los proyectos 00:24:35
pero eso es del eclipse 00:24:38
no tiene nada que ver con Java, nada, nada 00:24:39
directamente un proyecto maven 00:24:41
con simple, ¿de qué tipo? 00:24:49
gote punta simple y ya está 00:24:51
y ahora ya sí nos piden los datos 00:24:53
Entonces, este es el nombre de mi proyecto 00:24:55
Para Maben, artefacto significa tu proyecto 00:24:58
Pues yo que sé 00:25:01
Como es nuestra base de datos personas 00:25:02
Pues como queremos llamar al proyecto 00:25:05
Gestión personas 00:25:08
Venga, vamos a nuestro proyecto 00:25:10
Nuestro proyecto de gestión personas 00:25:13
Vale, así se llama nuestro proyecto 00:25:14
Artefacto, proyecto son sinónimos 00:25:17
Y esto, ¿qué era? 00:25:19
Nosotros, si empaquetamos bien el proyecto 00:25:22
o lo que es lo mismo, si organizamos las clases 00:25:24
bien en diferentes paquetes, que es la idea 00:25:27
organizar las clases bien en diferentes paquetes 00:25:28
pues esos paquetes 00:25:31
ya sabes que tienen una estructura jerárquica 00:25:33
normalmente 00:25:35
y deberían 00:25:36
tener una raíz común 00:25:39
por un tema de uniformidad 00:25:41
y esa raíz común 00:25:43
normalmente se sobreentiende 00:25:45
que todos damos 00:25:47
para esa raíz común el nombre de nuestro dominio 00:25:49
pues bueno 00:25:51
para maven tiene que ser puesto al revés 00:25:52
pues nuestro dominio, trabajamos en una empresa 00:25:55
cuyo dominio reservado 00:25:57
es dandau1.es 00:26:00
pues si mi empresa 00:26:01
en la que yo ofrezco mis aplicaciones 00:26:03
cuando yo suba mis aplicaciones 00:26:05
se suben al dominio dandau1.es 00:26:06
pues a todas mis aplicaciones 00:26:09
maven les diré en el group id 00:26:11
pues esto, que es el dominio pero al revés 00:26:13
repito, esto no es obligatorio 00:26:15
pero es que nada en programación es obligatorio 00:26:17
uno puede hacer una aplicación como le dé la gana 00:26:20
y le va a funcionar igual que otra hecha 00:26:22
siguiendo 00:26:24
pautas más universales 00:26:26
pero claro, la suya 00:26:28
ni Dios la va a entender, arreglarla 00:26:30
a lo mejor va a ser más costoso 00:26:32
si todos nos ponemos de acuerdo 00:26:33
más o menos 00:26:35
en las reglas de diseño 00:26:38
en la forma de hacerlo nos vamos a entender 00:26:40
entre sí 00:26:41
esta es una de las cosas en las que nos ponemos de acuerdo 00:26:43
y ahora ya, nombre y descripción 00:26:46
el que uno le dé la gana, yo suelo poner 00:26:49
siempre el propio nombre 00:26:51
del proyecto, pero por organización 00:26:53
mía, eso ya da un poco. 00:26:55
Pues venga. 00:26:58
Finito. 00:27:00
Finito, ahí se crea nuestro proyecto 00:27:05
Mave. 00:27:06
Y esta es la estructura típica de Mave. 00:27:08
Luego, cuando esto 00:27:12
ya se empaquete 00:27:13
en un jar o en un 00:27:15
guard, donde sea, para distribuirlo, 00:27:17
la arquitectura Mave se ha perdido. 00:27:19
Esto es solo en tiempo de desarrollo. 00:27:20
En tiempo de desarrollo, la arquitectura 00:27:22
es la de maven 00:27:24
luego ya las aplicaciones java cuando se difunden 00:27:25
son un montón de .class sin más 00:27:28
de que ya hacen diferentes paquetes 00:27:30
sin más, vale 00:27:32
pero ahora desarrollar, pues en función 00:27:33
de como desarrolles con maven o no 00:27:36
pues tu arquitectura de clases, de paquetes 00:27:37
de carpetas, perdón, es distinta 00:27:40
vale, aquí el eclipse 00:27:41
este, pues se nos emperra 00:27:44
en ponernos la jre 00:27:46
siempre, cuando hacemos un proyecto maven 00:27:48
se nos emperra en ponerla 00:27:50
al 1.8 00:27:52
Realmente es la JR 00:27:53
Que más se ha usado tradicionalmente 00:27:57
Siempre y se sigue usando 00:27:59
Pero nosotros vamos a 00:28:00
Ponerla al nivel que tengamos en nuestro 00:28:03
Entonces aquí, botón derecho 00:28:05
Properties 00:28:07
La que tengáis vosotros 00:28:08
La que tengáis vosotros instalada 00:28:10
Me da igual que sea 24, 25 00:28:14
La que tengáis 00:28:16
Que si dejarais la 8 00:28:17
Tampoco pasaría nada porque hay pocas 00:28:20
cosas que se hayan hecho después de la 8 críticas 00:28:22
bueno 00:28:25
si todo lo de 00:28:27
módulos y eso 00:28:28
entonces si cambiáis 00:28:30
si cambiáis 00:28:32
la máquina virtual 00:28:34
que va a ejecutar la aplicación, es decir 00:28:36
ahora es una que entiende más cosas 00:28:38
porque eso es lo que cambia respecto a una máquina 00:28:40
virtual 1.8, de 1.9, de 1.10 00:28:42
que cuanta más 00:28:44
actualizada sea la versión, más cosas 00:28:46
nuevas sintácticas entiende 00:28:49
por ejemplo, todo lo 00:28:50
de los módulos, el module path 00:28:52
el module, todo eso 00:28:54
la máquina virtual 1.8 no lo entiende 00:28:56
¿vale? 00:28:58
y quien dice eso dice otras cosas 00:29:00
entonces si uno cambia 00:29:02
la máquina virtual a una más actualizada 00:29:04
para que entienda nuevas 00:29:06
pequeñas incorporaciones que se han hecho en el código 00:29:08
de Java, pequeñas que son chorradas 00:29:10
pues lo normal es que 00:29:12
cambie el nivel de compilación también 00:29:14
para que se adapte a esta máquina virtual 00:29:16
¿vale? porque una cosa es 00:29:18
el nivel 00:29:20
de compilación con el que Eclipse 00:29:22
va a compilar tu código 00:29:24
Eclipse ya sabéis que está compilando el código 00:29:26
automáticamente, lógicamente, lo está compilando 00:29:28
automáticamente y en cuanto saca un error 00:29:30
de compilación, te lo marca aquí en rojito 00:29:32
te marca el error de compilación 00:29:34
vale, pues 00:29:36
hay muchos 00:29:38
niveles diferentes de compilador 00:29:39
si tú compilas con el nivel 00:29:42
1.8, él 00:29:44
solo te tiene en cuenta 00:29:46
la sintaxis que se 00:29:48
admitió hasta el 1.8 00:29:50
si compilas con el 1.10 00:29:52
él solo te tiene en cuenta 00:29:54
la sintaxis que se admitirá hasta 1.10 00:29:56
entonces 00:29:59
pues si vamos a ejecutar con una máquina 00:30:00
25 o 24 o 23 00:30:02
la que sea la vuestra, hombre, vamos a compilar 00:30:04
con uno que sea igual 00:30:06
lógicamente, ¿de qué me sirve 00:30:08
ejecutar con un 25 si luego al compilador 00:30:10
le esfuerzo a que 00:30:13
solo tenga en cuenta del 1.8 hacia atrás 00:30:14
pues ya que vamos a ejecutar con un 25 00:30:16
que lo entiende todo, que el compilador también 00:30:19
lo entienda, una cosa es la máquina 00:30:20
virtual que es la que ejecuta 00:30:22
y otra cosa es el compilador, que es el que 00:30:24
compila, hemos cambiado la máquina 00:30:26
virtual, pero el compilador no 00:30:28
vamos a cambiárselo, y eso 00:30:30
botón derecho en el proyecto 00:30:32
properties 00:30:34
aquí en compiler 00:30:36
pues 00:30:40
Maben me lo estableció al 1.8 00:30:43
vosotros lo ponéis al nivel 00:30:45
de vuestra máquina virtual 00:30:48
al mismo, nunca 00:30:49
superior, porque si lo pusierais superior 00:30:53
la máquina virtual no sería capaz 00:30:55
de entenderse 00:30:57
con ese código 00:30:59
¿al mismo o inferior? inferior sí 00:31:00
depende del eclipse 00:31:03
¿superior a la máquina virtual 00:31:07
que tengas? no, pero yo podría haber 00:31:15
puesto la máquina virtual 23 00:31:17
y luego marcar en el nivel 00:31:19
de operación el 25, eso 00:31:21
si me pongo a ejecutar 00:31:23
una combinación en la cual 00:31:24
la máquina virtual tenga 00:31:27
menos nivel que el compilador 00:31:29
cuando ejecutáis os sale unsupported 00:31:30
mayor, minor, version, no sé qué 00:31:33
entonces en cuanto veáis un error de ejecución 00:31:34
unsupported, mayor, minor, version 00:31:37
es, toma 00:31:39
mi máquina virtual es de nivel 00:31:40
más bajo que el compilador, ahí no hace falta 00:31:43
ya perder tiempo ni buscar encha GPT 00:31:45
en cuanto sale eso, unsupported, version 00:31:46
verificáis 00:31:49
eso y se acabó 00:31:51
bueno, pues ya tenemos, ¿no te acordabas? 00:31:52
que... 00:31:58
¿qué hace aquí todavía? 00:31:58
Pero si te dije que te cogía las dos horas. 00:32:01
Ah, ya no me acordaba, pero bueno, me da igual. 00:32:03
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:
1
Fecha:
19 de mayo de 2026 - 12:44
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
32′ 06″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
752.06 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid