Saltar navegación

20251009 Logs_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 10 de octubre de 2025 por Raquel G.

21 visualizaciones

Más información Transcripción

Descargar la transcripción

Venga, niños 00:00:00
Vamos 00:00:05
Vale, a ver 00:00:06
¿Cómo le decimos a Maven 00:00:09
Que necesitamos una dependencia? 00:00:12
Pues tenemos que 00:00:14
Decirle cuál es 00:00:16
¿Y cómo podemos averiguar cuál es? 00:00:17
Menos mal 00:00:19
Que tenemos una cosa 00:00:21
Si yo encuentro el ratón 00:00:24
Eso también 00:00:27
Que se llama 00:00:28
el repositorio de Maven 00:00:30
entonces, en cuanto busquéis 00:00:33
Maven repositorio, la primera que os va a salir 00:00:38
es esto 00:00:40
y aquí te sale 00:00:40
todas las tropecientas 00:00:43
mil millones de cosas 00:00:46
que tú puedes descargar y usar 00:00:47
muchas 00:00:50
muchísimas 00:00:51
entonces aquí, lo complicado 00:00:52
es encontrarlo 00:00:55
y luego una vez que lo has encontrado 00:00:57
que te case con tu versión y te funcione 00:00:59
normalmente esto es un camino 00:01:02
interminable hasta que consigues 00:01:03
todas las dependencias que casan 00:01:06
exactamente con lo que quieres hacer y te funciona 00:01:08
y cuando ya lo tienes 00:01:09
no lo toques nunca 00:01:11
nunca jamás, porque en cuanto 00:01:13
toques algo, pum, lo que pasa es que hay veces 00:01:15
no lo tocas tú, pero te han tocado la 00:01:18
versión del servidor, entonces ya 00:01:19
otra vez tienes que empezar 00:01:22
a tocarlo todo 00:01:23
en nuestro caso afortunadamente 00:01:25
Solo es los 4J 00:01:27
Pues vamos a hacer una búsqueda 00:01:29
Una búsqueda, los 4J 00:01:31
Dos, que me sacas por ahí 00:01:33
Venga, busca 00:01:35
Busca 00:01:37
Esto no suena 00:01:39
Esto no nos suena 00:01:41
Esto no nos suena 00:01:44
A ver, es que a mi no me gusta ninguna de estas 00:01:47
Porque 00:01:51
Vamos a hacer una cosa 00:01:51
Voy a ponerle 00:01:58
bueno, no hemos dicho que es de Apache 00:01:59
que Apache, ya sabéis que tiene un montón 00:02:03
de cosas de las que se ha apropiado 00:02:06
bueno, más que se ha apropiado, que las ha desarrollado 00:02:08
de Java, vale, entonces 00:02:10
bien, Apache 00:02:12
los 4J, vale 00:02:18
entonces 00:02:20
esto ya me dice, uno 00:02:22
lo buscaría en principio por los 4J 00:02:28
Apache, porque Apache 00:02:31
es él. Y le sale esto 00:02:33
los cuatro 00:02:36
los cuatro jotados. 00:02:37
Yo quiero... 00:02:42
No, no me... 00:02:43
Que no me funciona. 00:02:45
No, no, no. 00:02:49
No, porque está conectado al ordenador. 00:02:49
Pero da igual. 00:02:53
En otro aula 00:02:55
yo estoy proyectando. 00:02:56
Claro, me debería funcionar. 00:02:58
Pero es que 00:02:59
estábamos usando el de clases. 00:03:01
Ah, es porque 00:03:05
Me avisa, esa es la clave 00:03:07
Por eso no funciona en grado medio 00:03:09
Porque en grado medio no uso portátil, uso el de clase 00:03:11
Entonces tendría que poner 00:03:13
Los USBs también 00:03:15
Ah, vale, ya decía 00:03:16
¿Y por qué no me funciona el resto de...? Vale, vale 00:03:19
Porque no tengo los USBs 00:03:21
Sois estupendos, bueno, es la clave 00:03:22
¿Eh? 00:03:24
¿Está conectado igual por HDMI? 00:03:27
Claro, mi portátil está solo por HDMI 00:03:30
Pero... 00:03:32
Y el otro está por USB y HDMI. 00:03:33
Entonces, claro, tendría que ir por los USBs. 00:03:35
Por eso tampoco puedo coger la cámara. 00:03:38
Desde mi portátil, porque va por USB, etc. 00:03:39
Vale, entonces. 00:03:42
Lo que pasa es que yo quería la 2. 00:03:45
A ver, y si pongo API. 00:04:03
Es que, a veros, la... 00:04:04
Esto no lo quiero. 00:04:10
Ven, aquí que pone 00:04:19
septiembre del 2018. 00:04:20
Esta. 00:04:25
Vale. 00:04:30
Vale, pues entonces, 00:04:39
el core y el API. 00:04:40
Sí. 00:04:45
En realidad, a ver, yo las tengo ya en mi proyecto. 00:04:48
Podríamos copiar y pegar, 00:04:51
pero vamos a hacer 00:04:52
vamos a meternos en la basura directamente 00:04:54
a ver si nos funciona 00:04:56
entonces en general cuando uno ofrece 00:04:58
un paquete de clases 00:05:00
recordad la arquitectura, un segundito 00:05:02
de que normalmente tú 00:05:04
haces interfaces con los métodos 00:05:06
y luego implementaciones 00:05:08
pues en la mayoría de los casos 00:05:10
cuando uno busca dependencias 00:05:13
por ahí tiene la misma estructura 00:05:14
está el API, que son las interfaces sin más 00:05:15
luego está el Core, que son las 00:05:18
implementaciones, que es justo las dos cosas que me está 00:05:20
ofreciendo, el API y el 00:05:22
core, ¿vale? Entonces, yo 00:05:25
cogería las dos, 00:05:26
¿vale? Entonces, uno pincha 00:05:28
aquí, 00:05:30
core, y ya te dice, ¿qué versión 00:05:32
quieres? Vámonos 00:05:35
a esta de aquí, la de septiembre 00:05:37
18. 00:05:38
Pinchamos aquí, 00:05:42
sí, pincha el core, 00:05:44
y ya sale esto, 00:05:45
que esto es lo que hay que 00:05:47
copiar en dependencias 00:05:48
entonces todo en cuanto pinchas aquí ya se copia 00:05:50
cuando pinchas aquí 00:05:52
ya se copia 00:05:56
si en cuanto pinches ya se selecciona 00:05:57
y se copia 00:06:00
si estuviéramos trabajando con Gradle 00:06:01
pues esto es lo que habría que poner 00:06:03
en el fichero de configuración de Gradle 00:06:06
pero como estamos trabajando con Maven 00:06:08
esto 00:06:10
una vez que ya está copiado 00:06:11
nos vamos al Pong y a la 00:06:13
ahí está 00:06:15
Este, o sea, yo me he ido 00:06:18
Vamos a ver 00:06:23
A la última versión, vamos a ver 00:06:24
¿De dónde he salido yo? 00:06:26
Yo he buscado los 4J2 a API 00:06:30
He llegado a 00:06:32
Arriba 00:06:36
¿Cómo arriba? 00:06:39
En el séptimo 00:06:41
A este 00:06:42
He pinchado aquí 00:06:43
Y aquí me ofrece el core y el API 00:06:46
Pues vamos a los dos 00:06:48
El core ya lo he copiado 00:06:49
Voy a este 00:06:52
Selecciono la misma versión 00:06:53
La del 18 de septiembre 00:06:55
Pincho para que copie 00:06:57
Y pego aquí 00:07:00
¿Vale? 00:07:03
Entonces con suerte 00:07:07
Con estas dos puedo ya trabajar 00:07:08
Si no puedo trabajar ya me dirá 00:07:10
Class not found 00:07:13
Exception, class no se que, ya me dirá cosas 00:07:14
Entonces tendré que seguir buscando 00:07:16
Pero con suerte con estas dos 00:07:17
¿Y el API? 00:07:19
El API es el conjunto de interfaces 00:07:22
Y el core es la implementación 00:07:24
Suele ser una estructura típica de dependencias 00:07:25
El API y el core 00:07:28
Ambos dentro de dependencias 00:07:29
Dentro de las dependencias 00:07:31
Que habéis escrito a mano 00:07:34
Entonces en cuanto tengáis las dos 00:07:35
Dependencias estas 00:07:40
Y ahora luego aquí ya viene 00:07:41
Y guardéis 00:07:42
Al POM 00:07:44
te tendrás que crear tú 00:07:47
este nodo de dependencias 00:07:49
a mano 00:07:52
este nodo de dependencias 00:07:53
con su principio y su fin 00:07:55
te lo tendrás que crear a mano 00:07:57
y ahora ya dentro toda la lista de nodos 00:07:59
dependencias, dependencias, dependencias y otras 00:08:02
y en cuanto guardéis 00:08:03
le deis archivar 00:08:08
pues se hace la magia 00:08:09
en cuanto le damos a este botón 00:08:11
¡pum! ya pasan cosas 00:08:13
¿qué está pasando? 00:08:15
que el Eclipse, el plugin 00:08:18
de Maven de Eclipse, claro, se está conectando 00:08:20
al repositorio, está descargando 00:08:22
todos los hard 00:08:25
relacionados con esta dependencia 00:08:26
los está poniendo en un repositorio local 00:08:28
que ahora miramos a ver 00:08:31
dónde está, porque siempre van a saber 00:08:32
dónde está el repositorio local, porque a veces 00:08:34
cuando Maven casca, lo mejor 00:08:36
es borrar el repositorio local y empezar 00:08:38
de nuevo, y una vez 00:08:40
que lo ha descargado al repositorio local 00:08:42
ya lo mete al classpad del sistema 00:08:44
Todo eso ha hecho solo por darle yo a guardar 00:08:46
De hecho 00:08:50
Si nos vamos aquí de nuevo 00:08:52
A nuestro proyecto Maven 00:08:53
Nos vamos aquí, nos ha aparecido 00:08:55
Esta etiquetita de aquí 00:08:57
Con 00:08:59
Todas las dependencias 00:09:01
Que ha metido 00:09:03
Log4j 00:09:04
Fijaos que listo 00:09:08
Esto, la versión de antes de septiembre 00:09:11
No lo hacía 00:09:13
Fijaos que listo 00:09:14
la última versión que yo probé 00:09:16
de esto, te metía 00:09:19
el API y el core, punto pelota 00:09:21
esta versión 00:09:22
te metes dos hard 00:09:25
¿qué son los Jackson? 00:09:26
¿algunos no os lo han metido? 00:09:28
a ver, yo os avisé ya 00:09:30
o si no os lo avisé, os lo avisé ahora 00:09:32
y por eso cuando me decíais, graba las clases 00:09:34
no, os dije 00:09:36
veréis que esto es muy complicado, porque esto ya va a ser 00:09:38
un caos, a cada uno os va a salir 00:09:41
una cosa, a uno le funciona, a otro no 00:09:43
aquí hay mil variables de las que dependemos 00:09:45
cuando uno consigue que todo el puzzle 00:09:47
le encaje, a otro se le cae una pieza 00:09:49
entonces esto ya empieza a ser un caos 00:09:51
porque ya dependemos 00:09:53
entonces este es un ejemplo 00:09:54
a mí que me ha pasado, yo solamente 00:09:56
poniendo estas dos dependencias 00:09:59
no, no, no, perdón, perdón, perdón 00:10:00
perdón, perdón, hazme, todo lo que he dicho 00:10:03
es mentira, perdón 00:10:05
es que ha abierto el proyecto que no era 00:10:07
claro, es que he dicho, no me lo puedo creer 00:10:09
Qué listo que me ha metido el Jackson solo 00:10:13
Podría ser 00:10:15
Vale, perdón, perdón, perdón 00:10:16
Eso me pasa por, claro, es que tengo 00:10:19
Todos los proyectos juntos 00:10:21
Vale, perdón, perdónenme 00:10:23
Lo siento, ya 00:10:25
Pero, perdonad, ha metido los dos 00:10:29
Lo del Jackson 00:10:31
Vendrá después 00:10:33
Lo del Jackson, vale, pues estamos 00:10:34
Todos igualitos, dime 00:10:37
El POM 00:10:38
Sí 00:10:41
Tiene solo estas dos 00:10:41
Las que he copiado del repositorio de Maven 00:10:44
Tiene el nodo que he creado 00:10:47
Este 00:10:58
Hace dos años 00:10:59
Tenía un alumno con tendencia 00:11:10
A echar cabezadas en clase 00:11:12
Bueno, a ver, todos los años 00:11:14
Hay alumnos que hacen echar cabezadas 00:11:15
Y ese alumno 00:11:17
Primero echaba cabezadas 00:11:19
y en segundo dijo, he comprobado 00:11:20
que si me duermo un minuto 00:11:23
ya me he perdido 00:11:24
¿qué has escrito ahí? 00:11:26
con lo cual, los que tengáis 00:11:29
esa cabeza no la sentéis, porque es que 00:11:30
si es que alguien la tuviera 00:11:33
vale, pues entonces 00:11:36
pues que ha hecho Maben 00:11:38
lo que he dicho, ha descargado los hard 00:11:43
lo ha guardado en un repositorio local 00:11:44
lo ha añadido al pad del sistema 00:11:46
¿dónde está ese repositorio local? 00:11:48
es decir, los JAR los ha 00:11:50
bajado físicamente 00:11:52
pero ojo, no los ha 00:11:54
metido dentro del proyecto 00:11:56
los JAR no están aquí dentro 00:11:58
porque si estuvieran aquí dentro el proyecto 00:12:00
pesaría un huevo, ¿vale? 00:12:02
no los ha metido aquí dentro 00:12:04
los ha puesto un reportero local, con lo cual 00:12:05
no os peguéis 00:12:08
con lo cual, me diríais 00:12:09
¿qué pasa si ahora yo este proyecto 00:12:12
lo despliego en otro sitio? 00:12:14
si los JAR no están localmente 00:12:16
claro 00:12:17
pero es que cuando uno lo despliegue 00:12:20
en otro sitio 00:12:23
va a ver la dependencia en Maver 00:12:23
¿qué va a hacer ese otro equipo? 00:12:26
va a mirar su repositorio local 00:12:28
a ver si hubiera la casualidad que estuviera en estos hard 00:12:30
y si no lo está, los descargaría para él 00:12:32
entonces 00:12:35
está automatizando 00:12:36
la descarga de los hard cuando le haga falta 00:12:38
nosotros nos limitamos 00:12:41
a poner los dependencia aquí dentro 00:12:42
y da igual donde despleguemos esto 00:12:44
si él ve que no los tiene 00:12:47
en el local y hacen falta los despliega. 00:12:48
Ya nos olvidamos de eso, los descarga, perdón. 00:12:50
Pues, ¿dónde está ese repositorio local? 00:12:52
Pues, a ver, sí me acuerdo. 00:12:55
Creo que no me acuerdo. 00:12:57
Con lo cual, hasta que... 00:12:58
No pasa nada. 00:12:59
Vale, pues, entonces hemos quedado que estaba, 00:13:00
acordaos en el usuario, carpeta M2, repositorio. 00:13:04
Bueno, pues, ahora ya, ya sí que podemos hacer nuestra 00:13:10
pequeña aplicación que envía logs. 00:13:15
Vale. 00:13:20
Entonces, primero no vamos a meterle ningún archivo de configuración. 00:13:20
Vamos a hacer un primer paquete. 00:13:26
Como mi grupo era condam2, pues la idea es que los paquetes tengan ese condam2. 00:13:32
Pues yo qué sé. 00:13:39
Main. 00:13:43
Condam2. 00:13:46
Bueno, porque yo a mi proyecto 00:13:46
Mi proyecto Maven 00:13:49
Le he dicho que su identificador de grupo 00:13:51
Es com.dam2 00:13:53
Que es mi nombre de dominio 00:13:54
Era dam2.com 00:13:56
Era dam2.com 00:13:57
Bueno, ya, sí, pero porque se hace en orden distinto 00:13:59
A ver, dam2.com 00:14:02
Pero aquí en el nombre de paquete 00:14:04
Esto es un tema de cómo se empaqueta en general 00:14:05
¿Vale? Los nombres de dominio 00:14:08
Todos sabemos cómo son 00:14:09
Pepito.com, Juanito.org 00:14:11
Eso lo tenemos claro, ¿vale? 00:14:14
Entonces, ¿cómo se suele empaquetar en las empresas? Pues, como la idea es que nuestros paquetes tengan nombres únicos dentro de todas las aplicaciones, que nuestras aplicaciones tengan nombres únicos, ¿vale? Pues, se suele empaquetar aprovechando la unicidad del nombre de dominio. 00:14:15
pero se pone al revés 00:14:34
com.dam2.main 00:14:35
porque así tenemos la jerarquía mejor 00:14:37
com es la carpeta 00:14:39
com luego tendría tantas subcarpetas 00:14:41
como subdominios 00:14:43
tenga tu empresa, cada subdominio 00:14:45
a su vez tendrá tantas carpetas como subdominios 00:14:48
entonces tiene sentido que el nombre del paquete 00:14:50
sea al revés, porque esta es 00:14:52
la carpeta grandota, esta es la 00:14:53
subcarpeta dam2 00:14:55
y esta ya es la subcarpeta main 00:14:57
y esto se correspondería 00:14:59
con una empresa cuyo nombre de dominio es 00:15:01
dam2.com, dime 00:15:03
el proyecto 00:15:04
no te habrá pasado lo de 00:15:11
venga pues 00:15:13
vamos a hacernos nuestra 00:15:15
una clase normalicha y corrienticha 00:15:19
vale, pues aquí en esta clase 00:15:22
lo primero que queremos avisar cuando la aplicación 00:15:36
arranca es, entrando en la aplicación 00:15:38
para que uno, entonces eso ya 00:15:40
podría ser un posible mensaje de log 00:15:42
para saber en que momento ha arrancado la aplicación 00:15:44
a qué hora, etc. 00:15:46
Entonces, ¿quiénes 00:15:48
mandan? Esto por supuesto 00:15:50
lo podríamos hacer con un file 00:15:52
reader y se acabó, pero 00:15:54
qué complicado, ¿no? 00:15:55
Entonces, 00:15:58
como lo vamos a hacer con el 4J, 00:15:59
¿qué objeto es el que es capaz 00:16:02
de escribir en un archivo? 00:16:04
Pues un objeto que se llama 00:16:06
logger. 00:16:07
Entonces, de clase logger. 00:16:10
Entonces, si queremos escribir logs, 00:16:12
necesitamos 00:16:15
Un objeto logger 00:16:16
Que es el que es capaz de escribirlo 00:16:17
Este objeto logger 00:16:20
¿Cómo se crea? 00:16:21
De nuevo 00:16:24
Constructores caca 00:16:24
No los queremos 00:16:27
Entonces este se crea 00:16:29
Así 00:16:32
Y aquí ¿Qué ponemos? 00:16:35
Aquí 00:16:39
Lo que 00:16:40
Cuidado porque me ha importado el por defecto 00:16:41
El logger 00:16:44
De la herramienta java útil 00:16:46
Ahora vamos a tener que quitarlo 00:16:48
no queremos esto, queremos el de los 4.2.j 00:16:49
recordad que al principio os he dicho 00:16:51
la distribución estándar 00:16:53
te trae una herramienta para hacer logs 00:16:55
en java útil, pero bueno 00:16:57
es más limitada que los 4.j 00:16:59
la que mayoritariamente son los 4.j, ahora quitamos ese input 00:17:01
entonces 00:17:03
¿qué ponemos aquí en getLogger? 00:17:05
bueno, voy a quitarlo desde ya, no vaya 00:17:07
para esto, no lo quiero 00:17:08
¿cuál quiero importar? 00:17:11
quiero importar 00:17:14
el de or apache login 00:17:15
¿Pero cuál de todos? 00:17:17
Pues, a ver, es que 00:17:21
como ha cambiado la versión 00:17:22
no sé, yo creo que será el core 00:17:25
Será el core 00:17:26
Esto es como la vida misma, vamos a probar 00:17:28
Vale, entonces 00:17:30
Perdón 00:17:32
Entonces 00:17:36
¿Qué se pone aquí? 00:17:37
Se pone aquí la clase 00:17:40
a la cual este logger está asociado 00:17:42
en nuestro caso es 00:17:47
main.class 00:17:49
vale 00:17:51
si, espera, es que a ver si 00:17:52
este 00:17:57
a ver si lo he escrito yo mal 00:17:58
o es porque esta versión 00:18:00
a ver 00:18:02
no, voy a abrir la 00:18:07
chuleta, a ver que he escrito mal 00:18:09
por ejemplo 00:18:12
aquí tendré 00:18:14
ah, perdón 00:18:15
que es que no es 00:18:20
del logger, es logmanager, perdónenme 00:18:22
ustedes, no es 00:18:24
logmanager, si es que 00:18:26
no me tengo que aprender las cosas 00:18:28
que luego se me 00:18:30
olvidan, este ya 00:18:32
sí que es, getlogger 00:18:36
vale 00:18:38
vale 00:18:39
sigue dando error porque tienes que importar, hijo mío 00:18:43
de verdad, es que os gusta a vosotros 00:18:48
mucho ahí meter 00:18:50
cizaña, eh 00:18:52
sigue dando error 00:18:54
Además no se dice, sigue dando error 00:18:56
Se calla uno y lo arregla como loco 00:18:58
A mí me dice que hay que hacer un casting 00:19:00
Pues a mí me importa 00:19:03
A mí no me importa 00:19:04
Hay que quitar el código 00:19:04
A ver 00:19:06
A ver 00:19:11
Relájese, vale 00:19:14
Vale, pues el logger 00:19:16
Que es este 00:19:18
El logger que es este 00:19:19
Es el objeto que es capaz de mandar logs 00:19:22
Cuando uno quiera 00:19:24
entonces, ¿por qué he puesto aquí yo el nombre 00:19:25
de esta clase? 00:19:28
porque este objeto logger 00:19:30
puede haber uno por clase, mi aplicación 00:19:32
tendrá muchas clases, puede haber uno 00:19:34
por clase o uno 00:19:36
para todos 00:19:39
¿vale? podría haber uno para todos 00:19:40
entonces 00:19:43
si hay uno para 00:19:44
todos, yo no puedo configurar 00:19:46
las clases por separado 00:19:48
pero si hago uno por clase 00:19:50
puedo configurar cada clase por 00:19:53
separado. Ahora veremos qué significa esto de 00:19:54
configurar la jaula separado. 00:19:56
Vale, pues yo quiero mandar mi primer 00:19:58
log, que es este. 00:20:00
Que es, ahora, 00:20:04
¿qué métodos tiene 00:20:07
el logger? Pues tiene 00:20:08
un montón, pero 00:20:10
tiene unos 00:20:12
interesantes que son, 00:20:14
vamos a poner primero 00:20:17
un debug normal. 00:20:18
Espera, a ver. 00:20:20
No, espera, voy a ver un tracé. 00:20:22
Espera, vamos a ponerle un tracé 00:20:24
Un mensajito, un tracestream 00:20:26
Ahora, vale 00:20:28
Arrancando aplicación 00:20:33
Vale 00:20:41
Y podría hacer también 00:20:42
Ahora explicamos lo que es esto 00:20:44
Ahora, ahora lo, sí 00:20:47
Ahora lo 00:20:49
Arrancando aplicación 00:20:50
Ahora voy a cambiar esto, debug, después del debug tenemos info, después de info creo que viene one, después de one pondríamos error, vale, pues ¿qué es esto que he hecho yo aquí? 00:21:08
no exactamente 00:21:46
no exactamente 00:21:47
a ver 00:21:50
con esto 00:21:51
lo que le digo es 00:21:52
al logger 00:21:53
que me envíe un log 00:21:54
¿a dónde? 00:21:56
a un fichero de la consola 00:21:58
todavía no sabemos 00:21:59
por qué es que no hemos hecho 00:22:00
el fichero de configuración 00:22:01
el xml famoso 00:22:02
o el json 00:22:03
no lo hemos hecho 00:22:04
todavía no sabemos 00:22:05
dónde lo mandará 00:22:06
pero él manda un mensaje 00:22:06
¿por qué hay diferentes métodos 00:22:08
para enviar un mensaje? 00:22:10
porque el mensaje es el mismo 00:22:12
pero tu aplicación 00:22:14
puede decidir en qué nivel 00:22:15
de tu fase 00:22:18
de desarrollo estás 00:22:20
entonces, hay seis niveles 00:22:21
el de 00:22:24
traza, que es cuando lo quieres 00:22:25
estás en un nivel en el cual te interesa 00:22:27
todo, el de 00:22:29
dibujo, estás en nivel de depuración 00:22:31
te interesa todo, pero no tanto 00:22:33
el de info, cuando ya estás 00:22:34
el nivel de info 00:22:37
es cuando ya la aplicación está en explotación 00:22:39
ahora vemos qué significa 00:22:41
el nivel de aviso, el de error 00:22:42
y el de fatal, que es la cagado. 00:22:44
Entonces, tú puedes 00:22:46
configurar tu herramienta log 00:22:48
a través del fichero de configuración 00:22:50
xml, como lo configuraremos, 00:22:52
la puedes configurar a través de ese 00:22:54
fichero xml para que 00:22:56
esté en alguno de estos niveles 00:22:58
en el que tú quieras. 00:23:00
Entonces, yo aquí dejo estos 00:23:02
seis mensajes. 00:23:04
Y yo pongo, a través de mi fichero xml, 00:23:06
lo pongo, voy a configurarme 00:23:08
ahora mismo en nivel trazo. 00:23:10
¿Eso qué significa? 00:23:12
que el logger va a enviar 00:23:13
los de traza y todos 00:23:15
los superiores. Este es el más bajo, 00:23:18
este viene después, este es 00:23:20
un nivel superior, este y este. 00:23:22
Sin embargo, yo ahora ya no estoy en fase 00:23:23
de desarrollo de mi aplicación 00:23:25
y no quiero enviarlos de traza. 00:23:27
Esos no quiero. ¿Vengo 00:23:30
a la aplicación a borrarlos? No. 00:23:31
Venir al código a cambiar cosas, eso es justo lo que no 00:23:33
queremos. Me voy a mi aplicación 00:23:35
de configuración, perdón, 00:23:37
me voy al XML y le digo, ya no 00:23:39
estoy en nivel de traza. Súbeme a nivel 00:23:41
de debug. Le pongo a debug. Con lo cual 00:23:44
este sigue estando 00:23:46
en esta línea de código. Pero ya 00:23:47
el logger, como ve en la configuración 00:23:49
que tú estás en nivel de debug, 00:23:51
este no lo envía. Solo envía 00:23:53
los de debug y superiores. 00:23:56
Que ya estás 00:23:58
en un nivel que ya los detalles te dan igual. 00:23:59
Y oye, yo no quiero ni avisos. 00:24:02
Pones en el XML 00:24:04
tu nivel de log a error. 00:24:05
Entonces, aunque estos 00:24:08
sigan estando en la aplicación, 00:24:09
solamente los va a enviar 00:24:11
los que sean de error y de fatal 00:24:14
solo, entonces estos nunca 00:24:17
los quitamos, porque en la fase 00:24:19
de explotación de la aplicación 00:24:21
si hay errores, queremos que se 00:24:22
registren, pero no vamos 00:24:25
a querer que se registren todos los avisos 00:24:27
las depuraciones, porque nos 00:24:29
quedarían los archivos de logs enormes 00:24:31
y el pobre técnico se volvería loco 00:24:32
pero cuando estamos todavía 00:24:35
depurando la aplicación, si queremos 00:24:37
que llegue todo, para tenerlo todo 00:24:39
muy detallado. Entonces, ahí pondríamos en el 00:24:41
XML que el nivel de 00:24:43
log quiero que sea este, por ejemplo. 00:24:45
O este. ¿Vale? 00:24:47
Pero en el código no lo cambiamos. En el código 00:24:49
todos los mensajes que 00:24:51
uno ponga, mejor. Estos serían como los 00:24:53
system out. Todos los que pongas 00:24:55
en cualquier sitio, fenomenal. 00:24:57
Esos nunca los vas a quitar. 00:24:59
Luego tú ya lo que haces en el XML 00:25:01
es bajar el nivel y decidir cuáles 00:25:02
se van a ejecutar realmente 00:25:05
y cuáles no. ¿Vale? 00:25:06
Y al final los metes en los 00:25:08
Claro, claro 00:25:10
Efectivamente, en cualquier punto que quieras dejar registro 00:25:13
De aquí ha pasado esto, aquí no sé qué, en cualquier lado 00:25:15
Entonces, nosotros ahora no tenemos fichero de configuración 00:25:17
Pero una 00:25:20
Si log4j 00:25:21
Cuando arranca 00:25:23
Ve que no tiene fichero de configuración 00:25:24
Se configura por defecto 00:25:28
O debería 00:25:30
No sé esta nueva versión 00:25:31
Se configura por defecto 00:25:34
Para que 00:25:36
El error, el nivel se ponga en error 00:25:37
y la salida 00:25:40
de los logs sea solo por consola. 00:25:43
Como no le hemos dado ningún fichero, 00:25:45
entonces vamos a ejecutarlo y tenemos suerte 00:25:47
y con las dependencias que hemos 00:25:48
puesto, esto nos funciona. 00:25:51
Magnífico. 00:25:59
Ha pasado lo que yo preveía 00:25:59
que pasara, menos mal, porque si no... 00:26:00
Claro, ha enviado solo 00:26:03
estos dos, porque por 00:26:04
defecto él se configura a nivel error. 00:26:06
Como no he encontrado ningún fichero de configuración, 00:26:09
estos los ha ignorado 00:26:10
y como no le he configurado 00:26:12
ningún fichero ni nada, me lo ha sacado por 00:26:15
console y me lo ha sacado 00:26:17
en un formato por defecto 00:26:19
este formato lo podemos cambiar 00:26:21
¿vale? si queremos tener el fichero 00:26:23
de configuración 00:26:25
vale 00:26:26
de nuevo 00:26:27
la ventaja que tiene esto 00:26:33
es que no tenemos 00:26:36
que entrar al código a cambiar nada 00:26:38
si nosotros depuráramos con los ISO 00:26:40
menudo desastre, cuando yo ya llevo la aplicación 00:26:42
a producción, tendría que entrar 00:26:44
en el código, quitar los ISO 00:26:46
para que no me salgan en la consola 00:26:48
cuando ya la aplicación está ejecutando 00:26:51
claro, sin embargo aquí 00:26:52
yo el código no lo voy a tocar 00:26:54
claro 00:26:56
en el archivo de configuración 00:26:58
lo cambiamos para que ya no salga por consola 00:27:00
todo se hace por configuración 00:27:02
entonces en el log4j original 00:27:03
si tú ibas al fichero de configuración 00:27:06
al que todavía no tenemos 00:27:10
y le cambiabas algo 00:27:11
pues tenías que desplegar 00:27:13
la aplicación otra vez 00:27:17
no tocar el código, eso no 00:27:18
pero tenías que rearrancar la aplicación 00:27:20
para que se configurara con los nuevos cambios 00:27:23
eso es un rollo 00:27:25
cada vez que cambias un fichero de configuración 00:27:26
sea XML, Properties 00:27:29
tener que reiniciar la aplicación 00:27:30
para que se cojan los nuevos cambios 00:27:32
pues es un rollo 00:27:33
Entonces, las versiones actuales de los frameworks lo que permiten es que ese propio framework, cada ciertos segundos que tú lo configuras, va mirando a ver si tiene que recargar algo. 00:27:35
Pues, esa es una ventaja que tienen los 4J2, que tú cambias algo en el fichero XML y no tienes que preocuparte de reiniciar la aplicación. 00:27:50
el propio log4jl 00:27:57
tiene ahí su hilo paralelo 00:28:00
que cada cierto tiempo que tú configuras 00:28:01
también el fecho de configuración, cada 10 segundos 00:28:03
cada 20, cada 15, cada 3 minutos 00:28:06
está ahí, has cambiado 00:28:08
has cambiado, te actualiza 00:28:10
¿vale? 00:28:11
así que nos despreocupamos 00:28:13
que queremos cambiar el log 00:28:15
te vas al xml, lo cambias 00:28:17
y ya está, no tienes que hacer nada 00:28:19
en la aplicación, ¿vale? 00:28:21
bueno, entonces en un caso real 00:28:23
no queremos mandarlo a consola 00:28:25
queremos mandarle un fichero, pues entonces 00:28:27
ahora ya sí que tenemos que 00:28:29
ponerle un fichero de configuración 00:28:30
uno se aprende cómo se hace ese fichero 00:28:32
imposible, coges uno 00:28:35
que ya está por ahí y lo cascas y lo adaptas 00:28:36
¿vale? 00:28:40
claro 00:28:41
entonces 00:28:42
podríais coger el mío 00:28:44
que lo subo en un pispas 00:28:47
al aula virtual o podríamos 00:28:48
pedirle uno a ChaGPT 00:28:51
os gusta más ChaGPT 00:28:52
que yo, ¿verdad? 00:28:55
No, pero es por probar. 00:28:56
Ya, venga, vamos a decirle, venga, yo también prefiero pedir su HGPT porque es lo que vais a hacer siempre, ¿no? 00:28:57
Entonces, y así me ahorro subirlo a la ola virtual. 00:29:12
Bueno, lo voy a subir igualmente, pero puede ser. 00:29:17
Venga, ¿qué queréis? ¿Lista de recetas? 00:29:22
O datos jurídicos sobre la historia de España. 00:29:26
¿Me das un ejemplo de los4j2.xml? 00:29:29
Eso sí, se tiene que llamar así, 00:29:37
nada de cambiarlo de nombre. 00:29:40
Para que los4j2 lo encuentre, 00:29:42
él lo va a buscar por este nombre. 00:29:45
Si es Jason, los4j2.jason. 00:29:47
Si es yaml, los4j2.xml. 00:29:50
Vale. 00:29:52
¿Me das un ejemplo? 00:29:53
que configure tanto appenders fichero como fichero secuencial como consola y configure 00:29:56
Por separado el logger de una clase. 00:30:22
Venga, ¿me lo das? 00:30:29
Por favor. 00:30:31
Claro que sí, hombre. 00:30:35
Sin rotación. 00:30:39
Uy, yo lo quería con rotación. 00:30:40
Qué fallo. 00:30:41
Lo vemos con rotación. 00:30:42
Pídeselo con rotación, hombre. 00:30:43
Vale. 00:30:46
De la rotación. 00:30:47
Venga. 00:30:48
¿Para qué? 00:30:48
Vamos a copiarlo y lo cascamos en nuestro... 00:30:49
Ahora, ahora lo vemos. 00:30:51
a ver si yo sé interpretar 00:30:52
lo que nos ha generado 00:30:56
pero bueno 00:30:57
sí 00:30:57
aquí puedes ver el misterio secuencial 00:31:02
rotativo, así te saca 00:31:10
algo más guay 00:31:13
y se vuelve loco 00:31:13
como el cubo 00:31:18
en videojuego 00:31:20
vale, pues entonces 00:31:21
vamos a copiarlo 00:31:29
venga, pues ya está 00:31:31
este mismo que nos ha generado 00:31:41
¿dónde lo metemos? 00:31:42
en recursos, para que 00:31:45
la herramienta los4j lo encuentre 00:31:47
va a arrancar, tiene que estar 00:31:49
en una ruta del classpath 00:31:51
donde están todas las clases accesibles 00:31:52
para la máquina virtual 00:31:55
resources es una ruta 00:31:57
del classpad, pues ese es el sitio 00:31:59
maravilloso para poner los ficheros de configuración 00:32:01
¿que era con rotación secuencia o algo así? 00:32:03
nada, con cualquier cosa, da igual 00:32:06
entonces vamos a crear 00:32:07
aquí un nuevo fichero 00:32:09
que va a ser 00:32:10
log4j2.xml 00:32:14
y vamos a 00:32:19
pegar lo que nos ha dado 00:32:25
Que no sale nada rojo 00:32:27
Qué suerte hemos tenido 00:32:30
Dentro de la carpeta resources 00:32:31
Te creas un archivo 00:32:38
De nombre los4j2xml 00:32:40
Y pegas el código 00:32:42
Que te ha dado ChagPT 00:32:44
Podemos cambiar de guía en algún momento 00:32:45
Hay que usar ChagPT 00:32:51
Yo qué sé, si yo solo uso esa 00:32:52
No lo sé, pero hay algunas chinas 00:32:55
Por ahí muy chulas, ¿no? 00:32:57
Dicen 00:32:58
¿Cuál? 00:32:59
¿Cuál recomendáis vosotros? 00:33:04
¿Ya GPT? 00:33:07
Vale 00:33:09
Bueno, para cosas de desarrollo 00:33:10
No sé cuál será mejor, yo solo he usado esta 00:33:18
Bueno, Gemini alguna vez 00:33:20
Vale, pues a ver 00:33:21
Vamos a ver 00:33:23
aquí hay 00:33:27
dos cosas básicas 00:33:29
los appenders 00:33:31
y los loggers 00:33:33
y luego habría una cosa 00:33:36
que son los layouts, pero creo que no nos han metido 00:33:37
layouts ahí, es igual 00:33:39
new file, botón derecho, new file 00:33:41
vale, ¿qué son los appenders? 00:33:45
los appenders son 00:33:50
los sitios 00:33:52
por donde los loggers 00:33:54
Pueden enviar mensajes 00:33:55
Por defecto el appender 00:33:57
Si estaba sin configurar 00:34:00
Hemos visto que es la consola 00:34:02
Por defecto 00:34:03
Pero aquí en el blog 4j2xml 00:34:04
Ponemos todos los appenders que queramos 00:34:06
Aquí hemos 00:34:09
Aquí él me ha hecho 00:34:11
Tres appenders 00:34:12
Un appender consola 00:34:14
Para sacar por consola 00:34:17
Al que le da el nombre consola 00:34:18
Y le da este aspecto 00:34:21
le podéis cambiar el aspecto 00:34:23
y en lugar de que me salga el año 00:34:26
con cuatro cifras que es 00:34:28
que es muy largo, los segundos 00:34:30
tampoco me interesan tanto, 00:34:32
aunque yo no sé si este lo entiende, horas, minutos, 00:34:34
yo que sé, uno cambia 00:34:37
y hace aquí lo que le dé la gana. 00:34:38
Vale. 00:34:41
El nivel, el mensajito, 00:34:42
esta es la variable mensajito 00:34:44
del parámetro, del método log. 00:34:46
Bueno. 00:34:48
Normalmente uno aquí no cambia nada y ya está. 00:34:50
¿Qué otros posibles 00:34:52
Appenders me ha configurado? 00:34:54
El Appender 00:34:57
Ah, pues sí que me lo ha puesto rotativo 00:34:58
Espera, vamos a pasar 00:35:00
Primero del rolling file, vamos a este 00:35:02
El fichero 00:35:03
Un fichero normal 00:35:06
Lo ha llamado fichero secuencial 00:35:07
Fichero normal 00:35:09
¿Dónde se va a encontrar? 00:35:10
Él me ha dicho en la carpeta logs 00:35:14
Tendrá, log4j 00:35:15
La creará, la primera vez que lo usamos la creará 00:35:18
pues en la carpeta logs 00:35:20
secuencial.log 00:35:22
se va a llamar 00:35:24
luego en el archivo secuencial.log 00:35:25
es donde va a meter esos logs 00:35:27
¿vale? dentro de 00:35:29
la carpeta logs 00:35:31
lo va a meter y ahí hay detallitos de aspecto 00:35:33
append 00:35:36
vale 00:35:37
append true está claro 00:35:39
te los voy añadiendo 00:35:41
te voy sobre escribiendo 00:35:43
no menos añadelos 00:35:45
¿vale? bueno 00:35:46
y el otro posible 00:35:48
appender, el otro tipo posible 00:35:51
de appender, es este 00:35:53
rotativo 00:35:54
porque claro, si ponemos como appender 00:35:55
un fichero normal, es que 00:35:59
ese fichero llegará a un momento dentro de dos 00:36:01
meses que sea gigante 00:36:03
¿no? 00:36:05
porque todos los días, enviando todos los días 00:36:06
enviando, al cabo de dos meses 00:36:08
ese fichero es gigantesco 00:36:11
entonces podemos hacer un appender que sea 00:36:12
fichero rotativo 00:36:15
que 00:36:16
se va a llamar así el primero 00:36:18
pero luego 00:36:21
cada vez que te saltes de 10 megas 00:36:22
o la cantidad que uno le quiera poner aquí 00:36:24
2 gigas 00:36:27
o cada vez que te saltes de día 00:36:28
aunque eso no viene por defecto 00:36:30
¡Uy, qué listo! Me lo pone en comentarios 00:36:32
La verdad es que es súper útil este 00:36:35
Nos lo ha dicho 00:36:37
Cada vez que te saltes de día 00:36:38
o cada vez que te saltes de este tamaño 00:36:41
él te crea un fichero 00:36:43
nuevo 00:36:45
Con el nombre 00:36:45
Aplicación.log 00:36:48
Pero al que le añade 00:36:50
Lo que hayamos puesto aquí 00:36:51
El año 00:36:53
El nombre de los ficheros que te va 00:36:54
Creando 00:36:58
Tendrán este formato 00:36:59
Si nos parece muy feo 00:37:01
Se lo cambiamos 00:37:03
Entonces el rolling file mejor 00:37:04
Porque así no tenemos 00:37:06
Un fichero enorme 00:37:08
Vale, estos son los posibles 00:37:11
Los posibles a perder 00:37:13
ahora otra cosa son 00:37:15
los logger 00:37:17
a que aprender van a ir 00:37:19
bueno pues 00:37:21
logger, hay logger 00:37:23
por clase 00:37:25
veis, este logger 00:37:26
voy a borrar esto, este es el logger 00:37:28
de la clase main 00:37:31
este es el logger de mi clase main 00:37:33
si yo tengo más clases 00:37:35
habrá logger de sus propias clases 00:37:38
¿vale? pero luego está 00:37:40
un logger general 00:37:42
un superlogger, logger máximo, 00:37:43
que es el que manda 00:37:46
en todas. Pues ese 00:37:47
logger máximo se 00:37:49
configura aquí abajo 00:37:51
o debería 00:37:53
configurarse aquí 00:37:55
abajo, aquí. 00:37:57
Donde pone 00:38:00
logger raíz. Entonces, 00:38:01
este es el superlogger. 00:38:04
Aquí ponemos 00:38:06
el nivel que queremos. 00:38:07
Como hemos puesto 00:38:10
info, pues 00:38:11
solo se van a salir de info adelante. 00:38:13
El trace y el debug no van a salir, pero esto lo 00:38:15
cambiamos cuando nos dé la gana. 00:38:17
Y aquí ponemos a dónde 00:38:19
queremos que salgan esos logos. 00:38:21
¿Hay algún método desde dentro 00:38:24
que te cambie el fichero de configuración? 00:38:25
Es que 00:38:30
justo sería lo contrario. 00:38:31
Entonces, cambiar un fichero de configuración 00:38:33
desde el código es justo lo 00:38:35
contrario a lo que perseguimos. 00:38:37
Vale. 00:38:40
A lo mejor en una parte del programa te interesa que tenga más 00:38:40
Bueno, pero es que tú entonces haces 00:38:42
No lo sé 00:38:47
O sea, que una parte del programa 00:38:51
Use un log4 y otra parte use otro 00:38:55
Si se puede, no lo he visto nunca 00:38:57
Vale, entonces 00:39:01
Aquí uno pone tantos 00:39:03
Appenders como quiera 00:39:04
O sea, los superloggers de todos 00:39:06
Van a ir tanto a consola como a este 00:39:08
como no nos vamos a pasar de 10 megas nunca 00:39:11
ni de día 00:39:13
no vamos a estar aquí mandando logs hasta mañana 00:39:15
para verlo, pues no vamos a ver 00:39:17
el cambio, pero da igual, se va a ver el primer fichero 00:39:19
y ya está. Ahora, este es el 00:39:21
superlogger, pero uno podría 00:39:23
hacer eso ya así 00:39:25
configurar un logger 00:39:27
específico para cada clase 00:39:29
que eso ya sí que tiene relación con lo que tú me 00:39:30
estás diciendo, pero de otra manera, que es 00:39:33
oye, espérate, que yo quiero que mi clase 00:39:34
que en este caso mi clase 00:39:37
con dam2.main 00:39:39
quiero que mi clase funcione 00:39:41
de otra manera, esta clase, solo esta 00:39:43
esta me interesa que vaya 00:39:45
como debug, vale 00:39:47
pues entonces yo a esta clase 00:39:49
si quiero, la configuro 00:39:50
especialmente a ella 00:39:53
¿vale? 00:39:54
claro, entonces 00:39:57
todos los logger 00:39:59
de esta, todos los mensajes 00:40:01
de esta clase, les aplica a este nivel 00:40:03
mientras que al resto 00:40:05
les aplicará esto 00:40:07
y ahí puedes crear varios 00:40:09
para distintas clases 00:40:13
puedes crear varios 00:40:13
de tantos logger 00:40:14
claro 00:40:15
como tú puedes hacer 00:40:15
un logger por clase 00:40:17
pues puedes hacer 00:40:18
tantos logger por clase 00:40:20
y también podríamos hacer 00:40:21
poner aquí un paquete 00:40:22
en lugar de una clase 00:40:23
por ejemplo 00:40:25
pongo yo aquí 00:40:26
condandos 00:40:26
y esto aplica 00:40:27
a todas las clases 00:40:28
de ese paquete 00:40:29
vale, bueno 00:40:29
esperamos que 00:40:31
o sea, nos vamos 00:40:32
que os veo 00:40:32
con mucha prisa 00:40:33
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:
21
Fecha:
10 de octubre de 2025 - 12:30
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
40′ 37″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
183.20 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid