Formato y Manipulacion de Fechas con Java 1

Tenemos momentos en la vida en que a algun usuario latoso se le ocurre pedir que en su aplicacion se presente la hora con algun formato determinado, pero la hora que obtenemos del sistema o de una bd pues por cuestiones agenas a nosotros no tiene el formato que requerimos.

para solucionar este problemita podemos utilizar una clase llamada: SimpleDateFormat

cuando invoquemos al contructor le indicamos como queremos el formato de la fecha, por ejemplo

SimpleDateFormat formato = new SimpleDateFormat("dd/MM/yyyy HH:mm");
SimpleDateFormat formato = new SimpleDateFormat("dd/MM/yyyy");
SimpleDateFormat formato = new SimpleDateFormat("HH:mm");
SimpleDateFormat formato = new SimpleDateFormat("yyyy-dd-MM");

y para poder utilizar esta variable para formatear una fecha:

String fechaFormateada = formato.format(fecha);
donde fecha es una variable tipo date

de este modo realizamos un formato rapido y sensillo de una fecha sin quebrarnos la cabeza

tambien podemos realizar la operacion inversqa

CONVERTIR DE UNA CADENA A UNA VARIABLE TIPO DATE

utilizando la misma variable indicamos como esperamos la fecha
SimpleDateFormat formato = new SimpleDateFormat("yyyy-dd-MM");
solo necesitamos hacer una inversa a la operacion

Date fecha = formato.parse(fechaCadena);
donde fechaCadena es una fecha con el formato indicado en el constructor de la variable formato

Archivos properties

En ocaciones es muy util, mas cuando de aplicaciones web se trata poder modificar datos sin necesidad de recompilar nuestra aplicacion, en casos como datos de acceso a una bd, rutas para guardar nuestros logs, rutas hacia diversas paginas. Todo esto lo podemos guardar en un archivo de propiedades el cual no se necesita compilar.

puedes utilizar un bloc de notas para crear el properties, lo unico q tienes que hacer es guardarlo con la extencion .properties

ya que tenemos realizado esto, podemos comenzar a agregar propiedades a nuestro archivo
por ejemplo la propiedad: hola.mundo =hola mundo desde mi archivo properties
si te fijas el nombre de la propiedad fue hola.mundo pero no es una oblicacion poner el punto, lo que si es no poner espacios, siendo de este modo que una propiedad puede llamarse
hola.mundo
hola_mundo
holaMundo
...
y el texto que se encuentre despues de el signo de igual sera tomado como el valor de esa propiedad, no es necesario poner comillas como acostumbramos al asignarles valores a las cadenas en java.

utilizaremos ese archivo properties de 2 distintas formas
1.- guardado en una carpeta externa a nuestra aplicacion
2.- dentro de nuestra aplicacion

DENTRO DE UNA CARPETA EXTERNA A LA APLICACION

creemos una carpeta llamada archivo_de_propiedades y dentro de ella coloquemos nuestro archivo properties

en un proyecto java creemos una clase que se llame InvocadorProperties.java dentro de la clase crearemos:

1.- un metodo obtenerProperties que devuelva un String
2.- una variable tipo Properties que llamaremos archivoProperties
3.- un metodo llamado cargarProperties
4.- un metodo cerrarProperties
5.- una variable tipo FileInputStreama que llamaremos fis

EN EL METODO CARGARPROPERTIES
1.- declararemos un bloque try catch, el cual lanze dos excepciones de tipo: FileNotFoundException y IOException
quedando de la siguiente forma

try{
}
catch(FileNotFoundException e){
}
catch(IOException e){
}

2.- dentro del bloque try tenemos que saber el nombre de nuestro archivo properties y su ruta, para ello supongamos las variables ruta y archivo
String ruta="c:\\archivo_de_propiedades\\";
String archivo="archivo.properties";

3.- inicialicemos nuestra variable de tipo FileInputStream que recibira como parametros la ruta y el archivo
fis = new FileInputStream(ruta+archivo);

4.- inicialicemos nuestra variable properties con nuestro FileInputStream
archivoProperties.load(fis);

YA TENEMOS CARGADO NUESTRO ARCHIVO PROPERTIES

CERREMOS EL ARCHIVO PROPERTIES
1.- utilizando el metodo cerrarProperties creemos un bloque try catch que lanze una excepcion de tipo IOException
try{
}
catch(IOExeption e){
}

2.- dentro del bloque try, solo tenemos que preguntar si nuestra variable tipo FileInputStream es diferente de null, si es asi, solo hagamosle un close
if( fis != null ){
fis.close();
}

OBTENER UNA PROPIEDAD DEL ARCHIVO
para obtener una propiedad de nuestro archivo, como es el caso de la propiedad hola.mundo solo tenemos que realizar lo siguiente

1.- preguntamos si nuestra variable de propiedades es diferente de null si lo es simplemente invocamos su metodo getProperty()

if( archivoProperties != null ){
return archivoProperties.getProperty("hola.mundo");
}
return null;

al retornar una cadena nuestro metodo, devemos de asegurarnos retornar minimamente un null

de este modo podemos cambiar el valos de nuestra propiedad sin recompilar el programa, o añadir nuevas propiedades sin necesidad de recompilar el programa, un ejemplo de esto puede ser: tener un grupo de propiedades llamadas variable1, variable2 etc, y mediante un for en java recorrer esas propiedades, asi q si seguimos agregando variablesN, sin necesidad de recompilar podriamos utilizarlas

configurando log4j para una aplicacion web utilizando datos variables

Algunas veces cuando tenemos una aplicacion, que se alojara en diferentes servidores, necesitamos guardar el archivo en diferentes ubicaciones, pero para no estar modificando cada ves nuestra aplicacion, podemos utilizar datos variables, como la ruta del archivo, asi nos podemos casi casi olvidar de configurar las rutas

para el ejemplo necesitamos dar una leida a los 2 anteriores articulos de log4j para realizar esto de una forma rapida

lo que necesitamos realizar es

1.- creamos una clase que herede de nuestro escuchador Log4jConfigListener que tenemos en nuestro web.xml

public class ConfiguradorLog4J extends Log4jConfigListener {
}


2.- sobre escribimos el constructor de nuestra clase

public ConfiguradorLog4J(){
super();
}

3.- tenemos de 2 definir en esta clase la ruta (que es poco conveniente por que si queremos cambiar la ruta tenemos que recompilar el proyecto) o obtener la ruta de un archivo properties

en este caso simulare que obtengo la ruta de un archivo properties (el acceso al properties lo explicare en otra entrada)

4.- en nuestro constructor tendriamos que hacer algo como
System.setProperty("ruta.archivo.log4j", PropertyUtils.getProperty("ruta.archivo.log4j"));

lo que estamos haciendo es agregar a las propiedades del proyecto una nueva propiedad que contiene la ruta de nuestro archivo de log, la propiedad se llamara en este caso ruta.archivo.log4j y la obtiene de una clase que accesa a un archivo de propiedades

5.- tenemos que modificar nuestro archivo xml, especificamente donde indicamos la ruta del archivo donde guardaremos los logs

lo cambiariamos por:
param name="file" value="${ruta.archivo.log4j}/archivo_de_log.log" /
ahora cada ves que nuestra aplicacion cambie de servidor o de ruta de logs, solo tenemos que cambiar el archivo de propiedades y reiniciar nuestra aplicacion en el servidor

6.- finalmente, tenemos que cambiar nuestro listener en el archivo web.xml

en ves de tener la siguiente linea:
listener-class
org.springframework.web.util.Log4jConfigListener
/listener-class

por:

listener-class
paquete.de.tu.archivo.de.log.ConfiguradorLog4J
/listener-class

y hemos terminado una configuracion dinamica de nuestro log4j


NOTA: tambien puedes utilizar las propiedades de tu apache o de java, si fuera el caso no es necesario que realizes todos los pasos anteriores, el unico que tendrias que realizar seria el paso numero 5, puedes utilizar variables como: user.home, java.home etc.

les dejo una pagina con propiedades de java que pueden utilizar, el unico detalle es que algunas cambian de valor en aplicaciones stand alone y web, pues unas toman valores dependiendo del servidor que utilicen

http://www.mindspring.com/~mgrand/java-system-properties.htm

configurando log4j para una aplicacion web

La entrada anterior veiamos como poder configurar log4j en una aplicacion stand alone

para una aplicacion web no cambia mucho, si revisas el articulo, comentaba que para inicializar el archivo xml lo hicieramos en la clase principal, cosa que no existe en una aplicacion web, pues normalmente una aplicacion web su principal es un index.jsp por ejemplo, por lo tanto configuremos ! ! !

en ves de hacer una clase principal, sigamos los siguientes pasos:

1.- en nuestro archivo de configuracion web.xml tenemos que agregar unas cuantas lineas:

context-param
param-name
log4jConfigLocation
/param-name
param-value
/rutaDelArchivo/archivoLog4j.xml
/param-value
/context-param


definimos nuestro configurador de log4j, y definimos la ruta del archivo

2.- ya realizado esto, necesitamos que nuestra aplicacion este atenta a los llamados que hacemos a log4j esto lo realizamos de la siguiente manera

agregando un listener a nuestra aplicacion
listener
listener-class
org.springframework.web.util.Log4jConfigListener
/listener-class
/listener




LISTO !! YA TENEMOS CONFIGURADO NUESTRO LOG4J PARA UNA APLICACION WEB ! !



NOTA: recuerda que la configuracion del archivo xml y el llamado en las clases queda de la misma forma que cuando configuramos el los para la aplicacion stand alone

configurando log4j para una aplicacion stand alone

Esta ocacion, abordare de forma rapida como poder configurar log4j en nuestros proyectos stand alone.

algunas ocaciones queremos tener un registro de algunos acontesimientos que pasan con nuestra aplicacion, por ejemplo tener un documento donde guardar la hora en que ocurrio algo inersperado en el sistema, una exception, o alguna accion.

una forma muy sensilla es utilizar esta libreria para lograr nuestro cometido, por lo cual necesitamos tener lo siguiente:

1.- descargar la libreria de log4j en -> http://logging.apache.org/log4j/1.2/download.html

ahora en tu proyecto crea una carpeta a la altura de src, que puedes llamar lib (por estandar), agregar la libreria que descargaste

hecho esto ve a las propiedades de tu proyecto, y agrega la libreria (esto es necesario solo para aplicaciones stand alone, y se hace por defecto para aplicaciones web)

lo que pasa a continuacion, es que cuando ejecutes tu aplicacion, te diria antes de hacer cualquier cosa, que configures tu log4j

bueno, ahora configuremoslo:

crea un archivo .xml y llamalo digamos logsAplicacion :)

TODO LOS CODIGOS LLEVAN SU MAYOR Q Y MENOR Q, SOLO Q ME LOS QUITA ¬¬

1.- cuando creas un xml por defecto se pone :
?xml version="1.0" encoding="UTF-8"?
pero bueno si no ya sabes q hacer.

2.- agrega la siguiente linea de codigo para que tu aplicacion sepa q se trata de un documento de configuracion para el log
!DOCTYPE log4j:configuration PUBLIC "-//LOGGER" "http://logging.apache.org/log4j/1.2/apidocs/org/apache/log4j/xml/doc-files/log4j.dtd"

ahora todo el codigo que veremos a continuacion va entre un bloque xml

log4j:configuration debug="true"

/ log4j:configuration

tenemos 2 configuraciones basicas, que crees un archivo y guardes todos tus acontecimientos o que imprimas en consola todos tus acontecimientos, veamos la primer forma

3.- tenemos que crear un bloque appender, dentro del cual configuraremos nuestras politicas para crear el archivo de log, le brindamos tambien un nombre para poder utilizarlo despues
appender name="log_en_archivo" class="org.apache.log4j.RollingFileAppender"

/ appender

4.- dentro de este bloque, definimos el tamaño maximo de nuestro archivo:
param name="maxFileSize" value="100MB" /

5.- definamos la ruta y nombre de nuestro archivo
param name="file" value="c://logs/archivo_log.log" /

6.- definamos el layout que utilizaremos para escribir la informacion en el archivo
layout class="org.apache.log4j.PatternLayout"

param name="ConversionPattern" value="%d{ISO8601} %5p %c{1}:%M - %m%n"/

/ layout
no abundare mucho en esta parte, pero para mas informacion, busca el apli de log4j, la clase patternLayout

7.- bueno hemos terminado con el bloque appender, ahora tenemos que llamarlo, es algo asi como si de un metodo llamaramos a otro
root

priority value="info" /

appender-ref ref="log_en_archivo"/

/root

si queremos que la informacion se pinte en consola solo hay que modificar un poco lo que ya tenemos

1.- la clase que ocupa nuestro appender cambiaria, ya no seria RollingFileAppender, seria ConsoleAppender lo que nos llevaria a algo como:

appender name="log_en_consola" class="org.apache.log4j.ConsoleAppender"

2.- los parametros de tamaño de archivo y archivo los sustituimos por:

param name="Target" value="System.out"/
esto hara que el log se pinte en consola

3.- y para llamarlo, en el bloque root llama al nuevo appender
si quieres llamar a los 2 solo agrega los 2 llamados a los appender, asi lo puedes realizar n veces

NOTA: si ves el bloque root tengo una etiqueta llamada priority, es por que los log se manejan por prioridad, en este caso tengo info, pero hay mas como debug, pero la neta no recuerdo los otros, como sea en el api de log4j lo encuentras :) si no me mandas un comment

LLAMANDO A NUESTRO ARCHIVO DE CONFIGURACION

ya tenemos nuestro archivo de configuracion, si lo hubieramos nombrado log4j.xml hay hubieramos terminado todo, ya que al cargar la libreria, al ejecutar el proy se busca el archivo de configuracion con ese nombre. pero pues q chiste, por eso lo hemos nombrado logsAplicacion.xml

para poder invocar el archivo en tu clase principal, antes de q comienzes a codificar, llamemos a nuestro log. Dentro de nuestra clase main hacemos lo siguiente

1.- DOMConfigurator.configure(Loader.getResource("logsAplicacion.xml"));
no indicamos ruta, pues se supone que este archivo se encuentra a dentro de la carpeta src

SOLO NOS FALTA PODER UTILIZAR NUESTRO ARCHIVO DE CONFIGURACION

ya tenemos nuestro archivo, y ya esta cargado, falta utilizarlo en las clases que deceemos

1.- supongamos q tenemos una clase llamada Pruebas.java

2.- dentro de la clase, y como una variable global declaramos a nuestro loguer, haciendo llamado a la clase que queremos loguear
private static Logger log = Logger.getLogger( Prueba.class );


y por ejemplo en ves de poner System.out.println("Entrando al sistema");
System.out.println("Operacion Realizada");

bastara poner log.info("Entrando al sistema");
log.("Operacion realizada");

en el caso de las excepciones como

try{ }
catch(SQLException e) {
System.out.println("Error en la consulta");
}

pondriamos


try{ }
catch(SQLException e) {
log.error("Error en la consulta", e);
}

asi tanto en archivo como consola se imprimira todo lo que deceemos, para poder asi tener un control de nuestras acciones


como pueden ver en realidad no es mucho trabajo, por algo muy presiado como son los logs, que nos pueden sacar de grandes aprietos, sin necesidar de tener que debuguear una aplicacion para saber donde ocurrio un error o algo por el estilo

espero que sea de su agrado.