Lectura de Archivos Mediante FlatWorm

Vamos a Reutilizar el Framework FlatWorm para poder ahora leer datos de un archivo, siempre y cuando sabemos la longitud de cada campo

Para tal motivo realizaremos lo siguiente:


1.- creamos un proyecto y le agregamos las siguientes librerias:
            commons-beanutils.jar
            commons-collections-3.0.jar
            commons-logging.jar
            flatworm-2.0.1.jar
****Recuerda, no es obligatorio utilizar estas versiones de librerias, pero las pongo para que te sea mas facil seguir el ejemplo

2.- Creamos 4 paquetes
            com.archivos.bean
            com.archivos.configurador
            com.archivos.lectura
            com.archivos.main

3.- En el paquete bean, agregamos el bean que Productos que utilizamos en la entrada Creacion De Archivos III

4.- En el paquete Configurador, del mismo modo copiamos la clase DatosIniciales que tenemos en Creacion De Archivos III

5.- En el paquete lectura creamos una clase llamada LecturaArchivo agregando el siguiente codigo

            private DatosIniciales datos;
            private FileParser parser;
            private BufferedReader br;
            private FileFormat ff;
            //agregar sus metodos set y get


public void cerrar(){
try {
             if(br!=null){            
                          br.close();            
             }        
} catch (IOException e) {
             System.out.println("C 1");
}
} 

/*
Creamos un parceador para poder pasar de un xml a un formato de archivo
en un stream obtenemos el archivo a leer
el stream lo guardamos en un buffer para poder ser leido
*/
public void configurar(){
try {
             ConfigurationReader parserC = new ConfigurationReader();       
             ff = parserC.loadConfigurationFile(getDatos().getArchivoWarm());
             InputStream in;       
             in = new FileInputStream(
                          getDatos().getRutaSubidaArchivo()+getDatos().getNombreArchivo());
             br = new BufferedReader(new InputStreamReader(in));        
} catch (FileNotFoundException e) {
             System.out.println("Archivo no encontrado");
} catch (FlatwormUnsetFieldValueException e) {
             System.out.println("Error de Archivo Warm");
} catch (FlatwormConfigurationValueException e) {
             System.out.println("Error en la Configuracion del Archivo Warm");
}         
}


/*
Guardamos en un campoMach un record obtenido del buffer
preguntamos si el nombre del record obtenido es igual a nuestro beanWarm q tenemos mapeado en nuestro xml
si es asi obtenemos el bean Productos, obteniendolo del record . get bean (de un mismo record se pueden obtener multiples beans)
solo nos resta imprimir la informacion
*/
public void leer(){
 try {
             MatchedRecord results;       
             while ((results = ff.getNextRecord(br)) != null){
                          if (results.getRecordName().equals(getDatos().getRecordWarm())){
                          Productos prod = (Productos) results.getBean(getDatos().getBeanWarm());
                          System.out.println("******************");
                          System.out.println("Codigo: "+prod.getCodigo());
                          System.out.println("En Existencia: "+prod.getEnExistencia());

                          System.out.println("Fecha Inventario: "+prod.getFechaInventario());
                          System.out.println("Nombre: "+prod.getNombre());
                          System.out.println("Vendidas: "+prod.getVendidas());
                          }
             }
} catch (FlatwormInvalidRecordException e) {
              System.out.println("Record Invalido");
} catch (FlatwormInputLineLengthException e) {
              System.out.println("Longitud de la Linea invalida");
} catch (FlatwormConversionException e) {
              System.out.println("No se pudo realizar una conversion de datos");
} catch (FlatwormUnsetFieldValueException e) {
              System.out.println("Error de Campo Vacio");
} catch (FlatwormCreatorException e) {
              System.out.println("Error de Creacion del Bean");
} 
}

Como se puede observar, el leer puede ser un poco engorroso en comparacion con otras tecnicas como la tradicional de lectura de archivos, pero de este modo podemos modificar la longitud de los campos a leer sin recompilar codigo y es mas facil guardarlo en una bd, por ejemplo :)

En otra entrada veremos como realizar esto a traves de Oracle, sin pasar por java :)

 

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

Creacion De Archivos I (Archivos para Batch)

Algunas veces nos hemos visto obligados a crear archivos con informacion provenientemente de nuestra bd, para enviarlo a otro sistema el cual procesara esa informacion normalmente cargando la informacion en otra bd, esto es muy comun entre los bancos

los bancos o para los bancos se crean archivos con los clientes y sus pagos o sus cargos, estos se envian y procesan para realizar los cargos sobre nuestras tdc o tdd (Domiciliacion)

estos archivos tienen ciertas caracteristicas como: alinear los nombres a la derecha, rellenar de espacios un texto, longitudes fijas, rellenar con caracteres un texto, colocar encabesados etc...


A continuacion veremos algunas formas de realizar estos benditos archivos

1.- supongamos una clase que se dedicara a crear un archivo y escribir sobre el.

public class Escritura {
    String ruta;
    String archivo;
    private FileWriter fichero;
    private PrintWriter pw;

    public void abrirArchivo() {
        try {
            fichero = new FileWriter(ruta + File.separator + archivo);
            pw = new PrintWriter(fichero);
        } catch (IOException e) {
            System.out.println("Error al abrir archivo");
        }
    }

    public void cerrarArchivo() {
        try {
            if (fichero != null) {
                fichero.close();
            }
        } catch (IOException e) {
            System.out.println("error al cerrar archivo");
        }
    }

    public void escribir(String texto) {
        if (fichero != null) {
            pw.println(texto);
        }else{
            System.out.println("El archivo no esta abierto");
        }
    }
}

2.- supongamos ahora una clase en la cual tendremos los datos que contendra el archivo a crear

class Bean{
   
    private String nombre;
    private String apellido;
    private String edad;
    private String telefono;

 // con sus metodos get y set

} 

3.-  nos encontramos ahora un detalle, ese bean se tendra que escribir sobre un archivo, pero nuestra clase de escritura escribe String, por tanto tenemos que agrupar nuestros 4 datos en una sola variable que sera la que se escriba

public String toString(){
        return nombre + apellido + edad + telefono;
    }

4.- ahora tenemos algunas restricciones para crear nuestro archivo

- El nombre tiene que ser maximo de 10 caracteres, si es menor a 10, se llenaran las posiciones restantes con espacios
- El apellido tiene que ser maximo 20 caracteres, si es menor a 20, se llenaran las posiciones restantes con espacions
- La edad es maximo 2 caracteres, si la edad es menor a 10, se pondra un 0 a la izquierda: 8 años > 08
- El telefono es maximo 8 caracteres, rellenado con espacios

5.- para cumplir nuestras condiciones, modifiquemos nuestros metodos set 

public void setNombre(String nombre) {
        if(nombre==null){
            nombre = "          ";
        }
        else if(nombre.length()<10){
            do{
                nombre = nombre.concat(" ");
            }while(nombre.length()<=10);
        }else if(nombre.length()>10){
            nombre = nombre.substring(0,10);
        }
        this.nombre = nombre;
    }
    public void setApellido(String apellido) {
        if(apellido==null){
            apellido = "                    ";
        }
        else if(apellido.length()<20){
            do{
                apellido = apellido.concat(" ");
            }while(apellido.length()<=20);
        }else if(apellido.length()>20){
            apellido = apellido.substring(0,20);
        }       
        this.apellido = apellido;
    }
    public void setEdad(String edad) {
        if(edad==null){
            edad = "  ";
        }else if(edad.length()<2){
            edad = "0"+edad;
        }else if(edad.length()>2){
            edad = edad.substring(0,2);
        }           
        this.edad = edad;
    }
    public void setTelefono(String telefono) {
        if(telefono==null){
            telefono = "        ";
        }
        else if(telefono.length()<8){
            do{
                telefono = telefono.concat(" ");
            }while(telefono.length()<=8);
        }else if(telefono.length()>8){
            telefono = telefono.substring(0,8);
        }       
        this.telefono = telefono;
    }

NOTA: QUE TREMENDO CHOROTE NO ???? ( YA VEREMOS FORMAS SUPER SENSILLAS DE REALIZAR ESTO) 

6.- hay que crear una clase con su main, hacer instancia de las 2 clases anteriores, darles valores a sus variables 

public static void main(String args[]){
        Bean miBean = new Bean();
        Escritura miEscritura = new Escritura();
      
        miBean.setNombre("Ing. Fher");
        miBean.setApellido("Java - Limos . Blogspot");
        miBean.setEdad("23");
        miBean.setTelefono("12345678");
      
        miEscritura.archivo="JavaLimos.txt";
        miEscritura.ruta="D:";
      
        miEscritura.abrirArchivo();
        miEscritura.escribir(miBean.toString());
        miEscritura.cerrarArchivo();
    }

7.- al mandar escribir, llamamos al metodo toString que sobreescribimos


al final nuestro archivo quedaria algo como


Ing. Fher  Java - Limos . Blogs2312345678

8.- si se dan cuenta,  Java - Limos . Blogspot rebaso los 20 caracteres y fue cortado a Java - Limos . Blogs

ESTO ES MUY UTIL, PERO SI LAS LONGITUDES CAMBIAN, OBIAMENTE TENEMOS QUE RECOMPILAR NUESTRO PROGRAMA :(