Creacion De Archivos III (Archivos para Batch, con el Framework flatworm)

Esta es la tercera y ultima forma que posteare para poder crear archivos con informacion masiva

esta ocacion utilizaremos un framework llamafo "FLATWORM" el cual tiene la caracteristica de mapear en un archivo xml una o mas clases (de aqui en adelante Beans), en este archivo xml definiremos:

1.- Longitudes de campos
2.- Tipo de dato del campo
3.- Posicion del campo sobre el archivo
4.- Caracteres de relleno
5.- Formato a convertir un dato (conversion de fechas, alineacion de la informacion)


Iniciemos la construccion de archivos con flatworm


1. Crearemos un proyecto java, y le agregaremos 4 jars

     commons-beanutils.jar 
     commons-collections.jar (para mi caso utilizare la version 3.0) 
     commons-logging.jar
     flatworm.jar (para mi caso utiliare la version 2.0.1)  

*siendo los primeros 3 de apache 

2. procedamos a crear 4 paquetes

     com.archivos.bean
     com.archivos.configurador
     com.archivos.escritura
     com.archivos.main

3.- en el paquete com.archivos.bean crearemos un bean llamado Productos con las siguientes variables

     enExistencia           int
     nombre                   String
     codigo                    String
     fechaInventario        String
     vendidas                 int

con sus metodos get y set

4.- sobre escribiremos el metodo toString del bean quedando lo siguiente

public String toString(){
    return enExistencia + nombre + codigo + fechaInventario + vendidas;
} 

5.- crearemos en el paquete com.archivos.configurador una clase llamada DatosIniciales que contendra las siguientes variables
     nombreArchivo
     rutaSubidaArchivo
     archivoWarm
     beanWarm
     recordWarm

6.- en el paquete com.archivos.escritura crearemos una clase llamada EscrituraArchivo quedando de la siguiente forma

    private FileCreator archivo; //clase encargada de crear y escribir sobre el archivo
    private DatosIniciales datos;  
     
     // Metodo que crea el archivo, el constructor de FileCreator recibe como primer parametro
     //la ruta y nombre del archivo xml y como segundo parametro el nombre y ruta del archivo
     //que se creara
     public void abrirArchivo(){
        try {
            archivo = new FileCreator(getDatos().getArchivoWarm(), getDatos().getRutaSubidaArchivo() + getDatos().getNombreArchivo());
            archivo.open();           
        } catch (FlatwormCreatorException e) {
            System.out.println("Error al crear el archivo");
        } catch (UnsupportedEncodingException e) {
            System.out.println("Codificacion del archivo no aceptada");
        }
    }
    
     //clase que se encargara de cerrar el archivo creado
    public void cerrarArchivo(){       
        try {
            if(archivo != null){
            archivo.close();
            }
        } catch (IOException e) {
            System.out.println("Error al cerrar el archivo");
        }
    }
    
     //clase encargada de escribir sobre el archivo, recibe como parametros el bean
     //el metodo setBean recibe como parametros el nombre de nuestro bean, pero como esta
     //mapeado en nuestro arhivo xml, como segundo parametro nuestro bean
     //le agregamos un recordSeparator para que haga saltos de linea(esto es por que bloc de      //notas no reconocera los saltos de linea, cualquier otro editor si)
     //el metodo write se encarga de escribir y recibe como parametros el recordWarm que
     //hemos mapeado en nuestro xml
    public void escribir(Productos bean){       
        try {
            archivo.setBean(getDatos().getBeanWarm(), bean);
            archivo.setRecordSeperator("\r\n");       
            archivo.write(getDatos().getRecordWarm());
        } catch (FlatwormCreatorException e) {
            System.out.println("Error en el FlatWormCreator");
        } catch (IOException e) {
            System.out.println("Error de IO");
        }
    } 


7.- en el paquete com.archivos.main crearemos un metodo ArmarArchivos
que quedara de la siguiente forma


    EscrituraArchivo escritura;
    DatosIniciales datos;
   
    public ArmarArchivos(){
        escritura = new EscrituraArchivo();
        datos = new DatosIniciales();
    }


    //este metodo hara las veces de una consulta a una bd, solo para el ejemplo :)
    public List<Productos> consultar(){
        List<Productos> productos = new ArrayList<Productos>();
        Productos producto1 = new Productos();
        Productos producto2 = new Productos();
        Productos producto3 = new Productos();
       
        producto1.setCodigo("aaxd");
        producto1.setEnExistencia(10);
        producto1.setFechaInventario("09/05/2011");
        producto1.setNombre("aspirina");
        producto1.setVendidas(5);
       
        producto2.setCodigo("zzsd");
        producto2.setEnExistencia(20);
        producto2.setFechaInventario("05/05/2011");
        producto2.setNombre("melox");
        producto2.setVendidas(1);
       
        producto3.setCodigo("xxxxxxxxxx");
        producto3.setEnExistencia(50);
        producto3.setFechaInventario("09/04/2011");
        producto3.setNombre("desodorante");
        producto3.setVendidas(10);
       
        productos.add(producto1);
        productos.add(producto2);
        productos.add(producto3);
       
        return productos;
    }


    public static void main(String[] args) {
        ArmarArchivos armar = new ArmarArchivos();       
        
        // asignacion de informacion a la clase datos
        System.out.println("Asignando Datos ...");       
        armar.datos.setArchivoWarm("D:\\ejemplosJavaLimos\\ProductosXML.xml");
        armar.datos.setBeanWarm("productosBean");//esta en el xml
        armar.datos.setNombreArchivo("EjemploFlatWorm.txt");
        armar.datos.setRecordWarm("productosBeanW");//esta en el xml
        armar.datos.setRutaSubidaArchivo("D:\\ejemplosJavaLimos\\");
        armar.escritura.setDatos(armar.datos);
       
        List<Productos> resultados = armar.consultar();
 
        System.out.println("Armando Archivos ...");        
        armar.escritura.abrirArchivo();
        for(Productos producto : resultados){
            armar.escritura.escribir(producto);
        }
        armar.escritura.cerrarArchivo();
    }
     
 8.- hemos hablado de un bendito archivo xml, pues ahora lo presento, se llamara ProductosXML.xml 

< ?xml version="1.0" encoding="ISO-8859-1"? >
< file-format >
     < converter name="char" class="com.blackbear.flatworm.converters.CoreConverters" method="convertChar" return-type="java.lang.String"/ >
      < converter name="int" class="com.blackbear.flatworm.converters.CoreConverters" method="convertInteger" return-type="java.lang.Integer"/ >
     < record name="productosBeanW" >
         < record-ident >
            < length-ident minlength="45" maxlength="45" / >
        < /record-ident >
        < record-definition >
            < bean name="productosBean" class="com.archivos.bean.Productos"/ >
            < line >
                < record-element length="5" beanref="productosBean.enExistencia" type="int" >
                    < conversion-option name="justify" value="left"/ > 
                    < conversion-option name="pad-character" value=" " / > 
                < /record-element >
                < record-element length="20" beanref="productosBean.nombre" type="char" >
                    < conversion-option name="justify" value="right"/> 
                    < conversion-option name="pad-character" value="-" / >
                < /record-element >
                < record-element length="5" beanref="productosBean.codigo" type="char" >
                    < conversion-option name="justify" value="right"/ > 
                    < conversion-option name="pad-character" value="@" / >
                < /record-element>
                < record-element length="10" beanref="productosBean.fechaInventario" type="char" >
                    < conversion-option name="justify" value="right"/ > 
                    < conversion-option name="pad-character" value=" " / > 
                < /record-element >
                < record-element length="5" beanref="productosBean.vendidas" type="int" >
                    < conversion-option name="justify" value="right"/ > 
                    < conversion-option name="pad-character" value=" "  />
                < /record-element >               
            < /line >
        < /record-definition >
    < /record >
< /file-format > 

**DONDE: 

*Las Etiquetas converter, definiran el tipo de variable, en este caso recibire int y String, por lo tanto declarare una del tipo in y una del tipo char(no String)  

*Nuestro record se llamara productosBeanW, dentro de el podemos tener multiples beans, por eso la diferencia

*Dentro del bloque record-ident definimos la longitud maxima y minima de cada linea a escribir, esto mas que nada sirve a la hora de lectura, para diferenciar por ejemplo entre lineas de encabezado, pie de pagina, etc...

*Definimos nuestro bean, dandole nombre y la ruta dentro de nuestro proyecto

*Dentro del bloque linea, definimos nuestros elementos (variables del bean), dandole una longitud y un tipo de dato

*Entre el bloque record-element definimos las caracteristicas que tendra el campo como, el alineado, por ejemplo tenemos alineaciones a la derecha y a la izquierda, tambien podemos definir caracteres de relleno, es decir si el valor de un campo es menor a la longitud establecida, el resto se rellenara con los caracteres, tenemos 3 casos para el ejemplo, un espacion, un guion medio y un @

*Podemos definir valores por default formatear fechas entre otras opciones por medio de la etiqueta conversion-option



*Esto nos ayudara a no recompilar nuestro codigo, si las longitudes cambian, u otra cosa que no afecte al tipo de variable que se esta utilizando


*Al definir una longitud para cada campo, en caso de que sea rebasado por alguna variable, el valor de la variable sera cortado para adecuarse a la longitud


9.- Al final la salida de nuestro archivo queda:


10   ------------aspirina@aaxd09/05/2011    5
20   ---------------melox@zzsd05/05/2011    1
50   ---------desodorantexxxxx09/04/2011   10


si observas bien, el codigo del tercer producto fue cortado, la variable enExistencia se alineo a la izquierda y la variable vendidas se alineo a la derecha, la variable nombres se relleno con guines medios y la variable codigo con @

Perdon si describi poco, solo q estoy en el trabajo, pero cualquier cosa dejen sus comentarios y con gusto haremos algo al respecto

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