Blog error 404

Log4j y Spring

2011-06-22T10:26:00.000-07:00

La experiencia nos dice que completar nuestro código con trazas de log es una buena práctica a la hora de desarrollar. Log4j es una herramienta muy útil y libre implementada por Apache que nos va a ayudar en esta labor.

¿Por qué utilizar logs en vez de System.out?

La principal diferencia de cualquier API de log sobre un System.out.println() es la posibilidad de deshabilitar o categorizar las trazas de tal manera que no todas las trazas sean mostradas. Para ello, se definen varios niveles de traza en función de lo que queremos habilitar.

Componentes

Log4j consta de 3 componentes: loggers, appenders and layouts. Se complementan de tal manera que permitan habilitar los mensajes de log en función del tipo y nivel del mensaje (Loggers), controlar en tiempo de ejecución cómo se formatean esos mensajes (Layouts) y dónde se reportan esos mensajes (Appenders).

Niveles de log

Hay varios niveles de error, todos ellos definidos en la clase org.apache.log4j.Level. La prioridad de cada traza de error se asigna en función del método del logger que invoquemos.
Estos métodos son: debug, info, warn, error, fatal y log. Una traza de log estará habilitada si su nivel es igual o mayor que el nivel de trazas del logger.

La jerarquía de nivel de trazas es la siguiente:
DEBUG < INFO < WARN < ERROR < FATAL.
Hay dos niveles más, ALL y OFF, que estarán en el nivel más bajo y más alto respectivamente, y sirven para habilitar o deshabilitar todas las trazas.

El siguiente codigo es un ejemplo de este funcionamiento.

Logger logger = Logger.getLogger("logger ejemplo");



// Asigno nivel

logger.setLevel(Level.INFO);



// Se muestra ya que WARN &gt; INFO

logger.warn("¡Advertencia!");



// No se muestra ya que DEBUG &lt; INFO

logger.debug("Depurando");

Configuración

Log4j puede ser configurado programáticamente, sin embargo es más cómodo utilizar ficheros de configuración. Podemos utilizar 2 tipos de fichero, XML o properties.

Una configuración por defecto podría ser la siguiente:

package es.error404blog.test;



import org.apache.log4j.BasicConfigurator;

import org.apache.log4j.Level;

import org.apache.log4j.Logger;



public class Log4jTest {



    private static class Aplicacion {



        Logger logger = Logger.getLogger(Aplicacion.class);



        public void inicializa() {

            logger.debug("Inicializando...");

        }



        public void finaliza() {

            logger.debug("Finalizando...");

        }

    }



    public static void main(String[] args) {

        Logger logger = Logger.getLogger(Log4jTest.class);

        logger.setLevel(Level.ALL);



        BasicConfigurator.configure();



        Aplicacion a = new Aplicacion();

        logger.debug("Arrancando aplicacion...");

        a.inicializa();

        logger.debug("Finalizando aplicacion...");

        a.finaliza();

    }

}

Aquí cabe destacar la llamada a BasicConfigurator.configure(), que crea un ConoleAppender, que imprimirá en la consola y un PatternLayout con un formato especifico.
La salida quedaría del siguiente modo:



DEBUG: org.springframework.samples.petclinic.Log4jTest - Arrancando aplicacion...

0 [main] DEBUG org.springframework.samples.petclinic.Log4jTest  - Arrancando aplicacion...

DEBUG: org.springframework.samples.petclinic.Log4jTest - Finalizando aplicacion...

2 [main] DEBUG org.springframework.samples.petclinic.Log4jTest  - Finalizando aplicacion...

Configuración con properties

Para cargar la configuraci'on desde un properties bastar'ia con sustituir la linea del BasicConfigurator por

PropertyConfigurator.configure("src/test/java/com/blogerror404/test/log4j.properties");

y declaramos como ejemplo el siguiente properties:

log4j.rootLogger=DEBUG, stdout, rolling



log4j.appender.stdout=org.apache.log4j.ConsoleAppender

log4j.appender.stdout.layout=org.apache.log4j.PatternLayout



# Patrón que mapea un nombre de fichero y el número de línea.

log4j.appender.stdout.layout.ConversionPattern=%5p [%t] (%F:%L) - %m%n



log4j.appender.rolling=org.apache.log4j.RollingFileAppender

log4j.appender.rolling.File=example.log



log4j.appender.rolling.MaxFileSize=100KB

# Backup

log4j.appender.rolling.MaxBackupIndex=1



log4j.appender.rolling.layout=org.apache.log4j.PatternLayout

log4j.appender.rolling.layout.ConversionPattern=%p %t %c - %m%n

Configuración en Spring

Para integrar log4j con Spring el framework nos ofrece una clase que inicializa la configuración de log, lo cual nos evita declarar la configuración en nuestros fuentes. Esta clase es Log4jConfigurer.

La declaración quedaría del siguiente modo:

<bean id="log4jInitializer" class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">

 <property name="staticMethod" value="org.springframework.util.Log4jConfigurer.initLogging" />

 <property name="arguments">

    <list>

       <value>src/test/java/es/error404blog/test/log4j.properties:log4j.properties</value>

    </list>

 </property>

</bean>

De esta manera con la clase MethodInvokingFactoryBean se invoca el método estático Log4jConfigurer.initLogging con argumento el fichero de propiedades.

Si trabajamos en una aplicación web, podemos usar una configuración alternativa. Declaramos las siguientes líneas en el fichero web.xml de nuestra aplicación y spring cargará nuestra configuración de log4j.

<context-param>

  <param-name>log4jConfigLocation</param-name>

  <param-value>/WEB-INF/classes/log4j.properties</param-value>

</context-param>



<listener>

  <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>

</listener>

Tutorial: Primeros pasos con gwt

2011-06-10T09:14:00.000-07:00

Como bien dice el titulo, hoy vamos a dar nuestros primeros pasos con gwt (Google Web Toolkit).

Para realizar este pequeño tutorial he utilizado Eclipse Helios, Maven 2.2.1 y Gwt 2.1.1.

El eclipse lo podeis descargar de: http://www.eclipse.org/downloads/download.php?file=/technology/epp/downloads/release/helios/SR2/eclipse-jee-helios-SR2-win32.zip

Maven: http://maven.apache.org/download.html

y las librerías necesarias de gwt no hará falta por ahora que nos las descarguemos ya que esto lo hará maven por nosotros cuando lo hayamos configurado.

En eclipse, creamos un nuevo proyecto maven. (Para poder hacer esto necesitamos tener configurado maven en eclipse. Ver: Tutorial instalar maven en eclipse).

Seleccionamos donde queremos crear nuestro proyecto y damos a siguiente. En la siguiente pantalla nos pregunta que arquetipo queremos utilizar. Yo he utilizado el arquetipo maven-archetype-webapp (si os cuesta encontrarlo introducir webapp en el filtro y os aparecerá).

Damos siguiente. Ahora introducimos el group-id y el artifact-id.

Pulsamos finalizar.

Ya hemos creado el proyecto. Ahora debido a que el arquetipo no nos genera una carpeta donde colocar nuestros fuentes, tenemos que hacerlo nosotros. Nos vamos a la ruta donde hemos creado el proyecto y creamos una carpeta llamada java dentro de src/main.

Cuando lo hayamos hecho, abrimos una consola y nos vamos a la ruta donde esta nuestro proyecto, donde esta el fichero pom.xml y ejecutamos mvn eclipse:eclipse.

Con este comando generaremos de nuevo la estructura necesaria para que sea un proyecto de eclipse y nos coja los cambios que hemos hecho, es decir el nuevo directorio que hemos creado.

Cuando este ya todo esto hecho, ya podemos empezar a programar para crear una aplicación con gwt.

Creamos las siguientes clases y ficheros.

En src/main/java creamos el paquete com.example.helloworld.gwt.

En este paquete creamos el xml com_example_helloworld_gwt.gwt.xml que contendrá la configuración de gwt.

<?xml version="1.0" encoding="UTF-8"?>

<module rename-to='com_example_helloworld_gwt'>

   <!-- Inherit the core Web Toolkit stuff.  -->

   <inherits name='com.google.gwt.user.User'/>



   <inherits name='com.google.gwt.user.theme.standard.Standard'/>



   <!-- Specify the app entry point class.  -->

   <entry-point class='com.example.helloworld.gwt.client.HelloWorldEntryPoint'/>

 </module>

Dentro de com.example.helloworld.gwt.client creamos la clase que será nuestro entrypoint y la llamamos HelloWorldEntryPoint

package com.example.helloworld.gwt.client;



import com.google.gwt.core.client.EntryPoint;

import com.google.gwt.user.client.ui.Label;

import com.google.gwt.user.client.ui.RootPanel;



public class HelloWorldEntryPoint implements EntryPoint {



    public void onModuleLoad() {

        Label label = new Label("Hello world!!!!!");



        RootPanel.get().add(label);



    }



}

Creamos en el mismo directorio donde tenemos el fichero index.jsp, un fichero index.html que será nuestro html de entrada a la aplicación. En este html importaremos nuestro widget de gwt.

El contenido del html es :

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">



<html>

   <head>

     <meta http-equiv="content-type" content="text/html; charset=UTF-8">     

     <title>Mi primera aplicacion gwt</title>

     <script type="text/javascript" language="javascript" src="com_example_helloworld_gwt/com_example_helloworld_gwt.nocache.js"></script>

   </head>



   <body>



     

     <iframe src="javascript:''" id="__gwt_historyFrame" tabIndex='-1' style="position:absolute;width:0;height:0;border:0"></iframe>

     <h1>Mi primera aplicacion gwt</h1>

   

   </body>

 </html>

Con estos cambios nuestro proyecto debería quedar así:

El contenido del fichero pom.xml es el siguiente:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <groupId>com.dia.example</groupId>

    <artifactId>HelloWorld</artifactId>

    <packaging>war</packaging>

    <version>0.0.1-SNAPSHOT</version>

    <name>HelloWorld Maven Webapp</name>

    <url>http://maven.apache.org</url>

    <dependencies>

        <dependency>

            <groupId>junit</groupId>

            <artifactId>junit</artifactId>

            <version>3.8.1</version>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>com.google.gwt</groupId>

            <artifactId>gwt-servlet</artifactId>

            <version>${gwt.version}</version>

        </dependency>

        <dependency>

            <groupId>com.google.gwt</groupId>

            <artifactId>gwt-user</artifactId>

            <version>${gwt.version}</version>

        </dependency>

        

    

        <dependency>

            <groupId>com.google.code.gwt-dnd</groupId>

            <artifactId>gwt-dnd</artifactId>

            <version>2.5.6</version>

        </dependency>

        <dependency>

            <groupId>com.google.gwt</groupId>

            <artifactId>gwt-incubator</artifactId>

            <version>20101117</version>

            

        </dependency>

    </dependencies>

    <build>

        <finalName>HelloWorld</finalName>

        <plugins>





            <plugin>

                <groupId>org.apache.maven.plugins</groupId>

                <artifactId>maven-surefire-plugin</artifactId>

                <version>2.4.2</version>

                <configuration>

                    <argLine>-Xms256m -Xmx512m</argLine>

                </configuration>

            </plugin>



            

            

            <plugin>

                <artifactId>maven-clean-plugin</artifactId>

                <configuration>

                    <failOnError>false</failOnError>

                    <filesets>

                        <fileset>

                            <!-- clean up files from war:inplace -->

                            <directory>war</directory>

                            <includes>

                                <include>WEB-INF/classes/**</include>

                                <include>WEB-INF/lib/**</include>

                            </includes>

                            <followSymlinks>false</followSymlinks>

                        </fileset>

                    </filesets>

                </configuration>

            </plugin>

            <plugin>

                <artifactId>maven-compiler-plugin</artifactId>

                <version>2.0.2</version>

                <configuration>

                    <encoding>utf-8</encoding>

                    <source>1.5</source>

                    <target>1.5</target>

                    <showDeprecation>true</showDeprecation>

                    <showWarnings>true</showWarnings>

                </configuration>

            </plugin>





            <plugin>

                <groupId>org.codehaus.mojo</groupId>

                <artifactId>gwt-maven-plugin</artifactId>

                <version>2.1.0-1</version>

                <configuration>

                    <disableCastChecking>true</disableCastChecking>

                    <disableClassMetadata>true</disableClassMetadata>

                    <runTarget>/index.html</runTarget>

                    <webappDirectory>${basedir}/war</webappDirectory>

                    <compileReport>false</compileReport>

                    <extraJvmArgs>-Xms512m -Xmx512m</extraJvmArgs>

                    <hostedWebapp>${basedir}/war</hostedWebapp>

                    <gwtSdkFirstInClasspath>true</gwtSdkFirstInClasspath>

                    <force>true</force>

                </configuration>

                <executions>

                    <execution>

                        <goals>

                            <goal>compile</goal>

                            <goal>test</goal>

                        </goals>

                    </execution>

                </executions>

            </plugin>

            <!-- plugin war -->

            <plugin>

                <groupId>org.apache.maven.plugins</groupId>

                <artifactId>maven-war-plugin</artifactId>

                <version>2.1-alpha-2</version>

                <configuration>

                    <warSourceDirectory>${basedir}/src/main/webapp</warSourceDirectory>

                    <webappDirectory>${basedir}/war</webappDirectory>

                    <warName>${artifactId}</warName>

                </configuration>

            </plugin>

            

            



        </plugins>

    </build>



    <properties>

        <gwt.version>2.1.1</gwt.version>

    </properties>

</project>

Con esto ya tenemos concluido nuestro primer proyecto con gwt. Solo nos falta ejecutar, para ellos ejecutamos las tareas war:exploded y gwt:debug y cuando ya tengamos levantado el listener en el puerto 8000 ejecutamos un "Remote java Application" de eclipse para que la aplicación acabe de levantarse.

Abrimos una ventana del navegador e introducimos en la barra de direcciones la url :

http://127.0.0.1:8888/index.html?gwt.codesvr=127.0.0.1:9997

Nos saldrá el mensaje de Hello world!!! que hemos introducido en el entrypoint HelloWorldEntryPoint.java como un label.

Os dejo el código del proyecto en el subversión para que todos lo podáis descargar y probar.

https://error404blog.googlecode.com/svn/trunk/primerosPasosGWT

Ant y Maven

2011-04-30T03:24:00.001-07:00

Dado que un proyecto se comienza por los cimientos, nuestro primer post del blog es una breve reseña sobre 2 de las más importantes herramientas de gestión de proyectos y sus principales diferencias: Maven y Ant

Maven es una herramienta muy útil y muy similar a Ant, pero requiere para su utilización un menor grado de conocimiento. Sobre por qué herramienta decantarse, si Ant o Maven, en los diferentes proyectos habrá muchas opiniones, pero básicamente queremos que la herramienta nos ofrezca:

Reducir costes de desarrollo
Permitir a los desarrolladores centrarse en lo importante, es decir, en el negocio.
Agilizar tiempos

Ant y Maven son dos herramientas muy potentes y muy extendidas. Las principales diferencias son:

Ant no tiene convenciones formales, al contrario que Maven, como una estructura de directorios estándar.
Ant es procedural, es necesario indicar qué hacer y cuándo hacerlo. Maven es declarativo, simplemente con crear un fichero pom.xml y dejar tu código fuente en el directorio por defecto de Maven es suficiente. Maven se ocupa del resto.
Ant se basa en objetivos y una secuencia de tareas. Maven tiene un ciclo de vida definido, en el que con una llamada a un comando ejecutaremos todos sus pasos al instante.

La decisión entre una u otra herramienta no es simple; si un proyecto tiene demasiados procesos personalizados Ant puede ser una buena alternativa ya que es muy flexible. No obstante Maven ofrece la posibilidad de ejecutar scripts Ant.

El principal objetivo de Maven no es predominar en su uso sobre Ant. Maven fue creado con el objetivo de estandarizar el desarrollo de software, a fin de seguir el principio de la Convención sobre Configuración (CoC). Por ello, no es recomendable salirse de las convenciones que ofrece Maven.

Por todo lo comentado es muy recomendable utilizar Maven para proyectos nuevos, aunque Ant hoy en día sigue siendo una herramienta muy útil, ya que no todos los proyectos existentes son adaptables a Maven, o su migración sería muy costosa, algo totalmente indeseable