Saltar navegación

20251014 DOM_2 - Contenido educativo

Ajuste de pantalla

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

Subido el 20 de noviembre de 2025 por Raquel G.

9 visualizaciones

Más información Transcripción

Descargar la transcripción

este es nuestro único dato de configuración 00:00:00
es el que ponemos aquí, en el gestión 00:00:03
properties, que nos hemos vuelto locos 00:00:05
con los datos, o sea, con el nombre 00:00:07
y ahora me viene a mí a la cabeza 00:00:09
así que 00:00:10
normalmente a esto 00:00:13
lo solemos 00:00:14
ver con este nombre, ¿verdad? 00:00:17
no suena más que este nombre 00:00:18
casi que me viene a uno un fogonazo 00:00:20
a la cabeza que me suena más esto 00:00:23
para indicar que es un archivo de configuración 00:00:24
¿verdad? vale 00:00:27
Bueno, pues entonces 00:00:28
Eso ya nos permite 00:00:30
Aquí 00:00:34
Quitar esta cosa tan horrible 00:00:34
Y vamos a sacar 00:00:37
El nombre del archivo de configuración 00:00:39
Y esto, para eso teníamos que crear 00:00:41
Properties 00:00:44
A ver 00:00:47
No sé si 00:00:49
La memoria 00:00:50
Me va 00:00:53
Si no 00:00:55
Y ahora ya 00:00:57
Habríamos 00:01:00
Una configuración 00:01:01
Que cargábamos desde properties 00:01:04
Vamos a mirarlo 00:01:06
Aquí que estará 00:01:08
No, estaba en el otro, ¿verdad? 00:01:10
No, aquí no estaba 00:01:20
Lo del properties 00:01:22
Joder, que no quiero yo este 00:01:28
Quiero 00:01:30
UDF 00:01:30
No, pero 00:01:35
Pero, ¿dónde estáis viendo? 00:01:37
Yo aquí no estoy viendo 00:01:40
Abre, abre, abre 00:01:41
Ah, aquí está 00:01:44
Vale, vale, vale 00:01:47
Aquí está 00:01:47
Vale, entonces 00:01:49
Que sí, que es este 00:01:50
Yo quiero esto 00:01:53
Esto quería yo 00:01:56
No, perdono a nadie 00:01:59
Vale, entonces 00:02:03
Esto quería yo 00:02:06
Vale 00:02:10
¿Pero qué paquete equivocado? 00:02:11
Tú sí quieres un paquete equivocado 00:02:15
No es un paquete equivocado 00:02:17
A ver 00:02:19
Load y ahora 00:02:21
PropGetProperty 00:02:23
Esto está estupendo 00:02:25
Vale, entonces lo hacíamos así, ¿verdad? 00:02:26
Ahora importo 00:02:28
Y ahora prop.getProperty 00:02:29
Y queremos 00:02:32
Datos, se llamaba 00:02:34
Datos, vale 00:02:36
Esta no la quiero 00:02:38
Esta la cierro ya 00:02:41
Vale 00:02:42
Vale, y esto lo teníamos que meter 00:02:44
En un try-catch, ¿verdad? 00:02:50
Vale, entonces 00:02:53
Aquí 00:02:55
Podríamos 00:02:56
Dejarlo así, pero 00:02:58
Hombre, para no 00:03:02
Estar todo el rato aquí atentos a la 00:03:06
consola y todo eso, vamos a hacer 00:03:08
unos pequeños logs de depuración 00:03:10
¿no? vamos a hacer unos pequeños 00:03:12
logs, vale, pues para hacer 00:03:14
unos pequeños logs de depuración 00:03:16
ya sabemos que rápidamente copiamos la dependencia 00:03:18
de nuestro ejemplo 00:03:21
de proyecto de logs 00:03:22
¿que ya te has 00:03:24
perdido? 00:03:26
pues 00:03:28
hola 00:03:29
hola, ¿puedo pasar? 00:03:32
puedes pasar 00:03:35
Acostumbraos a pedir permiso antes de entrar 00:03:37
Bueno, lo ideal sería 00:03:39
Primero pedir disculpas por llegar tarde 00:03:41
Y luego pedir permiso 00:03:43
¿Vale? 00:03:44
Dime 00:03:45
Bueno, lo importáis a mano 00:03:45
Ah, pues habéis empeñado 00:03:55
Pero es un caos 00:03:58
Vale, bueno, pues entonces 00:04:00
Estábamos diciendo 00:04:02
Que vamos a aprovechar 00:04:03
a poner en práctica lo de los logs 00:04:06
¿vale? para hacer algunos 00:04:08
logs en esta aplicación 00:04:10
no lo vamos a hacer lo de los logs, el resto de aplicaciones 00:04:12
que hagamos pues nos eternizamos, pero bueno 00:04:14
en esta sí, como lo acabamos de ver el otro día 00:04:16
en esta sí, para ponerlo en práctica y ya está 00:04:18
entonces para poner en práctica 00:04:20
lo de los logs, vamos a 00:04:22
copiar la dependencia 00:04:24
yo tengo que tener por ahí el de logs 00:04:27
ejemplo logs 00:04:33
aquí está 00:04:37
Vale, pues vamos a 00:04:37
Copiar 00:04:41
Las dependencias de log 00:04:45
Las de 00:04:48
Jason, puedo pasar de ellas 00:04:50
Porque vamos a configurar 00:04:52
Con el xml 00:04:54
Y aquí, abrimos nuestro 00:04:55
POM 00:05:02
De este 00:05:03
Este 00:05:05
Que está limpio 00:05:11
Abrimos nuestro POM 00:05:13
Vale 00:05:15
Vale 00:05:16
Vamos a quitar esta cosa 00:05:26
Rojita tan fea 00:05:29
Claro, he copiado y pegado 00:05:31
Del POM del archivo del otro día de logs 00:05:35
Que está subido a la ola virtual 00:05:37
He copiado 00:05:40
Las dos primeras dependencias 00:05:42
Porque las otras eran para JSON 00:05:44
Vale, entonces recordad 00:05:46
Que de una clase a otra miraros las cosas 00:05:48
Porque si no 00:05:50
Estáis perdidos en la clase siguiente 00:05:52
Vale, pues entonces 00:05:54
Las dependencias de logs 00:05:57
Ya las tengo teóricamente 00:05:59
Vamos a ver 00:06:00
Si realmente están aquí 00:06:02
Sí 00:06:04
Aquí tengo el API y el core de los 4J 00:06:07
Ahora 00:06:11
Necesito el fichero de configuración 00:06:12
Vamos a copiarnos 00:06:15
Y pegarnos el otro 00:06:17
Y le fumigamos lo que no queramos 00:06:18
Pues vamos a copiar 00:06:20
El de los 4J del otro día 00:06:22
El XML este 00:06:26
Le copiamos 00:06:28
Y le pegamos 00:06:31
En resources 00:06:35
Le voy a poner el nombre bien 00:06:36
Del archivo del otro día 00:06:42
Del proyecto del otro día 00:06:46
Lo he sacado 00:06:47
Del proyecto de logs del otro día 00:06:48
Vale, entonces ahora vamos a abrirlo 00:06:51
Y vamos a quitar lo que no nos interese 00:06:55
Venga 00:06:57
Vamos a 00:06:59
Los appenders los podemos dejar 00:07:00
Y ahora 00:07:03
Vamos a loggers 00:07:05
Venga, pues no vamos a hacer un logger 00:07:06
Específico para cada clase 00:07:09
Este logger 00:07:10
Voy a quitar 00:07:14
En los archivos 00:07:17
En los archivos de configuración 00:07:20
Más que quitar 00:07:22
Lo mejor es comentar 00:07:26
por si luego lo quieres volver a usar 00:07:28
vale 00:07:30
entonces 00:07:32
vale y dejamos 00:07:33
el logger raíz 00:07:36
el logger raíz 00:07:37
lo vamos a poner a nivel depuración 00:07:40
porque estamos en la fase inicial 00:07:42
y que los logs 00:07:44
nos vayan a 00:07:48
consola y al fichero 00:07:49
y ya está, ya tenemos un fichero de logs 00:07:51
para enviar logs básico a un archivo 00:07:55
y a consola también 00:07:57
Se va a quedar ahí la consola 00:07:59
Si la quiero quitar, pues la quito 00:08:00
Y va solo al archivo y ya está 00:08:02
Bueno, le he puesto 00:08:04
Que inicie con esto y termine con esto 00:08:09
Y ya está 00:08:11
Vale 00:08:12
Vale, pues entonces 00:08:13
Vamos a arrancar la aplicación 00:08:23
Para ver si 00:08:28
Bueno, y ahora ya que tenemos el archivo de logs 00:08:29
Que menos 00:08:32
Que ponerle aquí un log 00:08:33
Bueno, crear el logger, claro, lógicamente 00:08:35
Y esto 00:08:37
Era de 00:08:43
GetLogger 00:08:45
A ver si 00:08:47
LogManagerGetLogger era 00:08:48
Mira que buena memoria tenéis 00:08:51
LogManager.getLogger 00:08:53
Y aquí pues nuestra clase 00:08:57
Gestión 00:09:01
Biblioteca 00:09:03
Punto clase, el hacerlo específico 00:09:05
para esta clase, nos permitiría luego configurar la parte 00:09:07
si queremos, logger y logger 00:09:10
lo importamos 00:09:12
de, no de java útil login 00:09:13
no, de aquí 00:09:15
que es la dependencia que hemos 00:09:17
importado, la de arriba es el log 00:09:19
la herramienta 00:09:21
de logs de java estándar, pero no 00:09:24
queremos esa que es muy básica, esta 00:09:25
sería esto 00:09:27
esto de aquí 00:09:33
Vale, entonces 00:09:37
Ahora ya 00:09:51
Tenemos un log 00:09:52
Vamos a hacer un log info 00:09:55
Para informar de que la aplicación 00:09:57
Ha arrancado y así el 00:09:59
Técnico sabe 00:10:01
A qué hora se inició 00:10:03
Joder 00:10:05
Sí 00:10:07
De Apache 00:10:14
No de Java útil 00:10:18
Java útil es otra herramienta de logs 00:10:19
Que funciona parecido 00:10:21
Pero no es la que más se usa y es más básica 00:10:22
Esa está directamente en el JDK 00:10:25
Por eso no necesita dependencia 00:10:27
Log info, vale, arrancando aplicación 00:10:28
Y ahora aquí 00:10:31
Pues podríamos hacer un log 00:10:32
Punto error 00:10:34
Si entramos aquí, dejo 00:10:37
No se pudo 00:10:42
Arrancar 00:10:46
No se pudo 00:10:48
Encontrar 00:10:49
properties, no se pudo encontrar 00:10:52
con lo cual si no se pudo encontrar 00:10:58
properties 00:11:00
ahora ya dentro de este catch 00:11:01
podríamos decir 00:11:04
arrancando con un fichero 00:11:06
estándar y cargar 00:11:08
y instanciar 00:11:11
gestión de biblioteca 00:11:13
con un estándar, es decir 00:11:14
esto, claro 00:11:16
por ejemplo 00:11:18
string num 00:11:21
fichero 00:11:23
Aquí esto lo haríamos 00:11:25
La idea es que la aplicación sea lo más robusta posible 00:11:30
Y nunca pare 00:11:32
Entonces aquí haríamos esto 00:11:33
Y aquí si hemos conseguido 00:11:36
Cargarlo, pues haríamos 00:11:38
Non fichero 00:11:40
Igual a 00:11:42
Esta propiedad, pero si no hemos podido 00:11:43
No se pudo encontrar properties 00:11:46
Usamos 00:11:48
Un fichero 00:11:52
Genérico, yo que sé 00:11:54
Fichero 00:11:55
Cualquier cosa 00:11:58
Y entonces ahora ya pondríamos 00:12:01
Darle la oportunidad de escribir a quien 00:12:02
A el usuario 00:12:10
Eh, sí, pero 00:12:11
El usuario tiene que estar ahí sentado 00:12:14
Y, vale 00:12:16
No un fichero 00:12:20
Igual a, y aquí ya haríamos cualquier cosa 00:12:21
El que uno le dé la gana, yo que sé 00:12:25
Arrancamos con uno estándar 00:12:28
Por lo menos la aplicación no se para 00:12:32
¿Vale? 00:12:33
Entonces vamos a hacer un par de logs 00:12:38
Solo pues para ver si realmente nos funciona 00:12:41
Y se va el fichero de logs 00:12:43
Y luego ya no vamos a estar arrastrando logs todo el rato 00:12:44
Porque se hace un poco pesado 00:12:46
Pero sería lo ideal, o sea lo ideal es que uno 00:12:48
Ponga logs en todas partes 00:12:50
De diferentes niveles, de bug, info, error 00:12:52
Para luego tener control 00:12:55
Sobre lo que está pasando 00:12:57
Pero nosotros no lo vamos a hacer 00:12:58
Venga, pues vamos a hacer este primer arranque 00:12:59
A ver si gestión se instancia correctamente con el... 00:13:03
Y aquí pondríamos numfichero, perdón 00:13:09
Aquí pondríamos numfichero 00:13:11
Y me dice, ¿podría no estar inicializado? 00:13:14
Yo sé que estaría, porque o bien es este o bien es este 00:13:20
Pero bueno, le callo al compilador 00:13:23
Con eso le dejo callado 00:13:25
Vale, vamos a ver si hasta aquí llegamos 00:13:26
Porque no hemos hecho nada 00:13:29
Nada más que instanciar el objeto 00:13:31
Y mirad cuánta basura 00:13:34
¿Por qué os creéis que existen 00:13:35
Los frameworks? 00:13:37
Porque los frameworks 00:13:40
Spring, Hibernate, todo eso 00:13:41
Gestionan 00:13:43
Los bins, todo 00:13:46
Pero los gestionan 00:13:48
Metiendo toda una cantidad de cosas 00:13:50
Vale, fijaos 00:13:54
Todo lo que hemos hecho 00:13:57
Solo para instanciar gestión de biblioteca 00:13:58
Pero claro, es que es así como tenemos que hacer 00:14:01
Ay, perdona, dime 00:14:04
Pues el import de log manager 00:14:06
El import de log manager 00:14:08
Porque hay otro aquí 00:14:13
Que es con 00:14:17
Otro log4j 00:14:18
Aquí creo que hay, no lo sé 00:14:20
¿Cuál? Este que he puesto yo, que te da error 00:14:22
Pero te dice, porque no lo encuentra 00:14:25
Dice que cohesiona con otro 00:14:31
Pues quítalo 00:14:33
Es que igual tienes otro 00:14:35
Vale, vamos a arrancar este main 00:14:37
Vamos a arrancar este main 00:14:43
A ver hasta donde llegamos 00:14:45
Pues sí, por eso lo voy a arrancar desde ya 00:14:46
¿Por qué me dices tú que la ruta va a dar error? 00:14:50
Claro, pero 00:14:55
Esto podría inducir a error 00:14:56
Y por eso yo lo estoy generando 00:14:58
Porque resources 00:15:00
Es una ruta del classpath 00:15:02
Del sistema 00:15:05
Por definición para maven 00:15:06
Si está en el classpath 00:15:08
¿Cómo no lo va a encontrar si está en el Clashpad? 00:15:09
Claro, pero estar en el Clashpad 00:15:13
Significa que la máquina virtual 00:15:17
Encuentra 00:15:19
Las cosas que estén 00:15:20
No, por encima no 00:15:22
Los import, el Clashpad es para los import 00:15:23
No es para los recursos 00:15:26
¿Vale? 00:15:27
El Clashpad es para esto 00:15:29
La máquina virtual de Java 00:15:30
Cuelga todas estas cosas 00:15:32
Desde su Clashpad 00:15:34
Entonces 00:15:36
Lo que esté en el 00:15:37
Los import 00:15:40
Los va a encontrar 00:15:41
Si todo esto 00:15:42
Cuelga del classpad 00:15:44
Que 00:15:45
Es el caso 00:15:46
Pero 00:15:47
Eso no significa 00:15:48
Que los recursos 00:15:49
Los vaya a encontrar 00:15:52
Entonces 00:15:56
Vamos a ejecutar este main 00:15:57
Una cosa son los recursos 00:16:00
Otra cosa son las clases 00:16:03
Y ahora 00:16:04
Me dice efectivamente 00:16:07
Not found exception 00:16:08
Me ha arrancado el log 00:16:09
Arrancando aplicación 00:16:10
Entonces 00:16:11
uno no tiene que estar sentado en la consola 00:16:12
viendo esto, lógicamente 00:16:15
la consola de un servidor 00:16:17
se llena de millones de cosas 00:16:19
de las 200.000 aplicaciones que están gestionando 00:16:20
entonces no podemos estar mandando el log a la consola 00:16:22
todo el rato, nosotros hemos 00:16:24
mandado el log a la consola 00:16:26
y de hecho hemos dejado el print extract trace 00:16:28
porque estamos ahí 00:16:30
sentaditos, pero cuando la aplicación 00:16:32
está en producción ya no hay nadie 00:16:35
mirando esta consola, pero 00:16:36
si podríamos venir 3 horas 00:16:38
después y abrir este fichero 00:16:41
vale, podríamos 00:16:43
venir tres horas después 00:16:48
y abrir este fichero y este fichero me dice 00:16:49
ah mira, la aplicación arrancó a las 00:16:52
9.48, ostras 00:16:54
pero mira, está trabajando con un fichero 00:16:56
estándar porque no lo pudo arrancar 00:16:58
ya ve rápidamente que hay un error, entonces 00:17:00
esto si es útil, que ese fichero esté ahí 00:17:02
para que uno venga tres horas después, no una 00:17:04
consola que está 00:17:06
sacando millones de cosas de las millones de 00:17:07
aplicaciones que se están corriendo en ese servidor 00:17:10
vale 00:17:12
Pues entonces, efectivamente, nuestro problema ha sido que esto no lo ha encontrado. 00:17:14
Claro, porque tenemos que convertir esto que es un recurso a un inputString mediante el método que lo permite. 00:17:22
Entonces, vamos a hacerlo bien. 00:17:33
Es decir, esto no funciona. 00:17:36
Porque a veces lo he visto 00:17:41
Para que no caigáis en esos 00:17:47
No encuentra el fichero 00:17:50
Así no encuentra el fichero 00:17:53
Entonces vamos a hacerlo 00:17:56
Bien 00:17:57
A ver 00:17:58
Vale 00:17:59
Pues necesitamos sacar 00:18:03
El input string 00:18:05
Para este 00:18:07
Esta es la sentencia que queremos hacer 00:18:08
Pues el 00:18:12
Este 00:18:16
Pues este input string 00:18:17
No lo queremos sacar así directamente 00:18:20
Instanciando un file input string 00:18:23
Ese ha sido nuestro problema 00:18:25
Porque no he encontrado ese fichero pero no está en la ruta 00:18:26
Pues vamos a sacar primero el input string 00:18:28
Convirtiendo el recurso a flujo 00:18:31
Entonces 00:18:33
Esto se hace 00:18:34
Mi clase se llama 00:18:36
Gestión biblioteca 00:18:38
Se llamaba 00:18:40
Con gestión biblioteca 00:18:40
gestión biblioteca 00:18:46
tiene un 00:18:51
perdón 00:18:52
no, porque es el nombre 00:18:55
de la clase, una cosa es 00:18:59
el nombre de la clase, otra cosa es el objeto 00:19:00
vale, entonces, ¿qué método era 00:19:02
este? 00:19:05
es que a saber en qué 00:19:10
proyecto lo tengo, espera, vamos a preguntárselo 00:19:11
a este rápidamente 00:19:13
A ver si me resuelve rápido 00:19:14
Para convertir 00:19:19
Recurso 00:19:22
En stream 00:19:25
En java 00:19:26
A ver si se ha enterado 00:19:28
Ah mira 00:19:31
Vale 00:19:35
Ah esto, vale que me falta el class 00:19:35
Vale, vale, vale, por eso no me salía el método classloader 00:19:44
Vale, pues entonces 00:19:47
Esto es 00:19:49
Gestión biblioteca punto class 00:19:51
Que era lo que me faltaba 00:19:53
Y ahora ya 00:19:54
GetClassLoader 00:19:56
¿Qué? 00:20:00
Sí 00:20:02
GetClassLoader 00:20:03
Y ahora convierto con el método este 00:20:07
GetResourceAsStream 00:20:10
Ahora ya sí este 00:20:12
Vale 00:20:14
Me voy a bajar con los puntitos abajo 00:20:25
Para que se vea mejor 00:20:28
Entonces cada clase 00:20:30
Tiene un objeto cargador 00:20:33
Cada clase tiene un objeto cargador 00:20:35
Que yo lo puedo sacar 00:20:37
Mi clase, si yo le doy a punto class 00:20:39
Tiene un objeto cargador 00:20:41
Que me permite a mí 00:20:43
Hacer muchas cosas, entre ellas 00:20:45
Este recurso 00:20:47
Que está en la carpeta de recursos 00:20:49
Convertirlo a una serie 00:20:50
Y eso ya es independiente del classpath y de todo 00:20:52
Y ahora ya este is 00:20:55
Lo podemos meter aquí 00:20:57
Y vamos a importar input string 00:20:58
De java.io, claro 00:21:01
Ya está 00:21:02
entonces ya he convertido 00:21:04
este recurso que está en la carpeta 00:21:06
resources, lo he convertido en flujo 00:21:09
y ahí ya salvo todo mi problema 00:21:11
del classpath y de todo 00:21:13
y esto es lo que hace por dentro el log4j 00:21:14
ahora ya si que podremos 00:21:17
arrancar, espero 00:21:21
espero 00:21:22
con nuestro 00:21:24
vale 00:21:26
vamos a ver si la aplicación 00:21:27
aquí arranca correctamente 00:21:31
perfecto 00:21:32
ha arrancado la aplicación 00:21:36
el log me lo dice arrancando aplicación 00:21:39
y ya está 00:21:42
pues ala, hemos pasado el primer escollo 00:21:43
bueno 00:21:46
primer escollo salvado, ahora ya vamos 00:21:49
a leer y hacer cosas 00:21:55
con el xml, vale 00:21:56
pues venga 00:21:58
cuando yo instancio 00:22:04
inicializo el fichero 00:22:08
y ahora ya lo primero que vamos a 00:22:10
hacer va a ser cargar 00:22:12
el DOM, eso es lo primero 00:22:14
que vamos a hacer, cargar el DOM 00:22:17
vale 00:22:18
pues vamos a cargar el DOM mediante este 00:22:20
método 00:22:22
vale, vamos a ponerlo aquí 00:22:23
no voy a hacer comentarios 00:22:26
javadoc para no que quede muy 00:22:31
pesado, cargamos 00:22:33
el árbol 00:22:36
DOM 00:22:38
desde el 00:22:39
fichero.xml 00:22:42
esto es lo que va a hacer este método 00:22:44
vale 00:22:46
cargar el árbol DOM y ese árbol DOM 00:22:47
guardarlo aquí, para que ahora ya el resto de 00:22:50
métodos puedan usarlo, ya está 00:22:51
pues venga, ¿cómo se carga el árbol DOM? 00:22:53
pues para eso 00:22:56
tenemos 00:22:57
vale, mi clase tiene como parámetros clave 00:22:58
propiedades clave, el fichero 00:23:06
el recurso 00:23:08
donde está el XML, el recurso 00:23:10
que este es el que acabamos 00:23:11
de instanciar 00:23:14
así 00:23:15
¿verdad? new file, fichero 00:23:17
Lo acabamos de instanciar, este objeto fichero 00:23:19
Y ahora 00:23:22
Tiene otra propiedad que es el DOM 00:23:23
Y ese DOM 00:23:26
Vamos a parsearlo 00:23:28
Cargarlo desde el fichero 00:23:30
Mediante este método 00:23:31
Que ahora mismo está vacío, pero vamos a completarlo 00:23:32
Este método está aquí abajo 00:23:34
Vale, pues ahora ya sí 00:23:35
Para parsear, cargar 00:23:38
Ese 00:23:41
Uy, he puesto el comentario donde no era 00:23:42
Perdón, control x 00:23:45
Aquí era 00:23:47
Vale, pues para cargar el árbol DOM 00:23:48
Desde el fichero xml 00:23:53
Tenemos que primero 00:23:54
Instanciar una factoría 00:23:59
Ahora hablamos de un poquito de las factorías 00:24:00
Que esto 00:24:03
El document builder factory 00:24:07
Esto, a ver 00:24:08
Aquí sí que tengo que mirar la 00:24:11
New instanera 00:24:13
No, no hace falta mirar la chuleta 00:24:14
Factory 00:24:16
Punto 00:24:21
New instance 00:24:22
vale, primero 00:24:25
instanciamos este objeto 00:24:33
este objeto como veis 00:24:40
se ha importado 00:24:43
document builder factory 00:24:44
de aquí 00:24:47
vale 00:24:50
voy a quitar este para luego cuando 00:24:51
se ha importado de aquí 00:24:59
vale, ahora 00:25:04
este objeto que es, este objeto es un objeto 00:25:05
que se llama factoría 00:25:08
es otro patrón de diseño más 00:25:09
en realidad, patrones de diseño ya nos suenan 00:25:12
el singleton 00:25:15
que es una forma de programar 00:25:17
en la cual 00:25:19
los constructores 00:25:21
están prohibidos 00:25:23
y lo que nos ofrecen las clases 00:25:24
son métodos get 00:25:27
y ese get ya se preocupa 00:25:29
cuando tú lo invocas de mirar si hay ya alguna 00:25:31
instancia hecha, si hay alguna instancia hecha 00:25:33
te devuelve esa instancia 00:25:35
y si no hay ninguna ya te crea un objeto propio 00:25:36
y así nos aseguramos de que no hay 00:25:39
múltiples instancias cuando 00:25:41
solicitamos un objeto, múltiples 00:25:43
instancias del mismo objeto cuando no nos 00:25:45
hacen falta, vale, ese es el 00:25:47
patrón singleton, el DAO pues ya lo sabemos 00:25:49
y con ese trabajaremos más, claro 00:25:51
porque es de acceso a datos 00:25:53
y lo del patrón factoría que tiene muchos detalles 00:25:54
y uno puede averiguar 00:25:57
se trata de 00:25:59
como estamos, cuando tenemos un framework 00:26:00
de lo que sea, en este caso un framework de xml 00:26:03
un framework de 00:26:05
acceso a lo que sea 00:26:06
muchas veces hay que instanciar muchos objetos 00:26:09
bueno, pues la forma de organizar 00:26:12
eso es 00:26:14
yo me hago una clase 00:26:15
que es una clase que se llama factoría 00:26:18
que en este caso es esta 00:26:20
acaban con el nombre factor 00:26:21
y me hago una clase factoría 00:26:24
y esa clase sirve 00:26:25
para instanciar 00:26:27
objetos de muchas otras 00:26:30
y ya está, entonces yo ahora voy a tener que 00:26:31
instanciar cosas 00:26:34
pues las instancio 00:26:35
a través de esta que es la fábrica 00:26:37
de objetos, es como una fábrica de objetos 00:26:39
descrito muy por encima 00:26:41
vale 00:26:43
bueno pues esta fábrica de objetos 00:26:43
me va a permitir ya 00:26:47
instanciar un document 00:26:49
builder 00:26:51
el document builder 00:26:52
te lo instancia 00:27:00
document builder factory 00:27:02
mediante 00:27:05
creo que new document builder 00:27:07
ese, ya está 00:27:09
vale, vamos a 00:27:11
importar document builder 00:27:13
de java xml parsers 00:27:15
y esto 00:27:17
me puede 00:27:19
dar una excepción 00:27:21
pues no pasa nada 00:27:22
vale, aquí estaría bien 00:27:24
poner un log, pero no vamos a arrastrarlo todo el rato 00:27:32
ya sabéis la dinámica 00:27:35
log de todo lo que me apetezca documentar 00:27:36
en un fichero, ya está 00:27:38
si son errores, log error, si es información 00:27:40
sin más, log info, si es detallitos 00:27:42
De depuración, log.debug 00:27:44
Como, pues por ejemplo aquí 00:27:46
Podría, yo que sé 00:27:48
Poner un log.debug 00:27:50
Aquí lo que pasa es que 00:27:54
El logger tendría que 00:28:01
Sacarlo 00:28:03
El logger tendría que ponerlo 00:28:04
Como variable de clase 00:28:08
Y aquí un logger 00:28:09
Entrando 00:28:16
Otra 00:28:26
Cargando documento 00:28:29
Entonces este sería un log 00:28:34
De mucho detalle 00:28:38
Un montón, la información de que estoy cargando documento 00:28:39
Solo lo necesito 00:28:43
En mi fase de depuración 00:28:45
Cuando estoy en una fase inicial del desarrollo 00:28:46
Cuando yo ya mande 00:28:48
Esta aplicación a producción 00:28:51
No entraré acá a quitar estos logs 00:28:52
Esa es la ventaja 00:28:55
Sino que lo que haré será irme aquí 00:28:56
Y aquí poner error 00:28:58
en cuanto pongamos aquí error 00:29:00
ya está, ya no va a salir todo eso 00:29:05
pero mientras 00:29:07
esté en la fase de depuración inicial 00:29:09
pues lo dejo así para verlo 00:29:11
todo en el fichero 00:29:13
vale 00:29:14
la ventaja 00:29:18
de que sea los 4J 00:29:20
y no los 4 normal 00:29:23
es que cambiándolo aquí 00:29:25
no tengo que reiniciar la aplicación 00:29:27
la aplicación cada cierto tiempo va a mirar 00:29:29
si ha habido algún cambio 00:29:31
¿Cada cuánto tiempo? 00:29:32
Cada lo que configure 00:29:34
Una variable que es 00:29:36
Monitor intervalo, aquí está sin configurar 00:29:39
Luego lo tendrá por defecto 00:29:41
Pero bueno, nos da igual 00:29:42
Vale 00:29:43
Venga, esto ya no me interesa 00:29:45
¿Dónde estamos? 00:29:48
Aquí 00:29:51
Vale 00:29:51
Ah, sí, sí, claro, porque estoy en 00:29:54
A menos que lo quisiera 00:29:59
Bueno, espera, más que estático 00:30:03
Que queda muy feo 00:30:07
O lo pasemos por aquí 00:30:08
O que lo, vale 00:30:10
Pero bueno, venga, más cómodo que sea 00:30:12
Si no 00:30:15
Se lo ponemos a biblioteca y ya está 00:30:27
Pero vale, casi 00:30:29
Venga, pues hala 00:30:30
¿Dónde estamos? Encargar documento 00:30:31
El document builder factory 00:30:35
El document builder 00:30:38
Y ahora 00:30:40
Podemos tratar de parsear 00:30:40
El árbol 00:30:44
Que es este doc de aquí 00:30:45
Porque el document builder ya me lo parsea 00:30:47
Db.parse 00:30:54
Y aquí mi fichero 00:30:56
Y ahora espérate 00:30:59
Que le añado la excepción 00:31:04
Así 00:31:05
Esto 00:31:12
Pues nada, a partir de ahora 00:31:15
Se convierte en un corta y pega 00:31:17
Cada vez que queremos parsear un XML 00:31:18
A un árbol DOM 00:31:20
Es que ya es hacer el factory 00:31:22
El factory 00:31:24
Me permite instanciar 00:31:26
El builder, que es el que 00:31:28
Me parsea 00:31:30
Y ahora el builder me parsea 00:31:32
Del fichero al documento 00:31:34
¿Vale? Y ya está, ya tenemos 00:31:36
El DOM guardado ahí 00:31:38
¿Vale? Esto es simplemente 00:31:39
Para pasar al 00:31:46
El doc 00:31:47
Como veis descarga el fichero 00:31:49
Uy esto 00:31:50
El doc 00:31:51
Cuidado porque clases document hay muchas 00:31:54
Imaginaos que yo no tengo aquí el import 00:31:57
Este de aquí 00:31:59
No tengo el import 00:32:00
Entonces import de document 00:32:02
Pues cuidadín 00:32:04
No es este 00:32:07
Es este 00:32:08
No es este de aquí 00:32:10
Vale 00:32:12
Sí, pero no va a ser el tuyo 00:32:14
Bueno, pues ya tenemos 00:32:19
Este cargado 00:32:23
Y ahora ya podemos hacer cosas 00:32:24
Por ejemplo, vamos a lo más 00:32:26
Ahora ya se trata de ver 00:32:27
Simplemente 00:32:29
Los métodos que te ofrece 00:32:31
El objeto document 00:32:34
El DOM para navegar 00:32:35
Y ya está 00:32:38
Y luego con esos métodos podemos ya hacer cualquier cosa 00:32:39
Pues por ejemplo 00:32:42
Vamos a listar 00:32:45
Los libros que tenemos 00:32:47
Bueno, pues el doc este 00:32:48
Tiene un montonazo de métodos 00:32:50
¿Vale? Tiene un montón de ellos 00:32:53
No vamos a verlos todos 00:32:55
Pero los básicos para hacer cosas 00:32:58
Pues tiene 00:33:00
Este 00:33:04
El más utilizado 00:33:09
Que es 00:33:12
Entonces devuélveme todos los nodos elemento que se correspondan con esta etiqueta. 00:33:13
Por ejemplo, yo quiero ver libros. 00:33:20
Pues los libros, ¿dónde están? 00:33:23
En nodos con etiqueta libro. 00:33:25
Pues entonces ponemos aquí libro. 00:33:28
Y me devuelve todo. 00:33:32
¿Cómo me lo devuelve? 00:33:34
En una lista propia suya. 00:33:35
Una lista propia suya 00:33:37
Que desgraciadamente no podemos 00:33:42
Convertir a string 00:33:44
Para practicar con labras 00:33:45
Pero podemos 00:33:48
¿Eh? 00:33:49
Bueno, ahora podemos 00:33:53
¿Vale? 00:33:54
Se importa del sitio correcto 00:33:56
Y ahora aquí tenemos una lista de nodos 00:33:58
Todos los nodos 00:34:00
Que se llamen 00:34:02
Libro, todos los nodos elementos 00:34:05
Que se llame el libro 00:34:06
Ahora ya podemos recorrer esta lista de nodos 00:34:07
Vale, ¿cómo se va sacando 00:34:10
Cada uno de los nodos 00:34:25
Elemento? 00:34:27
Vale 00:34:30
Pues cada uno de los nodos 00:34:30
Elemento 00:34:33
Que yo voy a ir uno por uno 00:34:34
Se saca dentro de esta lista 00:34:36
Libros 00:34:39
Con item, no con get 00:34:39
Sino con item y 00:34:42
Porque esa manía de cambiar las cosas 00:34:44
no es manía, es que 00:34:47
yo que sé, se llama así 00:34:48
entonces 00:34:50
libros item 00:34:52
y te lo devuelve 00:34:55
en clase node 00:34:57
pero la clase node es subclase 00:34:57
de element 00:35:00
entonces se puede hacer un casting 00:35:01
y hacer un casting 00:35:04
a element nos habilita 00:35:06
más métodos, entonces 00:35:08
en lugar de dejarlo como node 00:35:10
que podríamos dejarlo como node 00:35:13
y ya está importando nodo 00:35:14
Podríamos importar nodo y dejarlo así 00:35:16
Y ahora con este libro 00:35:20
Ver todo lo que podemos hacer 00:35:22
Bueno, pues si hacemos el casting a element 00:35:23
Y lo dejamos como element 00:35:26
Nos habilita otros métodos 00:35:28
¿Vale? 00:35:30
Todo el modelo es propio del doc 00:35:31
Sí, sí, sí 00:35:34
Son todos métodos del doc 00:35:35
Entonces, bueno, vamos a ver 00:35:36
¿Qué queremos hacer con el libro? 00:35:39
Pues queremos 00:35:44
El libro sabemos que tiene 00:35:44
sabemos que tiene 00:35:46
donde está gestión biblioteca 00:35:49
tiene un título 00:35:52
un autor 00:35:54
y un género 00:35:55
pues entonces ahora podemos 00:35:57
ir haciendo lo siguiente 00:36:00
a ver 00:36:02
vamos a ponerlo 00:36:04
como element que me da más flexibilidad 00:36:06
haciendo 00:36:08
el casting 00:36:10
primero importamos 00:36:11
element y luego hacemos 00:36:14
el casting 00:36:16
y ahora 00:36:16
pues por ejemplo vamos a 00:36:23
vamos a mostrar 00:36:24
vamos a mostrar solamente 00:36:26
el título 00:36:29
y el autor 00:36:32
pues vamos a sacar 00:36:33
el título 00:36:37
lo podemos sacar de la siguiente manera 00:36:40
este sería 00:36:44
este sería 00:36:53
¿verdad? 00:36:57
Todos los nodos título que cuelgan del elemento libro. 00:36:59
Todos los nodos título que cuelgan del elemento libro. 00:37:02
Y te lo devuelve de la misma manera. 00:37:05
Pero claro, me lo devolvería ¿cómo? 00:37:06
En node list. 00:37:09
Vale, pero como yo sé que solamente hay un nodo título. 00:37:10
Pues castearlo. 00:37:14
Pues no, castearlo no. 00:37:15
No puedo castear un elemento en una lista. 00:37:17
Puedo quedarme con el primero. 00:37:19
Y tercero. 00:37:21
¿Vale? 00:37:24
Y a los siete te lo voy a castear. 00:37:25
Vale. 00:37:26
Y ahora ya sí le hago el casting 00:37:27
Y ahora ya podría poner 00:37:29
Claro 00:37:33
Porque solo hay un título 00:37:36
Si no sería una node list tendría que recogerlo 00:37:39
Título 00:37:41
Y aquí título 00:37:42
Claro, pero título es el nodo elemento 00:37:45
¿Cómo saco yo lo que cuelga 00:37:47
De título que a su vez es un nodo texto? 00:37:49
Pues hay un método 00:37:52
Que es getTextContext 00:37:53
Que te saca 00:37:54
el nodo texto que cuelgue de él 00:37:56
aunque hubiese más nodos en él 00:37:59
sí, te saca solo el texto 00:38:00
que cuelgue de él 00:38:04
vale 00:38:05
sí, sí 00:38:05
a ver, si es la primera vez que uno lo ve 00:38:07
puede que sí, pero es que luego 00:38:11
es lo más natural del mundo 00:38:13
y cualquiera de estas cosas se hace en un pispás 00:38:15
lo que pasa es que si la primera vez que uno lo ve 00:38:17
pues hombre, se le puede hacer efectivamente 00:38:18
pero luego 00:38:21
al final son cuatro métodos 00:38:23
No son tantos métodos 00:38:24
Si es que estamos usando 00:38:28
Solo estamos usando este 00:38:29
Claro, pero en este caso 00:38:33
Sí que es factible porque solo vas a tener 00:38:34
Un título, un autor 00:38:36
Bueno, pero si no lo sigues recorriendo 00:38:37
Es lo mismo todo el rato 00:38:39
Ahora 00:38:40
Vale 00:38:44
Título, contexto 00:38:48
Context 00:38:50
Autor 00:38:51
Vale, a ver 00:38:55
Lo que quiero es que 00:38:57
Conozcamos esto un poquito 00:38:59
Su uso y sus posibilidades 00:39:00
No meternos en detalle 00:39:02
Y ver todo porque echaríamos 00:39:05
Una cantidad de tiempo que no renta 00:39:07
¿Vale? 00:39:09
No vamos a echar una cantidad de tiempo que no renta 00:39:11
Porque luego esto 00:39:13
A saber si lo usáis o no 00:39:14
Solamente ver por encima 00:39:16
Un poco sus posibilidades 00:39:19
No se sabe 00:39:20
Pero tenéis que conocerlo todo 00:39:25
O dicho de otra manera 00:39:27
Yo tengo que dar 00:39:29
Que menos que los contenidos 00:39:29
¿Y qué van a tener el examen? 00:39:31
Todo lo que estoy mencionando 00:39:34
Pero es la vida, chicos 00:39:35
Estos son aplicaciones grandes 00:39:38
Con millones de cosas 00:39:41
Y tenemos 5 horas a la semana 00:39:42
Y tenéis que manejaros en ese 00:39:44
Vale 00:39:46
Bueno, vosotros 00:39:47
podéis con esto y más, de verdad 00:39:51
yo no puedo 00:39:53
tratar como un niño 00:39:55
de cole, porque no soy niño de cole 00:39:57
en absoluto, estáis muy lejos de eso 00:39:59
vale 00:40:01
de este método, que es lo único 00:40:03
hasta ahora, con lo que hemos visto hasta ahora 00:40:05
que es lo único, con lo que 00:40:07
la única conclusión interesante 00:40:09
que hemos sacado de esto 00:40:11
pues que mediante tres líneas de copia 00:40:12
y pega, uno parsea 00:40:15
el fichero 00:40:17
a su árbol DOC 00:40:18
vale, mediante técnicas de copia y pepa 00:40:21
y una vez que uno tiene su doc 00:40:22
que es la clave, el doc 00:40:25
pues tiene métodos para hacer cosas 00:40:26
y este es básico 00:40:28
pero es que este es básico 00:40:30
que es el que ya 00:40:33
tenemos que conocer porque este sí que es básico 00:40:35
me saca 00:40:37
todos los nodos, elementos 00:40:39
que se llamen así 00:40:41
y me los guarda en una lista 00:40:43
y yo recorro la lista 00:40:44
y con cada nodo de cada uno 00:40:46
de ellos, que los saco de esta manera 00:40:49
hago ya lo que quiera 00:40:50
y en particular, ¿qué quiero hacer? 00:40:53
pues sacar 00:40:55
de él, por eso aquí he puesto 00:40:56
libro, porque son solo los que cuelgan 00:40:59
de él, aquí he puesto doc 00:41:01
todos los que cuelgan de doc 00:41:02
si yo lo veo así, lo entiendo 00:41:04
pero de repente veo, libro.getElementById 00:41:06
pues todos los nodos 00:41:09
títulos que cuelgan del nodo elemento libro 00:41:11
y en vez de devolverte un element, te devuelves un node 00:41:13
que tienes que castear al elemento 00:41:15
te devuelve un node list 00:41:16
por eso le ponemos el ítem 0 00:41:18
para que se quede con el primero 00:41:20
bueno, a ver, pero es el primer método que estamos haciendo 00:41:21
con esto, que igual por eso se os hace un poco 00:41:24
raro 00:41:26
en cuanto hagamos dos, tres métodos más 00:41:27
pues ya está 00:41:30
esto es home, home, home 00:41:31
no creo que hayan trabajado 00:41:36
vale 00:41:37
Pues venga 00:41:38
Vamos a hacer este método 00:41:54
Vamos a sacar todos los libros 00:41:55
Copiamos el de arriba 00:41:59
Vamos a sacar todos los libros 00:42:02
ahora 00:42:06
vamos a recorrer 00:42:08
los libros 00:42:09
todo esto es programar 00:42:11
si es que es programar, no es nada 00:42:16
ahora, de cada libro 00:42:18
un segundito 00:42:20
ahora vamos a terminarlo 00:42:23
que no vamos a terminar en nada 00:42:25
y os vais a sostenir 00:42:26
lo que vayáis a hacer 00:42:28
espera un momento 00:42:30
vamos a acabarlo 00:42:32
tenemos todos los libros 00:42:33
vamos libro por libro 00:42:36
De cada libro vamos a sacar el autor, si es que luego es copia y pega y lo de arriba, vamos a sacar el autor. Aquí tenemos el autor del libro y ahora, si autor.loquelecuelga, que es el, es uno de los textos, sí, eso, 00:42:38
Lo que es igual que el buscado, es igual que el autor buscado, entonces tengo que añadir a mis títulos, tengo que añadir a mis títulos el título. 00:43:02
Entonces, el título lo puedo sacar 00:43:25
Como lo he sacado antes 00:43:29
El título lo he sacado así 00:43:31
Si esto luego se hace de corrido, muchachos 00:43:33
Claro, saco el título 00:43:40
Y lo añado a 00:43:43
Títulos 00:43:46
Títulos.add 00:43:48
Título.getTextContext 00:43:51
¡Hala! Y ya está el método 00:43:56
Vale 00:44:01
He cogido todos los libros 00:44:03
He ido libro por libro 00:44:06
He sacado el autor 00:44:10
Siempre tiro de ese método 00:44:12
Siempre en realidad 00:44:16
Del autor 00:44:17
Si es el buscado, pues ya está 00:44:23
Pues venga 00:44:25
Vamos a probarlo 00:44:26
Por si hemos hecho algo mal 00:44:28
Llamando a 00:44:29
gestión 00:44:32
punto 00:44:35
un segundo, ya me voy 00:44:37
ya me voy 00:44:40
vamos a buscar título 00:44:40
por autor 00:44:44
esto me da una, y vamos a buscar 00:44:44
a que autor vamos a buscar 00:44:48
vamos a buscar a este 00:44:49
mismo, vamos a 00:44:52
buscar a este 00:44:56
y ahora 00:44:58
esto va a dar una lista 00:45:02
la vamos a 00:45:04
pasar a stream 00:45:06
para mostrarla 00:45:08
con el for each 00:45:10
y tan joder 00:45:11
cancino 00:45:13
a ver 00:45:14
la vamos a pasar a stream 00:45:16
y así ya podemos llamar al for each 00:45:21
y al for each 00:45:24
ya le pasamos 00:45:26
el system.out 00:45:27
printl 00:45:30
vale pues ya está 00:45:32
buscamos títulos por autor 00:45:35
Y vamos a mostrarlos todos aquí 00:45:38
Vamos a poner aquí esto 00:45:39
Para distinguir del listado anterior 00:45:42
A ver si me busca los de este 00:45:44
Pues sí, efectivamente 00:45:50
Me ha encontrado este de aquí 00:45:53
Estupendo 00:45:55
Vale 00:46:02
A ver 00:46:03
Vale 00:46:06
pues a ver si 00:46:11
sois capaces 00:46:15
de hacer 00:46:17
sin mucha ayuda de EchaGPT 00:46:18
libros 00:46:21
un segundo, el de libros 00:46:23
eliminar, este ya implica 00:46:25
modificar, que no hemos 00:46:27
y agregar, eliminar, es que estos ya son 00:46:29
modificar que no solo consulta 00:46:31
pero hombre, este por lo menos 00:46:33
hacedlo y ya el próximo día 00:46:35
aprendemos a modificar que nos falta 00:46:37
no solo a consultar, consultar es que 00:46:39
es esto que hemos hecho, tú vas navegando y ya está 00:46:41
aprendemos a modificar y ya está 00:46:43
es que luego esto ya es práctica 00:46:45
y muy rápido, sin añadir dependencias 00:46:46
sin cargar la aplicación porque esto no pesa nada 00:46:49
pues puedes hacer consultas y cosas 00:46:51
¿vale? 00:46:53
pero a ver, alguien iba a preguntar 00:46:55
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Segundo Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
9
Fecha:
20 de noviembre de 2025 - 12:48
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
46′ 57″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
224.98 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid