Buscar
Social
Ofertas laborales ES

Entries in j2se (2359)

viernes
jun012001

Log4java (Parte 1)

Introducción a log4j.




Log4j ha sido elegido recientemente finalista en la categoría de "API/Tecnología Java nueva o revisada más útil." de los JavaWorld Editors' Choice Awards, que podrían equipararse a los Oscar del mundo Java.



Desde javaHispano queremos acercarte este API que te sorprenderá tanto por su sencillez, como por su potencia.



¿Qué es Log4j y dónde puedo encontrarlo?



Log4j es un API para manejar el registro (log) de operaciones en nuestros programas, que tan necesario resulta en los períodos de depuración. Log4j es uno de los componentes del proyecto Jakarta (al igual que Tomcat) de Apache, cuya página web principal es: http://jakarta.apache.org/log4j/



¿Cómo funciona Log4j?



En primer lugar, debemos saber que el API nos ofrece cinco prioridades diferentes, que de mayor a menor son: DEBUG, INFO, WARN, ERROR, FATAL, aunque de ser necesario también es posible crear nuestras propias prioridades.



De manera similar a la estructuración en paquetes de Java, Log4j divide los tipos de registro por categorías, cuya prioridad es hereditaria. Por ejemplo, si no definimos una prioridad para la categoría "com.javahispano.prueba", heredaría la prioridad de "com.javahispano". De esta forma, una vez definida una categoría, podemos enviar peticiones de registro (log requests) utilizando los métodos que ésta nos ofrece.



Para determinar la información que acompaña a nuestros mensajes, Log4j nos ofrece los Layouts. Entre ellos tenemos el SimpleLayout, que simplemente muestra la prioridad y el mensaje, u otros más elaborados como PatternLayout que nos deja formatear con total libertad la información que podemos mostrar de entre toda la que nos permite Log4j.



Para configurar el registro en general disponemos de tres opciones, las clases BasicConfigurator, PropertyConfigurator y DOMConfigurator. La primera utiliza un Layout predefinido para ir mostrando el registro por pantalla. Con las otras dos podremos usar un fichero de configuración normal para la primera, y un fichero XML ya parseado para la segunda.



Finalmente, para determinar lo que Log4j debe de hacer con la información del registro, están los Appenders. Entre estos disponemos de una gran variedad, que cubrirá casi con toda seguridad todas sus necesidades. Podemos escribir en un OutputStream con WriterAppender, en ficheros con FileAppender, en ficheros de registro de como máximo un tamaño con RollingFileAppender, podemos enviar por correo la información con SMTPAppender, o registrarle en un servidor especial para Log4j, cuyas clases por supuesto se incluyen, con SocketAppender, o incluso a un daemo syslog con SyslogAppender. No sólo eso, también se pueden enviar a varios sitios a la vez, con lo que las posibilidades son tremendas.



Un ejemplo básico (extraído de la documentación).




import com.foo.Bar;

// Importar las clases de log4j.
import org.apache.log4j.Category;
import org.apache.log4j.BasicConfigurator;

public class MyApp {

// Define una variable estática de categoría que referencia
// a la instancia de Category llamada "MyApp"
static Category cat = Category.getInstance(MyApp.class.getName());

public static void main(String[] args) {
// Configuración básica que imprime en la consola
BasicConfigurator.configure();
cat.info("Entrando en la aplicación.");
Bar bar = new Bar();
bar.doIt();
cat.info("Saliendo de la aplicación.");
}
}



La clase com.foo.bar:



package com.foo;

import org.apache.log4j.Category;

public class Bar {
static Category cat = Category.getInstance(Bar.class.getName());

public void doIt() {
cat.debug("Hazlo de nuevo!");
}
}



Al ejecutar MyApp, la salida sería:



0 [main] INFO MyApp - Entrando en la aplicación.
36 [main] DEBUG com.foo.Bar - Hazlo de nuevo!
51 [main] INFO MyAqpp - Saliendo de la aplicación.


Próximo artículo.



En el próximo artículo veremos el PatternLayout que se utiliza en BasicConfigurator para obtener esta salida, y aprenderemos a crear una configuración y un registro más avanzados.
















Roberto Casas compagina sus estudios de 5º de Ingeniería
Informática en el Centro Politécnico Superior de Zaragoza con su
trabajo en la empresa Master-D y javaHispano.



Para cualquier duda o tirón de orejas, e-mail a:
roberto_ARROBA_javahispano.com




viernes
jun012001

Log4java (Parte 2)

Configurando log4j



En el anterior artículo aprendimos a usar BasicConfigurator, para
utilizar el API log4j de forma sencilla. Esta clase usa un PatternLayout
para mostrar la información que examinaremos a continuación,
para luego aprender a definir nuestros propias instancias de PatternLayout
y conseguir un log personalizado.


El PatternLayout de BasicConfigurator.



BasicConfigurator usa la cadena "%r [%t] %p %c %x -%m%n" como patrón
de conversión para el PatternLayout. Esta cadena se encuentra definida
estáticamente como PatternLayout.TTCC_CONVERSION_PATTERN. Con este
patrón de conversión, PatternLayout ofrece unos resultados
idénticos a los que se obtendrían usando el layout TTCC_Layout.



Ahora vamos a ver paso por paso como se utilizan estos patrones de conversión
(puede encontrar una descripción de todas las opciones que puede incluir
en un patrón de conversión en
http://jakarta.apache.org/log4j/docs/api/org/apache/log4j/PatterLayout.html

).




Las secuencias de carácteres que comienzan con el símbolo
%, son cadenas especiales que se reemplazan por información útil
sobre la aplicación que se está ejecutando.



Con %r mostramos el número de milisegundos desde el comienzo de
la aplicación hasta la petición del registro, en el ejemplo
del artículo anterior corresponde al 0, al 36 y al 51. Para mostrar
el nombre del hilo que generó la petición usamos %t, que como
además se encuentra entre corchetes hará que dicho nombre aparezca
de la misma forma ([main] en el ejemplo del artículo anterior). El
%p se usa para mostrar la prioridad (DEBUG, INFO, ...) del evento de log.
Con %c mostramos la categoría a la que pertenece el evento (en el
ejemplo del artículo anterior corresponde a com.foo.Bar y MyApp).
%x no hace que se muestre nada por pantalla, ya que en la aplicación
no hay contexto de diágnostico anidado (NDC -> nested diagnostic
context) asociado al hilo que generó el evento. Finalmente, con %m
mostramos el mensaje, y con %n se añade el separador de línea
que se use en la plataforma.




Además de los reemplazamientos, podemos utilizar modificadores de
formato al estilo de la familia de funciones printf en C. Para ello vamos
a ver en la siguiente tabla como formatear la cadena con la que se muestra
la categoría a la que pertenece el evento:

















































Modificador de formato

Justificación a izquierda Anchura mínima Anchura máxima Explicación
%20cno20noRellena a la izquierda con espacios si el nombre de la categoría
es menor de 20 carácteres. 
%-20c

20noRellena a la derecha con espacios si el nombre de la categoría
es menor de 20 carácteres.
%.30cN/Dno30Corta desde el principio si el nombre de la categoría
es más largo de 30 carácteres. 
%20.30cfalse2030Rellena a la izquierda con espacios si el nombre de la categoría
es menor de 20 carácteres. De lo contrario, si éste es más
largo de 30 carácteres lo corta desde el principio.    
%-20.30ctrue2030Rellena a la derecha con espacios si el nombre de la categoría
es menor de 20 carácteres. De lo contrario, si éste es más
largo de 30 carácteres lo corta desde el principio.    



Definiendo nuestro propio PatternLayout.



Después de la sección anterior, ya deberíamos de ser
capaces de especificar nuestro propio PatternLayout, y ampliarlo con la información
que podemos encontrar en los documentos del API. Para que sirva como ejemplo,
voy a proponer un PatternLayout que resultará extremadamente útil
en tiempo de depuración, dada la cantidad de información que
proporciona, pero que desaconsejo su uso en versiones finales por problemas
de eficiencia. El PatternLayout que usaremos a continuación será:
"%-5p [%d{ISO8601}] (%M [%C:%L]) - %m%n". Como nueva información,
tendremos la fecha del evento, y el método, la clase y la línea
en la que se produce el evento de log.



Usando PropertyConfigurator con nuestro PatternLayout.



Ahora que hemos aprendido a crear nuestro PatternLayout, debemos saber como
podemos usarlo en nuestras aplicaciones.



Para usar PropertyConfigurator nos crearemos un fichero con las siguientes
líneas:




log4j.rootCategory=DEBUG, A1
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%-5p [%d{ISO8601}] (%M [%C:%L]) - %m%n



Con la primera línea especificamos en primer lugar que para la categoría
raíz, sólo se mostrarán los mensajes de prioridad mayor
o igual que DEBUG, y que se usará como Appender (que veremos más
a fondo en el próximo artículo) A1. Se podría añadir
más de un Appender a una categoría separándolos por
comas tras la prioridad. Si quisiéramos definir una prioridad y un
Appender distintos para la categoría com.javahispano podríamos
a continuación añadir:


log4j.category.com.javahispano=INFO, A2


La segunda línea especifica el tipo de Appender, que ya veremos lo
que es. Basta con saber que este hará que toda la información
se nos muestre por pantalla.



La tercera línea hace que el layout del appender que estemos definiendo
sea del tipo PatternLayout.



La última línea es la que asigna el patrón de conversión
que queremos utilizar.



Ya podemos crear una pequeña aplicación para probar nuestro
PatternLayout:




import org.apache.log4j.*;

public class Log4jCap2 {

static Category cat = Category.getInstance(Log4jCap2.class.getName());

public static void main(String[] args) {
PropertyConfigurator.configure(args[0]);
cat.info("Entrando.");
Foo f = new Foo();
f.pru();
cat.info("Saliendo.");
}
}



A continuación vemos la clase Foo que se utiliza en nuestro programa.



import org.apache.log4j.*;

public class Foo {

static Category cat = Category.getInstance(Foo.class.getName());

public Foo() {
cat.debug("Creando un foo");
}

public void pru() {
cat.info("En pru");
}
}


Para ejecutar el programa de prueba simplemente tenemos que pasarle el nombre
que le hayamos dado al fichero de configuración como primer parámetro
y obtendremos:




INFO [2001-05-22 14:01:44,283] (main [Log4jCap2:9]) - Entrando.
DEBUG [2001-05-22 14:01:44,302] (<init> [Foo:7]) - Creando un foo
INFO [2001-05-22 14:01:44,304] (pru [Foo:11]) - En pru
INFO [2001-05-22 14:01:44,306] (main [Log4jCap2:12]) - Saliendo.


Usando DOMConfigurator con nuestro PatternLayout.



Como habrá visto, el esquema del fichero de configuración es
claramente jerárquico, por lo tanto, encaja perfectamente su descripción
dentro de un fichero XML.



Para usar ficheros XML para configurar el log, log4j nos ofrece la clase
DOMConfigurator. Esta clases es muy similar a PropertyConfigurator, pero
espera un fichero en un formato XML determinado por el fichero log4j.dtd (puedes descargar este fichero de aqui).
El fichero de configuración XML equivalente al que hemos usado anteriormente
es el que sigue:



<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration>
<appender name="A1" class="org.apache.log4j.ConsoleAppender">
<layout class="org.apache.log4j.PatternLayout">
<param name="ConversionPattern" value="%-5p [%d{ISO8601}] (%M [%C:%L]) - %m%n"/>
</layout>
</appender>

<root>
<priority value ="debug" />
<appender-ref ref="A1" />
</root>
</log4j:configuration>



La aplicación de prueba quedará en este caso así:



import org.apache.log4j.*;
import org.apache.log4j.xml.*;

public class Log4jCap2 {

static Category cat = Category.getInstance(Log4jCap2.class.getName());

public static void main(String[] args) {
DOMConfigurator.configure(args[0]);
cat.info("Entrando.");
Foo f = new Foo();
f.pru();
cat.info("Saliendo.");
}
}



Y la salida será por supuesto equivalente:



INFO [2001-05-22 14:32:47,328] (main [Log4jCap2:10]) - Entrando.
DEBUG [2001-05-22 14:32:47,363] (<init> [Foo:7]) - Creando un foo
INFO [2001-05-22 14:32:47,365] (pru [Foo:11]) - En pru
INFO [2001-05-22 14:32:47,367] (main [Log4jCap2:13]) - Saliendo.


Próximo artículo.


En el próximo artículo veremos como usar los distintos tipos de Appenders que nos ofrece log4j.
















Roberto Casas compagina sus estudios de 5º de Ingeniería
Informática en el Centro Politécnico Superior de Zaragoza con su
trabajo en la empresa Master-D y javaHispano.



Para cualquier duda o tirón de orejas, e-mail a:
roberto_ARROBA_javahispano.com




sábado
may262001

Blackdown libera Java3D y JMF para Linux

Blackdown sigue portando el JDK para Linux. Esta vez han terminado con Java3D en su version 1.2.1_01 y la version 2.1.1 de JMF.


Poco a poco vamos disponiendo de todas las API de Java para Linux.
viernes
may252001

Thin-Client Framework: tus clientes inteligentes

Thin-Client Framework (TCF) es un framework presentado en la división opensource de IBM de alphaworks que basado en el patron "modelo-vista-controlador" permite desarrollar aplicaciones clientes "ligeras", reusables y modulares.
jueves
may242001

J2SE 1.4 Beta!.

Pues sobre esta noticia no hay mucho que decir, simplemente ya esta ahí: J2SE 1.4.

Entre sus novedades estan la integración total del proceso de XML, una nueva Network I/O API escalable, JDBC 3.0 y mejoras del motor del API Java2D y del de seguridad, como SSE (Seckure Socket Extension) y un API de criptografia.