09 septiembre, 2007

JAFramework

.
Escribir Registros en un Archivo

El siguiente programa graba un nuevo registro al final del archivo EMPLEADOS.txt.

GrabaAlFinal.java
   1:
2:package demo;
3:
4:import framework.JAFactory;
5:import framework.JAFile;
6:import framework.JAFileFactory;
7:import framework.util.JAConsole;
8:
9:public class GrabaAlFinal
10:{
11: public static void main(String[] args)
12: {
13: JAFileFactory factory=JAFactory.getFileFactory();
14:
15: // levanto el descriptor a memoria
16: factory.load("descriptor.xml");
17:
18: // obtengo un puntero al archivo EMPLEADOS.txt
19: JAFile a = factory.getFile("EMPLEADOS.txt");
20:
21: // ingreso x consola los datos del empleado
22: // para grabarlos al final del archivo
23:
24: // nombre
25: System.out.print("Nombre: ");
26: String nom = JAConsole.readString(10);
27:
28: // legajo
29: System.out.print("Legajo: ");
30: int leg = JAConsole.readInt();
31:
32: // sueldo
33: System.out.print("Sueldo: ");
34: float sueldo = JAConsole.readFloat();
35:
36: // direccion
37: System.out.print("Direccion: ");
38: String dir = JAConsole.readString(15);
39:
40: // sector
41: System.out.print("Sector: ");
42: int sec = JAConsole.readInt();
43:
44: // creo un registro y le seteo los datos
45: REmpleado reg = new REmpleado();
46: reg.setNombre(nom);
47: reg.setLegajo(leg);
48: reg.setSueldo(sueldo);
49: reg.setDireccion(dir);
50: reg.setSector(sec);
51:
52: // agrego el registro al final del archivo
53: a.writeAtEnd(reg);
54:
55: // cierro el archivo
56: a.close();
57: }
58:}
59:

El método writeAtEnd graba el registro reg al final del archivo a. El uso de este método es equivalente al código que vemos a continuación.
   1:
2: // muevo el puntero al final del archivo
3: // (recordemos que se numeran desde cero)
4: a.seek(a.filesize())
5:
6: // grabo el registro
7: a.write(reg);
8:


Modificar los datos de Registros Existentes

El siguiente programa incrementa un 20% el sueldo de cada uno de los empleados del archivo EMPLEADOS.txt.

ModificaRegistros.java
   1:
2:package demo;
3:
4:import framework.JAFactory;
5:import framework.JAFile;
6:import framework.JAFileFactory;
7:
8:public class ModificaRegistros
9:{
10: public static void main(String[] args)
11: {
12: JAFileFactory factory=JAFactory.getFileFactory();
13:
14: // levanto el descriptor a memoria
15: factory.load("descriptor.xml");
16:
17: // obtengo un puntero al archivo EMPLEADOS.txt
18: JAFile a = factory.getFile("EMPLEADOS.txt");
19:
20: double nuevoSueldo;
21: REmpleado reg = new REmpleado();
22:
23: boolean eof = a.read(reg);
24:
25: while( !eof )
26: {
27: // el nuevo sueldo sera un 20% mas
28: nuevoSueldo = reg.getSueldo() * 1.20;
29: reg.setSueldo(nuevoSueldo);
30:
31: // retrocedo el puntero
32: a.seek(a.recno() - 1);
33:
34: // grabo el registro con el valor
35: // del sueldo incrementado
36: a.write(reg);
37:
38: eof = a.read(reg);
39: }
40:
41: // cierro el archivo
42: a.close();
43: }
44:}
45:

En la línea 23 (y luego en la 38 leemos el registro y en la línea 28 incrementamos el valor del atributo sueldo.

Cuando leemos un registro el putero del archivo avanza al registro siguiente por lo tanto, para grabar las modificaciones tenemos que hacer que el puntero vuelva a apuntar al mismo registro. Esto lo hacemos con el método seek pasándole el valor del método recno-1 como vemos en la línea 32 (es decir, el número de registro actual menos 1).


Grabar Nuevos Archivos

El programa que veremos a continuación recorre el archivo EMPLEADOS.txt y genera dos archivos llamados SALIDA1.txt y SALIDA2.txt, ambos con el formato de registro que se detalla en el descriptor (modificado).

descriptor.xml
   1:
2:<jaframework xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="jaframework.xsd">
3:
4: <driver class="driver.textfile.DOSTextFileDriver">
5:
6: <record name="REmpleado" class="demo.REmpleado">
7: <field name="nombre" att="nombre" class="STRING" size="10" type="String" />
8: <field name="legajo" att="legajo" class="INTEGER" type="int" />
9: <field name="sueldo" att="sueldo" class="REAL" type="double" />
10: <field name="direccion" att="direccion" class="STRING" size="15" type="String" />
11: <field name="sector" att="sector" class="INTEGER" type="int" />
12: </record>
13:
14: <record name="RSalida" class="demo.RSalida">
15: <field name="nombre" att="nombre" class="STRING" size="10" type="String" />
16: <field name="sueldo" att="sueldo" class="REAL" type="double" />
17: </record>
18:
19: <file name="EMPLEADOS.txt" record="REmpleado" />
20: <file name="SALIDA1.txt" record="RSalida" />
21: <file name="SALIDA2.txt" record="RSalida" />
22:
23: </driver>
24:</jaframework>
25:

En la línea 14 definimos el registro RSalida para los archivos de salida. Ambos archivos tendrán el mismo formato de registro. En las líneas 20 y 21 definimos los archivos SALIDA1.txt y SALIDA2.txt como archivos de registros RSalida.

Ahora tenemos que crear el bean (clase, POJO o registro) para mapear los registros de los archivos de salida. Debe tener un atributo por cada campo del registro del archivo.

RSalida.java
   1:
2:package demo;
3:
4:import framework.JARecord;
5:
6:public class RSalida extends JARecord
7:{
8: private String nombre;
9: private double sueldo;
10:
11: public double getSueldo()
12: {
13: return sueldo;
14: }
15:
16: public void setSueldo(double sueldo)
17: {
18: this.sueldo = sueldo;
19: }
20:
21: public String getNombre()
22: {
23: return nombre;
24: }
25:
26: public void setNombre(String nombre)
27: {
28: this.nombre = nombre;
29: }
30:}
31:

Ahora si, veamos el programa que genera los archivos SALIDA1.txt y SALIDA2.txt con los valores de los campos nombre y sueldo de los empleados de EMPLEADOS.txt, con el siguiente criterio:
  1. Si sueldo > $2500 => grabo en SALIDA1.txt
  2. Si sueldo <= $2500 => grabo en SALIDA2.txt

GeneraSalida.java
   1:
2:package demo;
3:
4:import framework.JAFactory;
5:import framework.JAFile;
6:import framework.JAFileFactory;
7:
8:public class GeneraSalida
9:{
10: public static void main(String[] args)
11: {
12: JAFileFactory factory = JAFactory.getFileFactory();
13:
14: // levanto el descriptor a memoria
15: factory.load("descriptor.xml");
16:
17: // obtengo un puntero al archivo EMPLEADOS.txt
18: JAFile aEmp = factory.getFile("EMPLEADOS.txt");
19:
20: // obtengo punteros a los archivos de salida
21: // que vamos a crear
22: JAFile aSal1 = factory.getFile("SALIDA1.txt");
23: JAFile aSal2 = factory.getFile("SALIDA2.txt");
24:
25: // un registro para leer empleados
26: REmpleado rEmp = new REmpleado();
27:
28: // un registro para escribir en los archivos
29: // de salida (recordemos que son del mismo
30: // tipo de registro)
31: RSalida rSal = new RSalida();
32:
33: // mientras no sea eof de aEmp
34: while( !aEmp.read(rEmp) )
35: {
36: // seteo los datos que me interesan en el
37: // registro rSal
38: rSal.setNombre(rEmp.getNombre());
39: rSal.setSueldo(rEmp.getSueldo());
40:
41: // si el sueldo >2500 lo grabo en aSal1
42: if( rEmp.getSueldo() > 2500 )
43: {
44: aSal1.write(rSal);
45: }
46: else
47: // si no, lo grabo en aSal2
48: {
49: aSal2.write(rSal);
50: }
51: }
52:
53: // cierro todos los archivos
54: aEmp.close();
55: aSal1.close();
56: aSal2.close();
57: }
58:}
59:

El programa recorre todo el archivo EMPLEADOS.txt. Si sueldo del empleado supera los $2500 lo graba en el archivo SALIDA1.txt. Si no, lo graba en SALIDA2.txt (líneas 44 y 49).



.........................,...................




.

No hay comentarios.: