Saltar navegación

20260407 JavaFX_PrimerEjemplo - 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 18 de abril de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Todo arrancado 00:00:00
El eclipse 00:00:03
Vale, pues venga 00:00:06
Vale, pues a ver 00:00:10
Hacemos nuestro primer proyecto 00:00:23
Pero ahora, como va a ser un proyecto 00:00:26
Que tiene una interfaz gráfica 00:00:27
Y vamos a necesitar, por tanto 00:00:29
de dependencias, vamos a hacerlo 00:00:31
con la estructura de Maven 00:00:33
porque para que el proyecto lo pueda 00:00:34
manejar, la herramienta de gestión 00:00:37
de proyectos de Maven tiene que tener una estructura 00:00:39
concreta, ¿vale? Nuestra estructura 00:00:41
de toda la vida. Tiene que tener una estructura 00:00:43
de carpetas concreta para que la herramienta 00:00:45
Maven lo entienda y pueda 00:00:47
hacer esas tareas automáticas, de arrancar, 00:00:49
de compilar, lo que sea. 00:00:51
Pues entonces no podemos empezarlo con un proyecto Java 00:00:53
normal, sino lo tenemos que empezar como un 00:00:55
proyecto Maven. 00:00:57
vale, afortunadamente la herramienta 00:00:58
Maven no es que sea de Eclipse ni de 00:01:00
nada, lo que pasa es que Eclipse la 00:01:02
integra, pero nosotros 00:01:04
podríamos hacerlo todo por consola y hacer 00:01:06
nuestro Maven Project todo por consola 00:01:08
vale, pero Eclipse la 00:01:10
integra, entonces nos facilita el 00:01:12
trabajo, igual que nos facilita 00:01:14
Eclipse, pues el editor de texto 00:01:16
nos facilita de buguear y todas esas 00:01:18
cosas, pues nos facilita el uso 00:01:20
de la herramienta Maven 00:01:22
pues venga, entonces en lugar de un new 00:01:23
java project normal y corriente 00:01:26
un maven project 00:01:28
vale 00:01:30
aquí de nuevo 00:01:31
nuestro objetivo ahora no sé si en la parte 00:01:36
de entornos de desarrollo 00:01:39
está comprendido y ahí lo veréis en más detalle 00:01:40
no lo sé 00:01:43
pero mi objetivo ahora no es 00:01:44
ni explicar maven 00:01:47
ni evaluar 00:01:49
de maven lógicamente pero si 00:01:51
si lo vamos a usar 00:01:53
lo imprescindible 00:01:54
conceptualmente lo tenemos que conocer 00:01:56
bueno, pues a ver 00:01:59
en cuanto hacemos hacer un nuevo proyecto 00:02:00
con la arquitectura de Mave 00:02:03
nos aparece esta ventanita 00:02:04
y esta ventanita ya 00:02:06
nos cuenta, nos habla 00:02:08
sobre 00:02:11
uno de los conceptos 00:02:12
de Mave 00:02:15
que es el arquetipo 00:02:16
¿vale? que es el arquetipo 00:02:25
el tipo de proyecto que vamos a hacer 00:02:27
tipos de proyectos hay muchos 00:02:29
un proyecto de tipo 00:02:31
modelo vista 00:02:33
controlador, un API REST 00:02:35
una aplicación 00:02:37
web con front 00:02:39
de Angular, una librería 00:02:41
de clases, hay millones 00:02:43
de tipos de proyectos, una 00:02:45
aplicación de escritorio normal y corriente 00:02:47
pues el tipo 00:02:49
de proyecto lo llama MAMEN 00:02:51
Arquetipo 00:02:52
entonces lo primero que nos pregunta 00:02:54
¿qué tipo de proyecto quieres? 00:02:56
pues le vamos a decir 00:02:59
oye, sáltate el tipo de 00:03:00
no me hagas elegir el arquetipo 00:03:02
sáltatelo porque quiero el normal y corriente 00:03:05
y ya está 00:03:07
el normal, yo ya lo personalizaré 00:03:08
o sea, el básico 00:03:12
que no tiene nada raro 00:03:13
yo ya luego le personalizo y lo que sea 00:03:14
entonces, marcamos aquí esto 00:03:16
para que se salte el elegir el arquetipo 00:03:19
porque si no se lo salta 00:03:22
veréis que os saca ahí 00:03:23
millones de arquetipos posibles 00:03:25
que uno se vuelve loco 00:03:27
entonces, marcamos ahí 00:03:28
¿Puedes repetir rápido qué es un arquetipo? 00:03:29
Tipo de aplicación que vas a hacer. 00:03:32
Aplicación web, aplicación de escritorio, 00:03:35
librería de clases, 00:03:37
API REST, servicio web, 00:03:39
el tipo de aplicación que vas a hacer. 00:03:41
Ese es el arquetipo. 00:03:43
Entonces, te dice, ¿quieres seleccionar 00:03:45
un arquetipo en concreto? 00:03:47
Porque así yo ya me configuro algunas cosas 00:03:48
de partida. 00:03:51
Entonces decimos, no, 00:03:53
sin ninguna configuración. 00:03:54
El más general que haya. 00:03:57
Y ya le configuramos nosotros 00:03:59
Vale, pues 00:04:00
Marcamos entonces esto 00:04:02
Para que se salte el elegirlo 00:04:05
Bueno, yo voy a poner esto 00:04:11
Pero porque lo tengo separado por esto 00:04:13
Pues venga 00:04:15
Siguiente 00:04:17
Hasta aquí hemos llegado todos 00:04:18
He marcado esto y ya está 00:04:21
Es que no me sale lo de 00:04:32
Javascript 00:04:36
Ah, no, pero 00:04:37
no, a ver, es que esto 00:04:39
porque yo lo tengo metido en un working set aparte 00:04:41
esto olvídate 00:04:43
vale, vale 00:04:44
pues siguiente ventana 00:04:50
esta ventana 00:04:52
también mete nombres 00:04:54
que son los habituales en la terminología 00:04:56
de Maven 00:04:59
como el grupo y el artefacto 00:04:59
el artefacto 00:05:03
es el proyecto 00:05:08
artefacto es como si fuera la aplicación 00:05:09
el proyecto, es como llama Maven 00:05:12
a la aplicación, pues la llama 00:05:14
artefacto 00:05:16
pues nada, entonces aquí 00:05:17
pondríamos el nombre de nuestra aplicación 00:05:21
el nombre, pues lo que queráis poner 00:05:23
aplicación prueba 00:05:25
para ver si nos funciona todo 00:05:27
las dependencias, las librerías 00:05:29
yo que sé, el nombre que no le dé la gana 00:05:31
ese es el artefacto, el proyecto 00:05:33
y aquí uno pone lo que le dé la gana 00:05:35
es como una descripción que aparecerá en el 00:05:39
fichero de configuración 00:05:41
de maven, pues aparecerá 00:05:43
ese nombre, esa descripción 00:05:45
pero bueno, el nombre del proyecto 00:05:47
como tal, lo que entendemos como nombre de proyecto 00:05:49
nosotros es lo que pongamos aquí en el artefacto 00:05:51
y el grupo que es 00:05:53
el grupo 00:05:58
es la raíz 00:05:59
la base de mi 00:06:02
estructura de paquetes 00:06:04
nuestras aplicaciones lógicamente 00:06:05
son un montón de clases distribuidas en paquetes 00:06:10
y esos paquetes ya más o menos hemos visto 00:06:12
por ahí que suele haber 00:06:16
uno que incluye 00:06:17
las clases que describen el modelo 00:06:20
las entidades 00:06:21
pues puede haber otro que yo que sé 00:06:22
que a lo mejor 00:06:25
tenga las clases que son las excepciones 00:06:26
porque yo he hecho excepciones propias 00:06:29
puede haber otro pues que sean 00:06:31
las clases 00:06:34
que se ocupan de cómo recupero 00:06:34
yo objetos y cómo los guardo 00:06:37
en el soporte que sea 00:06:39
sea un fichero, sea una base de datos 00:06:41
normalmente yo distribuyo las clases 00:06:42
en función de lo que hacen 00:06:45
pues lo habitual 00:06:46
lo habitual 00:06:49
no es que estos sean paquetes 00:06:50
que están así sueltos, este se llama modelo 00:06:53
este exception, este dado, paquetes sueltos 00:06:55
no es lo habitual, lo habitual es que 00:06:57
estén metidos como en una especie de jerarquía 00:06:59
y que todos tengan 00:07:01
un prefijo delante 00:07:03
por ejemplo, imaginaos que fuera esta 00:07:04
la jerarquía, pues el 00:07:07
paquete en realidad sería mi app punto 00:07:09
model, mi app punto excepción 00:07:11
mi app punto dado 00:07:13
ya sabéis que el nombre de los paquetes es 00:07:15
no sé qué, punto, no sé qué, punto, no sé qué 00:07:17
y eso es equivalente a la ruta de carpetas 00:07:19
donde están 00:07:21
pues lo normal es que los paquetes 00:07:22
que integra mi aplicación 00:07:25
tengan un prefijo común 00:07:27
eso significará que realmente 00:07:29
si yo me meto en el sistema de archivos 00:07:32
habrá una carpeta mi app 00:07:33
y dentro de esa carpeta sea la carpeta model 00:07:35
exception o dao 00:07:37
que se traduce que el nombre del paquete 00:07:39
es mi app.model, mi app.exception 00:07:41
mi app.dao, entonces queda mucho más bonito 00:07:44
y organizado y cuando uno 00:07:46
despliega una aplicación 00:07:47
pues si todos los paquetes 00:07:49
tienen una raíz común 00:07:51
pues queda mejor 00:07:52
vale, pues esa raíz común 00:07:53
esa raíz común sería el grupo 00:07:57
la raíz común sería el grupo 00:07:59
¿y qué raíz común solemos poner? 00:08:02
por supuesto la que a uno le dé la gana 00:08:07
pero normalmente 00:08:09
se pone el nombre de dominio 00:08:11
el dominio 00:08:13
correspondiente a la empresa 00:08:15
que está desarrollando su software 00:08:17
¿vale? ¿qué es un software 00:08:18
de oracle? pues el grupo 00:08:21
será 00:08:23
con punto oracle 00:08:24
es el dominio al revés 00:08:26
¿qué es una 00:08:28
aplicación de telefónica? 00:08:32
pues si pudiéramos meternos en las aplicaciones 00:08:34
de telefónica, veríamos 00:08:36
que el grupo de sus aplicaciones 00:08:38
es, pues yo que sé, es punto 00:08:40
telefónica, es decir 00:08:42
normalmente es el dominio 00:08:46
y así todas las aplicaciones 00:08:47
que están por ahí, que se despliegan, que no sé qué 00:08:50
pues solamente ya por su 00:08:52
empaquetado, queda clarísimo 00:08:54
esas aplicaciones, de quién son 00:08:56
cada 00:08:58
paquete de que se ocupa 00:09:00
entonces el nombre y la arquitectura de empaquetado 00:09:01
en realidad no es trivial hasta el punto 00:09:04
de que se asume cierto estándar 00:09:06
es obligatorio que el grupo 00:09:08
sea siempre el dominio 00:09:10
pero bueno, es lo habitual 00:09:11
¿vale? 00:09:14
bueno, pues nosotros podemos poner el grupo que nos dé la gana 00:09:16
Venga, pues vamos a poner 00:09:18
Por ejemplo es .damp1 00:09:23
Ya está 00:09:25
Sí, claro, los nombres de los paquetes 00:09:27
No me haces una minúscula 00:09:32
Porque es que esto 00:09:33
Formará parte del nombre de mis paquetes 00:09:36
El artefacto, pues yo que sé 00:09:38
Vamos a hacer esta prueba 00:09:42
Esta prueba de clase 00:09:43
Aquí, para ver si conseguimos que arranque la aplicación 00:09:47
Que entienda los módulos de las dependencias 00:09:50
Todo eso, luego ya la siguiente tarea 00:09:51
Ya será empezar a programar la aplicación 00:09:53
Pero la primera parte es que yo consiga arrancarlo 00:09:55
Y que haya encontrado los módulos 00:09:58
Y todo eso 00:09:59
Vale, nombre y descripción 00:10:00
Yo siempre pongo por comodidad 00:10:03
Lo mismo 00:10:05
Y ya está, pero vamos, uno podría aquí 00:10:07
Extenderse y le quedaría más bonito 00:10:09
¡Hala! 00:10:13
Ya lo tenemos relleno 00:10:17
Pues venga, finish 00:10:18
Y se está abajo a la derecha la barra verde 00:10:20
hasta que lo construye 00:10:23
y ya lo ha construido 00:10:24
y como veis 00:10:27
la estructura de carpetas 00:10:30
que ha generado no es la de un proyecto 00:10:32
de Java normal y corriente 00:10:34
tiene esta carpeta 00:10:36
que es la que se supone 00:10:40
que está pensada y me ofrece Maven 00:10:42
para mis paquetes 00:10:44
mis paquetes y mi código fuente irá aquí 00:10:45
luego tiene 00:10:48
esta pensada 00:10:50
para las clases de prueba 00:10:51
entonces si hiciéramos bien las cosas 00:10:53
lógicamente, pues uno va haciendo 00:10:56
las clases de prueba para ir a las clases normales 00:10:58
¿no? 00:11:01
entonces, pues uno iría metiendo aquí 00:11:02
las clases de prueba, pues no sé, todo lo que 00:11:04
hayáis hecho o visto de pruebas en entornos de 00:11:06
desarrollo, entonces 00:11:08
Maven, si tú le das el goal 00:11:10
ahora vemos lo que es el goal, le dices, oye Maven 00:11:12
pasa test 00:11:14
pues Maven ya se coge las clases 00:11:16
de prueba de aquí, empieza 00:11:18
a hacer todo lo que tenga que hacer, automatiza 00:11:20
todo eso, esta carpeta 00:11:22
la de resources para que está pensada 00:11:28
pues está pensada por si mi aplicación usa recursos 00:11:30
tipo ficheros de configuración 00:11:32
pues yo que sé, cosas que usa mi aplicación 00:11:34
el fichero de configuración de base de datos 00:11:36
si es que usa una base de datos 00:11:38
recursos varios que no son código 00:11:39
normalmente son 00:11:42
pues esos ficheros, ficheros que mi aplicación 00:11:44
va a utilizar pues como configuración 00:11:46
o como cosas 00:11:48
y como la parte de pruebas tiene que 00:11:48
ser completamente paralela 00:11:52
a la original para que las pruebas 00:11:54
se pasen, pues esta está pensada 00:11:56
para meter los recursos pero de pruebas 00:11:58
los recursos de pruebas 00:12:00
es decir esto es 00:12:01
una copia de esto para que yo vaya haciendo 00:12:02
en paralelo las clases de prueba y todo 00:12:06
para que pueda ir pasando las pruebas 00:12:07
pero bueno esa parte nosotros 00:12:09
no la vamos a hacer con lo cual esas dos carpetas 00:12:10
no la vamos a usar 00:12:13
vale y luego está 00:12:14
este fichero que es el fundamental que ahora lo abrimos 00:12:19
y lo vemos 00:12:22
pero fijaos en el detalle 00:12:22
cuando Eclipse arranca el proyecto 00:12:25
MAVEN, automáticamente 00:12:29
se configura 00:12:32
para usar la JR1.8 00:12:33
entonces en la mayoría 00:12:36
de las aplicaciones podemos tirar con la 00:12:39
JR1.8 00:12:41
y ya está, pero en esta no nos interesa 00:12:42
porque esta se va a pegar 00:12:45
con JavaFX 00:12:47
que usa el sistema de módulos 00:12:48
que es más moderno que JR1.8 00:12:50
entonces puede haber conflictos, entonces lo normal es que 00:12:52
en cuanto uno hace el proyecto de MAVEN con Eclipse 00:12:54
cambie esto 00:12:56
cambie y lo ponga al nivel suyo propio 00:12:58
yo tengo el JDK 25 00:13:01
porque lo he puesto esta semana santa 00:13:03
para tener el último 00:13:06
vosotros pues el que tengáis 00:13:07
el que tengáis el 24 o el que sea 00:13:08
entonces lo primero que tendríamos que hacer 00:13:10
y que no se nos tendría que olvidar 00:13:13
una vez hecho el proyecto MAVEN 00:13:14
es cambiar la máquina virtual 00:13:15
a la más reciente nuestra que tengamos 00:13:17
a ver 00:13:20
¿necesitáis que lo cambie a negro? 00:13:22
Uy, qué claridad de ideas 00:13:24
A ver 00:13:28
¿Alguien más le ha salido algo 00:13:32
con el plugin de Maven 00:13:35
para Eclipse? 00:13:37
Vale, entonces 00:13:41
Ahora 00:13:42
Este fichero de aquí 00:13:47
El POM 00:13:49
Este es el básico 00:13:51
Este es el que manda 00:13:53
en Maven 00:13:56
porque este es el que tiene 00:13:57
toda la configuración 00:13:59
¿vale? entonces ahora mismo 00:14:01
si lo abrimos 00:14:03
si lo abrimos 00:14:06
no tiene nada 00:14:13
el fichero de configuración de Mabel 00:14:14
que ahora mismo está vacío porque todavía no tiene nada 00:14:18
tiene solamente lo que lo hemos puesto 00:14:21
el grupo 00:14:23
como se llama nuestro proyecto 00:14:24
y el nombre y la descripción 00:14:27
no tiene nada más 00:14:29
¿vale? 00:14:30
¿Tiene o sale a todos este error rojo? 00:14:33
Sí, sí. 00:14:37
Vale. 00:14:38
Pues tiene esa cosita roja 00:14:39
que da cierta ansiedad porque es rojo. 00:14:41
Pero entonces parece que es un error de compilación 00:14:45
y que todo va a morirse. 00:14:48
Pero es que esto no es un código fuente. 00:14:50
Con lo cual, 00:14:52
podríamos ignorarlo si nos diera la gana. 00:14:54
Esto es un error porque te dice 00:14:57
que el esquema que para ti y para Natán 00:14:59
Podríamos ignorarlo, no pasa absolutamente nada 00:15:01
Porque esto no es código fuente 00:15:03
Pero, como nos da ansiedad 00:15:04
Ese rojo ahí, verlo 00:15:07
Pues 00:15:08
Os digo el truco mágico 00:15:10
Que le pongáis aquí una S 00:15:12
Una S 00:15:15
Ahí 00:15:18
Ese truco no le sabía ni ChaGPT 00:15:19
Ni Gemini, ni nadie 00:15:23
Y ya está, se quita el error 00:15:24
Que da lo mismo, que esté, que no esté 00:15:30
no va a tener ninguna implicación 00:15:32
ahora de trabajar con el proyecto, de nada 00:15:34
pero nos queda más bonito 00:15:36
si lo quitamos 00:15:37
claro, a cambio hacemos aparecer una cosa 00:15:40
del sonar, pero esa no la vemos tanto 00:15:44
así que no nos importa 00:15:46
dime 00:15:47
vamos a automatizar 00:15:48
las dos cosas que necesitamos con JavaFX 00:15:53
con JavaFX 00:15:56
la gestión de las dependencias 00:15:57
y el arranque del proyecto 00:16:03
que no es trivial porque no es 00:16:05
arrancarlo como una aplicación normal 00:16:07
porque tiene módulos 00:16:09
claro, los parámetros que te dicen 00:16:11
dónde están los módulos que vas a usar 00:16:15
efectivamente 00:16:16
le pasas parámetros 00:16:20
vale, pues entonces 00:16:21
aquí 00:16:25
es donde tenemos que empezar a configurar 00:16:26
cosas 00:16:29
vale, entonces 00:16:29
esto 00:16:32
vamos a ver 00:16:34
aquí habría que empezar a configurar 00:16:35
primero las librerías de las que 00:16:38
tiro 00:16:40
esto que se pone 00:16:41
aquí, serían las 00:16:46
librerías que necesita 00:16:53
mi proyecto 00:16:55
mi proyecto, eso lo tengo 00:16:56
que meter aquí en este nodo 00:17:08
de pendencias que he escrito 00:17:10
yo. 00:17:12
¿Vale? 00:17:14
En este nodo de pendencias que he escrito 00:17:16
yo aquí es donde tenemos que ir poniendo 00:17:18
una POM a las librerías que necesitamos. 00:17:20
Nosotros vamos a tiro 00:17:23
fijo a por las de JavaFX. Entonces yo lo que 00:17:24
voy a hacer ahora es 00:17:26
pasaros un POM al aula virtual 00:17:28
para que lo copiéis de ahí. 00:17:30
Y así no perdamos más tiempo. 00:17:33
Pero antes de hacer eso, de subiros 00:17:35
el POM al aula virtual para que lo 00:17:36
descarguéis y lo copiéis de ahí, 00:17:38
Vamos a ver un poco en general la magia de Maven, que es la magia que tiene, que es, imaginaos que queremos hacer una aplicación que usa, pues yo que sé qué, venga, vamos a poner, pues bueno, usa JavaFX, que son librerías externas. 00:17:40
entonces, jolines 00:18:02
pues yo necesito las librerías de java 00:18:05
fx, ¿qué pongo ahí dentro? 00:18:06
¿qué pongo ahí dentro? 00:18:08
vale, pues entonces uno se va a internet 00:18:10
y abre el 00:18:12
repositorio de maven 00:18:17
busca maven repository 00:18:18
es lo primero que le sale, el repositorio de maven 00:18:27
y ahora 00:18:29
en el repositorio de maven 00:18:32
están los miles de millones de millones de miles 00:18:35
de hard 00:18:37
que tú puedes utilizar en tu aplicación 00:18:38
pues oye 00:18:41
Venga, quiero yo 00:18:42
Pues hacer una aplicación 00:18:45
Que use JavaFX 00:18:47
Venga, no sé qué 00:18:49
Pongo ahí parámetros de búsqueda 00:18:52
Búscame 00:18:54
Y ya me empieza a sacar aquí cosas 00:18:55
Entonces 00:19:00
Esto no es trivial 00:19:07
Porque luego tú a partir de aquí 00:19:10
Tienes que encontrar la que realmente quieres 00:19:13
Si vas a ciegas 00:19:15
Normalmente pruebas 00:19:17
Ahora vemos como pruebas 00:19:19
y lo pones, uy pues no me funciona 00:19:21
pues va a ser otra, o sea no es trivial 00:19:23
entonces 00:19:25
antes, ¿qué ocurre? 00:19:26
pues que normalmente la arquitectura de tu proyecto ya está 00:19:29
hecha, has hecho un proyecto en equipo, la arquitectura ya está hecha 00:19:31
las dependencias ya están, no te vuelves loco desde cero 00:19:33
aquí, ahora 00:19:35
¿qué es lo que hacéis y haréis? 00:19:37
pues este pobre 00:19:40
repositorio de maven 00:19:41
que sigue siendo fundamental, pues se ha quedado 00:19:42
un poco así, porque le sueles decir 00:19:45
a la IA que sea 00:19:47
pásame el nodo de 00:19:49
dependencias directamente para que yo 00:19:51
copie y pegue de una aplicación 00:19:53
que usa esto, esto y esto, entonces el te lo pasa 00:19:55
y después de 15 00:19:57
intentos, la 15 00:19:59
ya si te va a pasar el bueno 00:20:01
vale 00:20:02
entonces, si no lo 00:20:03
hiciéramos así, ah pues mira, esta es la librería 00:20:06
que yo quiero, quiero esta 00:20:09
es que ninguna de estas que me está ofreciendo 00:20:11
en particular es la que 00:20:12
querríamos, imaginamos 00:20:14
Pues de JavaFX 00:20:19
Pero yo quiero de OpenJFX 00:20:21
A ver, sí, pero 00:20:27
No, tranquila 00:20:36
Que no hace falta, que os lo voy a pasar yo ya 00:20:43
No hace falta 00:20:45
Relax 00:20:46
Vale, a ver, nos da igual cualquiera 00:20:48
Ah, bueno, por ejemplo, no, más interesante 00:20:51
Más que JavaFX, porque eso como lo vamos a hacer 00:20:52
De otra manera 00:20:55
Imaginaos que queremos hacer una aplicación 00:20:55
que queremos que genere archivos 00:20:58
de logs 00:21:00
¿sabéis lo que es un archivo de logs? 00:21:01
es un archivo 00:21:05
que según una aplicación va funcionando 00:21:06
se va escribiendo solito 00:21:08
y va tomando 00:21:10
notas de lo que está pasando 00:21:12
¿por qué? porque si la aplicación falla 00:21:13
y te llama un cliente, oye son las 00:21:16
me ha fallado la aplicación, uy a qué hora te falló 00:21:18
pues a las 13 y cuarto 00:21:20
estaba sentado y me falló 00:21:22
tú abres el archivo de logs que tiene notas 00:21:23
13 y 10, pasó esto 00:21:26
13 y 15, pasó que alguien 00:21:29
Intentó acceder a una variable protegida 00:21:30
O no sé qué, ¡boom! 00:21:33
Le dices, oye, es que mira, pasó esto, lo siento 00:21:34
Ahora ya te lo arreglo, no sé cuánto 00:21:36
Eso es un archivo de log, ¿vale? 00:21:38
El archivo de log, ¿quién lo genera? 00:21:40
Nuestra propia aplicación 00:21:42
Que en lugar de hacer el system.out.println 00:21:43
Pues hace una cosa muy parecida 00:21:46
Pero que en lugar de escribirlo en consola 00:21:48
Lo va escribiendo a un fichero 00:21:50
Entonces el fichero se va generando 00:21:52
Vale, pues imaginaos que queremos 00:21:53
Hacer una aplicación 00:21:56
Y cambiar los system.out.println 00:21:57
Que informen de lo que va pasando 00:21:59
Cambiarlo por mandarlo a un fichero de log 00:22:01
Pues tendríamos que usar una librería de logs 00:22:03
Que tiene las clases que lo hacen 00:22:06
Pues venga 00:22:07
Entonces, oye, voy a buscar una librería de log 00:22:09
Que me haga estas cosas 00:22:12
Anda, mira 00:22:14
Pues, uy, esta, que bonita 00:22:15
Me gusta esta 00:22:17
Vale, que quiero esta librería 00:22:18
Entonces 00:22:21
¿Qué hacemos? 00:22:21
Pinchamos, venga 00:22:24
¿Qué versión quieres? Saca todas las versiones 00:22:26
¿Qué versión quieres? Venga 00:22:28
Esta quiero, la 6.5 00:22:30
¡Pum! 00:22:32
La pinchas y 00:22:33
Y te dice 00:22:35
Ah, está abajo, no lo veía 00:22:36
Vale, y te da esto 00:22:41
Vale, pues esto 00:22:43
Tú tal cual pinchas 00:22:45
Se copia 00:22:47
Tal cual pinchas 00:22:48
se copia y esto lo metes tú 00:22:51
en el POM. Vale, lo que 00:22:53
se ha copiado, tal cual, nos vamos aquí 00:22:55
adentro de dependencias, 00:22:57
hacemos control V 00:22:59
y le damos a guardar 00:23:00
y de repente, pues aquí empiezan 00:23:02
a pasar cosas. 00:23:05
¿Veis? Aquí han empezado 00:23:08
a pasar cosas, la barrita se ha puesto 00:23:09
como loca. Pues, ¿qué ha pasado? 00:23:11
Pues ha pasado una magia 00:23:14
que ahora de repente 00:23:15
mi proyecto le ha 00:23:17
aparecido dependencias de 00:23:19
maven y le ha 00:23:21
aparecido todo este mogollón 00:23:23
de hard 00:23:25
entonces 00:23:25
al haber copiado yo en mi pom 00:23:28
xml, al haber copiado 00:23:31
ese dependency que me ofrecía maven 00:23:33
en cuanto lo he 00:23:35
copiado y he guardado, maven dice 00:23:37
ah vale, que quieres los hard 00:23:39
de la herramienta log tools 00:23:41
quieres estos hard 00:23:43
no pasa nada, yo me conecto al 00:23:44
repositorio, te los descargo 00:23:47
te los incorporo a 00:23:49
donde haga falta, el classpath 00:23:51
y ya los tienes todos ahí 00:23:53
vale, entonces no hemos tenido que 00:23:54
buscar por internet a mano estos 00:23:57
hard para descargarlos 00:23:59
y añadirlos nosotros al proyecto 00:24:01
no, nos hemos ido al repositorio de 00:24:03
maven, hemos buscado 00:24:05
quiero esta herramienta, hemos 00:24:06
copiado la dependencia 00:24:09
que me ofrecía, en cuanto 00:24:11
hemos guardado, pum 00:24:13
el repositorio de maven 00:24:14
ha descargado todos los puntos 00:24:17
hojas relacionados con esta herramienta, 00:24:19
todos, y los ha 00:24:21
incorporado a mi proyecto. Y además, 00:24:23
y además, 00:24:27
me los ha 00:24:29
guardado localmente 00:24:30
en un sitio. ¿Veis aquí la ruta donde lo ha 00:24:32
guardado? Lo guarda en una 00:24:34
carpetita oculta .m2 00:24:36
repository, ¿vale? 00:24:38
En vuestro usuario. 00:24:40
Entonces, en esta carpetita oculta, 00:24:42
ahí lo deja ya descargado. 00:24:44
Que esa carpeta desaparece, 00:24:49
porque uno va, se mete en ella, la ve a borrar 00:24:51
no pasa nada porque 00:24:53
desaparezca, cuando la aplicación 00:24:55
arranque otra vez 00:24:58
maven dirá, uuuh, me los han quitado 00:24:59
pues no pasa nada, él solo se vuelve 00:25:01
a conectar al repositorio y te los vuelve a descargar 00:25:03
en cuanto ve que en el pom está eso 00:25:05
vale 00:25:07
entonces nos facilita 00:25:08
horrores el 00:25:11
encontrar y incorporar 00:25:13
las librerías que usa mi aplicación 00:25:15
vale, pero como lógicamente 00:25:17
esta no la vamos a usar, pues vamos a quitar 00:25:19
esto que hemos copiado 00:25:21
volvemos a guardar 00:25:22
y ha desaparecido el maven 00:25:25
de pendencia 00:25:27
lo hemos quitado, lo hemos borrado, boom, pues ha desaparecido 00:25:28
en el repositorio local 00:25:32
se ha quedado, si no queremos que nos moleste 00:25:36
podríamos borrarlo 00:25:38
vale, por ejemplo, me voy yo 00:25:39
al repositorio local, porque se habrá quedado 00:25:44
ahí 00:25:46
era en un users 00:25:46
admin 00:25:49
.m2 00:25:50
Repositori 00:25:53
Uf, bueno, es que tengo el repositorio hasta arriba 00:25:56
De cosas 00:25:58
Una de ellas es lo que acabo de descargar 00:25:59
Lo podría borrar entero, de hecho voy a borrar el repositorio enterito 00:26:02
Lo quito todo, ala 00:26:05
A tomar por saco, fuera 00:26:05
Que no, si luego Maben 00:26:07
Si necesita algo porque lo ve que está en dependencias 00:26:11
Se lo va a descargar otra vez 00:26:15
Bueno, esto no me deja 00:26:16
Pero tengo el eclipse abierto, yo creo 00:26:20
me voy a perder tiempo aquí con esto 00:26:22
bueno 00:26:27
esto ha dejado 00:26:28
vale, pues nada 00:26:30
pero las dependencias 00:26:33
que nos importan a nosotros 00:26:35
son las de JavaFX 00:26:37
vale, pues entonces 00:26:39
os voy a subir a la aula virtual 00:26:41
un POM con esas dependencias 00:26:42
las copiáis ahí 00:26:48
cuando os hayáis 00:26:52
Copiado el properties, ya se os quitarán 00:26:55
Estos errores que os aparecían aquí, ¿vale? 00:26:57
Entonces 00:27:00
Podríais quitar el properties 00:27:00
Y poner aquí 25 00:27:02
Tal cual, ¿vale? 25 00:27:04
¿Vale? Lo que pasa 00:27:07
Es que yo lo he hecho así, porque 00:27:09
Si incorporamos más dependencias 00:27:11
En lugar de poner el 25 00:27:12
En todas partes, pongo esto 00:27:15
Que es el nombre de la variable 00:27:16
Y la variable está declarada arriba 00:27:18
¿Por qué 25? 00:27:20
A ver, es la versión de JavaFX 00:27:22
que yo he elegido para poner aquí 00:27:25
los que tengáis 24 00:27:26
no sé si va a ser compatible, si no 00:27:28
tendréis que bajarlo ahí a 24 00:27:30
pero solo habrá que bajarla aquí 00:27:32
porque como lo tenemos puesto 00:27:34
en variable no habrá que tocarlo en todas partes 00:27:36
y ahí la ventaja de que sea en variable 00:27:38
¿y en Mave y Compile? 00:27:39
¿en qué nivel de compilación va a compilar Mave? 00:27:42
entonces los que tengáis el 24 00:27:45
la JDK 24 00:27:47
eso sí que sí tendréis que cambiarlo de 24 00:27:48
ya deberíamos saber 00:27:50
si nos va a dar problemas 00:27:57
cuando surjan los problemas 00:27:59
ya se arreglarán 00:28:02
igual es el jdk 00:28:04
para java fx 00:28:05
no lo sé 00:28:12
pero hasta cual quieres bajar 00:28:13
prueba a ver 00:28:14
por el 21 00:28:19
Normalmente del 17 en adelante 00:28:20
Casi todo funciona 00:28:27
Hay como ciertos JDKs 00:28:28
Que son como saltos críticos 00:28:30
1, 8, 1 00:28:32
Y el 17 por otro 00:28:33
Entonces, bueno, prueba 00:28:36
Si no ha descargado un JDK 00:28:38
Es un minuto 00:28:41
Vale 00:28:42
Bueno, pues entonces 00:28:43
Las dependencias ya están 00:28:46
las habéis copiado en su versión 25 00:28:48
24, la que sea 00:28:50
y cuando 00:28:52
le habéis dado a guardar 00:28:54
pues automáticamente, ahora ya 00:28:55
sí que sí, ¿dónde estoy yo? aquí 00:28:58
os ha aparecido 00:29:00
esto, que ahí están 00:29:01
las clases que vamos a usar 00:29:05
el stage, el screen, el botón 00:29:07
el layout, el panel 00:29:09
el control, lo que sea 00:29:11
están todas ahí 00:29:13
¿vale? en esos hard 00:29:15
luego eso ya lo tenemos, esa parte 00:29:16
entonces, uno podría 00:29:19
pretender 00:29:24
ahora ya arrancar su aplicación porque tiene 00:29:27
las clases 00:29:29
pues vamos a hacer como si quisiéramos 00:29:30
hacer nuestra primera aplicación JavaFX 00:29:33
total, ya tenemos las clases 00:29:36
pues venga 00:29:37
estamos más o menos todos a la vez 00:29:39
nos vamos a 00:29:41
srcmenjava 00:29:43
que este es como si fuera pues eso 00:29:44
el antiguo src de los java project 00:29:47
el antiguo src, ahora es este 00:29:49
Y aquí nos vamos a hacer nuestro primer paquete 00:29:51
Con esta primera aplicación 00:29:55
Pero hombre, para ser coherentes con el grupo 00:29:56
Que hemos marcado 00:29:59
Para ser coherentes 00:30:00
Con este grupo 00:30:03
Vamos a, ¿dónde estamos? 00:30:03
Vamos a crearnos un paquete que se llame 00:30:07
EsDAM1, como sea 00:30:09
Pues venga, me voy a hacer mi primer paquetillo 00:30:10
Que es 00:30:13
Es.DAM1. 00:30:14
Pues app, por ejemplo 00:30:17
Eso son las carpetas 00:30:19
Esto es un paquete 00:30:27
Es .dam 1.app 00:30:29
Esto ya sabemos que significa 00:30:30
Que se traduce en que aparecerán tres carpetas 00:30:33
Pero paquete es uno 00:30:35
Vale, pues ya está 00:30:37
Para organizar mis clases 00:30:43
En una arquitectura jerárquica 00:30:48
Que es mucho más clara 00:30:49
Organizada 00:30:52
entonces no es lo mismo 00:30:53
que mi aplicación tenga paquetes 00:30:54
que sean paquete 1, paquete 2, paquete 3 00:30:57
que tenga paquetes que sean 00:30:59
dam 1, paquete 1, dam 1, paquete 2 00:31:00
yo automáticamente veo que todo es una aplicación 00:31:02
de dam 1, más bonito 00:31:05
vale, pues venga 00:31:06
ahora ya nos podemos hacer nuestra primera 00:31:08
aplicación esta 00:31:11
pues sale 00:31:12
una 00:31:13
aplicación con java 00:31:15
hacemos una nueva clase, pues venga 00:31:19
Primera ventana, como la queráis llamar 00:31:22
Primera ventana 00:31:24
Una primera ventana de prueba 00:31:27
Pues mi primera ventana 00:31:29
Para que este sea 00:31:32
El punto de arranque de una aplicación 00:31:36
JavaFX 00:31:38
Tiene que heredar 00:31:39
La clase Application 00:31:43
Extends 00:31:45
Application 00:31:47
Tiene que heredar de aquí 00:31:49
y ahora, ¿esto dónde está? 00:31:54
pues él me lo ofrece 00:31:59
me lo ofrece aquí 00:32:00
gracias a que yo tengo 00:32:02
la dependencia incorporada 00:32:05
si no hubiera hecho lo de Mave 00:32:07
ni hubiera puesto las dependencias 00:32:08
esto no me lo ofrecería 00:32:10
pero esto forma parte 00:32:12
de los hard que yo acabo de incorporar 00:32:14
pues ala 00:32:17
ahí lo pongo, tan feliz 00:32:17
vale, entonces 00:32:20
al heredar de application me dice 00:32:25
oye tú, tienes que implementar los métodos 00:32:27
o volverte abstracto, lo que sea, lo siento. 00:32:31
Pues venga, vamos a implementarlos. 00:32:34
Bueno, pues este es el método 00:32:40
que cuando yo arranque la aplicación, 00:32:42
la aplicación va a arrancar aquí, en Start. 00:32:45
Y el Start va a construir un Stage. 00:32:48
El Stage es el marco básico que no tiene nada. 00:32:52
No tiene nada todavía. 00:32:56
En ese stage es como el frame, el marquito 00:32:57
Que no tiene nada 00:33:00
Yo lo más que puedo hacerle es 00:33:00
Hacerle visible 00:33:04
¿Vale? 00:33:06
Y en principio 00:33:13
Lo único que va a hacer esta aplicación mía 00:33:15
Es ese marco, ese stage 00:33:17
Que no tiene nada 00:33:19
Porque no le he puesto nada, pues hacerlo visible 00:33:21
Y ya está 00:33:23
Y la aplicación se va a quedar ahí esperando a que pasen cosas 00:33:24
Que no va a pasar nada 00:33:27
Porque es que no tengo yo ni capturado de bender 00:33:28
Yo he capturado nada 00:33:30
claro, para verlo 00:33:31
habría que ejecutar, ¿vale? 00:33:33
entonces, para ejecutar 00:33:35
tiene que haber un main 00:33:38
¿verdad? y el main 00:33:39
es el que hace el lanzado, entonces 00:33:41
el main 00:33:43
será un método que tenga esto 00:33:45
a ver 00:33:49
hacemos aquí un main 00:33:50
stage es la raíz 00:33:53
de cualquier aplicación con interfaz gráfica 00:33:57
el stage es el marco 00:33:59
De toda la vida, que lo único que tiene es 00:34:01
Esto, un stage es esto de arriba 00:34:04
Con este botón, este botón 00:34:05
Y este botón 00:34:08
¿Vale? Entonces 00:34:09
Vale, pues para que la aplicación 00:34:12
Arranque tiene que tener un main 00:34:36
Porque esto es una aplicación de escritorio 00:34:37
No es una aplicación que la ejecute en su lugar web 00:34:38
Ni la ejecute nadie, es una aplicación de escritorio 00:34:41
La aplicación de escritorio tiene que tener un main 00:34:42
El punto de arranque siempre es el main 00:34:44
Vale, pues JavaFX 00:34:45
Está hecha para que este método 00:34:48
Lance pues 00:34:50
Coja los parámetros que sean 00:34:51
Etcétera, etcétera y ya me lanza este stage 00:34:54
Así es como está 00:34:56
Entonces yo me puedo 00:34:59
Plantear, decir, pues venga 00:35:00
Vamos a arrancar esto 00:35:02
A ver si realmente veo ese frame 00:35:03
Entonces voy 00:35:06
Y me voy al 00:35:08
Runas Hub Application de toda la vida 00:35:09
Y me encuentro con esto 00:35:13
Me dice 00:35:18
Lo siento pero es que no encuentro 00:35:20
las cosas de JavaFX 00:35:22
es que no las encuentro, no puedo lanzar esto 00:35:24
claro 00:35:26
porque esto liga con lo que decíamos 00:35:28
antes, es que 00:35:31
el arrancado no es tan 00:35:32
fácil como antes, ahora 00:35:35
como las librerías de JavaFX 00:35:36
están modularizadas 00:35:39
para arrancar hay que decirle 00:35:40
donde están los módulos para el inbound 00:35:42
entonces eso 00:35:44
se podría hacer creando una configuración 00:35:45
de ejecución, pasándole 00:35:48
rutas del módulo de path, etc 00:35:50
pero podéis preguntar a HGPT 00:35:52
y os dirá unos comandos 00:35:54
no sé que los probáis y al cabo de un rato 00:35:56
pues lo ejecutaré 00:35:58
pero no tiene sentido si estamos usando 00:35:59
maven, que es esto de repente 00:36:02
de pasar de maven, porque cuando yo hago 00:36:04
el runas java application 00:36:06
estoy pasando de maven completamente 00:36:08
estoy ejecutando yo a mano 00:36:10
y encima mal, porque le tengo que pasar parámetros 00:36:11
que no lo estoy pasando 00:36:14
entonces hombre, si he hecho el proyecto con maven 00:36:15
me ha hecho 00:36:18
de las dependencias, muy bien 00:36:20
pero que también me automatice 00:36:22
la tarea de ejecutar 00:36:24
e incorporar 00:36:26
los caminos a los módulos 00:36:29
y todo eso 00:36:30
bueno, pues eso Maven como lo puede hacer 00:36:31
a través de una cosa que se llama 00:36:34
plugin, los plugins de 00:36:36
Maven famosos, entonces Maven 00:36:38
tiene un montón de plugins posibles 00:36:40
que yo puedo configurar en el con 00:36:42
plugin de ejecución, plugin de compilación 00:36:43
plugin de pruebas 00:36:46
y entonces yo lo que haré, ya me olvidaré 00:36:47
de ejecutar la aplicación como java aplicatio 00:36:50
me olvidaré y le diré 00:36:53
oye tú maven 00:36:54
ejecuta tu plugin 00:36:56
de lo que sea, en mi caso 00:36:59
será ejecución 00:37:00
y yo habré configurado ese plugin para que ya se 00:37:01
ejecute correctamente 00:37:04
luego vamos a decir, vamos a 00:37:06
darle a maven un plugin de ejecución 00:37:08
para java fx 00:37:11
con los parámetros 00:37:12
de java fx con toda la información necesaria 00:37:15
pues eso 00:37:17
si volvéis a abrir el que yo os he dado 00:37:18
veis que hay un nodo 00:37:20
plugins 00:37:23
que podéis poner 00:37:25
después del build 00:37:26
¿vale? 00:37:29
perdón, dentro del build, del nodo build 00:37:31
un plugin 00:37:33
un nodo plugins 00:37:36
¿vale? este que tengo comentado 00:37:37
lo ignoráis, esto ya no 00:37:39
¿vale? y 00:37:41
copiáis este 00:37:43
lo copiamos 00:37:45
y ahora lo explico 00:37:47
¿vale? 00:37:54
Entonces, copiamos esto, nos vamos al POM otra vez, build, está sin hacer todavía, pues venga. 00:37:55
Bueno, vamos a copiarlo todo el build entero desde aquí y ya está. 00:38:12
Copiamos todo esto, todo el build con todo el plugin que tiene dentro. 00:38:16
Esto que está comentado fuera, fuera, lo quitamos, así no metemos ruido. 00:38:30
Vale, más bonito así tabulado. 00:38:41
Bueno, pues le he metido un plugin para ejecutar JavaFX, ¿vale? 00:38:46
Le he metido este plugin, se llama JavaFX y es para ejecutar JavaFX. 00:38:59
Y además le estoy diciendo cuál es la clase de arranque de esa ejecución. 00:39:07
La clase de arranque de esa ejecución es uno como lo hayáis llamado. 00:39:15
Primera ventana, pues habrá que cambiarlo. 00:39:20
esdam1.app 00:39:22
cuidado, ponerla 00:39:23
correctamente 00:39:26
primera 00:39:27
ventana, vale 00:39:29
aseguraros que en este plugin 00:39:37
tenéis puesta 00:39:39
la clase main, donde está 00:39:41
vuestro método main 00:39:43
con su nombre completo 00:39:44
que recordad que el nombre completo es el nombre del paquete 00:39:47
siempre, a ver 00:39:49
yo esto de aquí 00:39:55
lo he tenido que poner porque tengo muchas JDK 00:39:56
entonces al tener muchas jdk 00:39:59
si no lo ponía 00:40:01
él tiraba de una jdk que tengo 00:40:02
en la java home porque la necesito para otro 00:40:06
servidor y esa es de 00:40:08
1.8 y 1.8 00:40:10
no era compatible, entonces le he dicho 00:40:12
no, no, tu maven plugin 00:40:14
tu maven ejecútate con esta 00:40:15
si vosotros solo tenéis una jdk 00:40:17
podéis quitar eso, más que nada 00:40:20
porque vuestra ruta ni siquiera será esta a lo mejor 00:40:22
vale, entonces repito 00:40:24
esto es opcional 00:40:27
es para especificar 00:40:29
que JDK va a ejecutar este plugin 00:40:31
entonces 00:40:33
yo he tenido que ponerlo 00:40:35
porque tengo muchos JDK 00:40:36
y entonces el plugin 00:40:39
tira del que tenga en esta variable 00:40:41
otros no tenéis tampoco 00:40:43
y esta tenía otra 00:40:44
pero si vos solo tenéis un JDK instalado 00:40:45
pues esto 00:40:49
lo podéis quitar directamente 00:40:51
pues pon aquí 00:40:53
la que tú quieras usar, pon aquí la ruta 00:40:58
del JDK que deberías poner 00:41:00
la misma en la que 00:41:02
está tu proyecto, la que has puesto para tu proyecto. 00:41:04
Te pones aquí la ruta 00:41:07
ese JDK con el bin java.exe 00:41:08
¿vale? 00:41:11
Porque esta es 00:41:14
la máquina virtual de este JDK. 00:41:14
Pues esta es la 00:41:18
máquina virtual que tiene que ejecutar ese plugin. 00:41:18
Bueno, ¿habéis 00:41:24
copiado el plugin en el Pong? 00:41:25
Vale, para verificar 00:41:35
que no estamos haciendo cosas raras 00:41:36
con el Maven, de vez en cuando 00:41:39
y que está tomando las últimas actualizaciones 00:41:41
hay una cosa que hay que hacer 00:41:43
con cierta regularidad, sobre todo si nos fallan 00:41:45
las cosas, que es 00:41:47
actualizar 00:41:49
reconstruir el proyecto 00:41:50
con los cambios que hemos hecho 00:41:52
entonces si al proyecto 00:41:54
le dais botón derecho 00:41:57
y os vais a 00:41:59
Maven 00:42:03
a la pestaña 00:42:05
al ítem Maven 00:42:07
hay una cosa que pone actualizar proyecto 00:42:09
entonces conviene 00:42:11
cuando hacéis cambios en el POM o algo 00:42:13
os vais ahí 00:42:15
botón derecho, maven 00:42:17
actualizar proyecto 00:42:19
marcáis 00:42:20
que proyecto maven quieres actualizar 00:42:23
ese 00:42:25
si no os da ningún error 00:42:25
es que lo que habéis puesto en el POM no es ninguna burrada 00:42:28
significa eso que luego va a funcionar todo 00:42:31
pero bueno 00:42:33
Bueno, hasta aquí hemos llegado todos. 00:42:39
Tenemos ya el plugin puesto. 00:42:41
Vale, pues este es al que hay que llamar para decirle, 00:42:43
oye, tú, lanza la ejecución. 00:42:48
Porque tú, plugin de Maven, sí que sabes entenderte con los 00:42:50
módulos, sabes recuperarlos, encontrarlos tú y sabes 00:42:54
entenderlos. 00:42:58
Entonces, ahora ya, cuando usamos Maven, 00:42:59
se acabó el Runas Java Application. 00:43:02
Se acabó. 00:43:05
Ahora usando maven 00:43:06
Hay que ejecutar maven 00:43:08
Y decirle a maven 00:43:11
Tú, lánzate con este plugin 00:43:12
Vale 00:43:15
Pues como hacemos eso, ya se acabó 00:43:16
El, repito 00:43:19
El runas java application, es decir 00:43:21
Esto 00:43:23
Este runas java 00:43:23
Application se acabó 00:43:27
Este ya nada 00:43:28
Porque si usamos esto 00:43:31
estamos tratando de ejecutar la aplicación 00:43:34
pasando de Maven 00:43:37
y eso es lo que no nos funciona 00:43:38
porque pasar de Maven implica 00:43:40
ya no gestionar los módulos, etc. 00:43:43
Entonces, ¿qué es lo que tenemos que dar? 00:43:45
Maven Build 00:43:49
que es, oye tú 00:43:49
venga, dale 00:43:51
sí 00:43:53
porque es otra cosa 00:43:57
el Maven Clean es limpio en el proyecto 00:44:01
de mierdas, de dependencias que ya no 00:44:03
uses, quítalas del path, etc. 00:44:05
vale, pues entonces 00:44:08
vale, pues entonces 00:44:10
Maven Bill me dice 00:44:17
ah, muy bien, vale 00:44:18
entonces aquí ya 00:44:20
nos contesta Maven a la orden que hemos dado 00:44:21
tú Bill 00:44:24
pues él nos contesta 00:44:25
y nos dice, muy bien, pero ¿qué hago? 00:44:27
me dice, ¿cuál es tu objetivo en la vida? 00:44:31
te pide que se lo escribas aquí en Gold 00:44:34
vale, yo me he despertado 00:44:36
pero ahora que quieres que ejecute 00:44:38
yo, que quieres que haga 00:44:41
pues maven que es lo que 00:44:43
puede ejecutar, a quien puede 00:44:45
llamar a los plugins 00:44:47
pues venga, ya tenemos uno 00:44:49
que es este plugin de aquí 00:44:51
no puedo cerrar esto 00:44:53
bueno da igual, ya tenemos uno que es 00:45:00
este que hemos 00:45:04
puesto, que se llamaba java fx 00:45:06
verdad, era java fx maven 00:45:08
plugin, pues vamos a llamarlo 00:45:10
así java 00:45:12
es decir, aquí 00:45:15
le ponemos el nombre del plugin 00:45:17
que queremos que lance 00:45:20
que es el que hemos puesto 00:45:22
el nombre, que era java fx 00:45:23
y ahora, pero el plugin puede 00:45:25
hacer muchas cosas 00:45:28
ese plugin puede hacer un montón de historias 00:45:29
pero no, lo que queremos es que ejecutar 00:45:32
queremos que te ejecutes 00:45:34
queremos que hagas la ejecución 00:45:35
no que hagas la 00:45:38
compilación y nada, pues dos puntos 00:45:40
run, esto solo se hace 00:45:42
una vez, luego ya se queda guardado 00:45:44
no os luchéis, vale 00:45:46
llave fx porque es 00:45:48
el nombre del plugin, dos puntos 00:45:54
la orden que queremos 00:45:57
que ese plugin haga, que es 00:45:59
ejecutar, y ahora 00:46:00
en name 00:46:04
si le dais un nombrecito 00:46:06
ya esa configuración 00:46:08
se queda guardada, y a partir de ahí 00:46:10
la ejecución va a ser dar simplemente 00:46:12
ese nombre, entonces acordaos 00:46:14
del nombre que hay aquí o ponedle otro 00:46:16
si queréis, lo que os dé la gana. 00:46:18
Tiene sentido que sea el nombre del propio 00:46:20
proyecto. Así yo cuando lo quiero ejecutar, llamo a ese 00:46:22
proyecto y ya está. 00:46:24
Pues venga. Y podemos aprovechar y darle 00:46:26
a run. 00:46:28
Y ahora 00:46:33
ya está. 00:46:34
¿Vale? Esta es nuestra aplicación. 00:46:39
Este es un 00:46:42
stage. La ventanita 00:46:42
con esto y punto pelota. 00:46:44
Pena, ¿por qué? 00:46:48
Porque está esperando y no le vamos a dar nada 00:46:49
Bueno, pero ya se lo iremos dando 00:46:51
Bien 00:46:53
Vale 00:46:53
Pues 00:47:01
Así se ha quedado la cosa 00:47:02
Si le dais a la X 00:47:05
La aplicación se cierra 00:47:09
Ya está combinado 00:47:10
No, o sea, la compilación es automática 00:47:13
En Eclipse y en Maven cuando tú ejecutas 00:47:21
A ver, hay un goal de Maven que es 00:47:23
el compil. O sea, si tú quieres 00:47:24
compilar sin más, pues tú 00:47:26
puedes hacer aquí un 00:47:28
donde estoy 00:47:30
runas, maven build 00:47:34
y ahora quiero, oye, ¿qué 00:47:36
plugin quiero? Quiero el compiler 00:47:38
que siempre existe, que lo habíamos hecho. 00:47:40
Tú, compiler, ¿qué quiero que hagas? 00:47:42
Compilar, compile. 00:47:45
Con esto estás forzando 00:47:48
solo una compilación, por ejemplo. 00:47:50
Pero bueno, como la compilación se hace 00:47:52
siempre previa a una ejecución, 00:47:54
¿Y el Eclipse ya la hace automáticamente? 00:47:56
Bueno, ya, pero entonces tú lo tendrás que exportar, entonces. 00:48:07
Exportarlo a un hardware. 00:48:13
Cualquier aplicación Java, si tú la quieres distribuir, la tienes que exportar a un hardware. 00:48:14
¿Vale? 00:48:19
¿Exe jamás? 00:48:20
no, porque esto no es un lenguaje 00:48:26
de compilación compilado, sino interpretado 00:48:29
entonces no genera 00:48:31
un .exe, genera un hard 00:48:33
que la máquina virtual del equipo que sea lo ejecute 00:48:34
pero bueno, ya lo haremos 00:48:37
vale, ¿a todo el mundo 00:48:39
le ha funcionado? 00:48:41
no puede ser 00:48:42
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:
18 de abril de 2026 - 11:15
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
48′ 49″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
194.34 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid