JAFramework

.
Java Algorithm Framework (JAF)

JAF es un framework que posibilita a los programas Java el acceso a archivos de registros de longitud fija. Está pensado como un framework de uso didáctico para facilitar la enseñanza del lenguaje de programación Java en materias de Algoritmos y Programación.

La arquitectura de JAF es extensible por lo que (implementando adecuadamente un driver) permite el acceso a archivos de registros generados con Turbo Pascal, Free Pascal, C, Archivos de Texto o archivos con cualquier formato de registro. Junto con el framework se proveen los drivers para acceso a archivos de texto (tanto DOS como UNIX) y acceso a archivos de Free Pascal, dejando para los alumnos el desarrollo de drivers que posibiliten el acceso a otros tipos de archivo.

El framework también incluye una factory de DataSources JDBC (JAConnectionFactory), un administrador de transacciones y una factory de instancias (JABeanFactory).



Los temas cubiertos en este tutorial son los siguientes:

1 - Archivos de Registros

• Introducción a Java Algorithm Framework (JAF)
• Recorrer Archivos
• Recorrer Archivos Indexados
• Acceso Directo a Registros
• Búsqueda Binaria
• Grabar y Modificar Registros
• Entrada de Datos por Consola (JAConsole)

2 - Acceso a Bases de Datos

• Configurar y Utilizar un DataSource JDBC
• Manejo de Transacciones

3 - Factory de Instancias

• Configurar y utilizar el BeanFactory

4 - Nuevas Funcionalidades (agregado 12/junio/2009)

• Alias para identificar archivos e índices
• Creación de índices a través del descriptor
• Indexación en varios niveles
• IndexListener
• Ordenamiento de archivos

Comenzando con JAF

A continuación veremos con crear y configurar un proyecto en Eclipse para trabajar con JAF y luego analizaremos algunos ejemplos sobre su funcionalidad.


Configuración del Framework

Para utilizar JAF necesitamos disponer del framework y del driver específico según el archivo al que querramos acceder desde nuestro programa Java. En este tutorial utilizaremos archivos de texto.

Los siguientes pasos nos permitirán crear un proyecto en Eclipse y habilitarlo para trabajar con JAF.

1 - Descargar (desde aquí) los siguientes archivos:

• framework.jar (clases de framework)
• drivertxtfile.jar (driver para archivos de texto)
• driver_readme.txt (documentación del driver)
• jaframework.xsd

2 - Crear un proyecto Java en Eclipse.
3 - En las propiedades del proyecto seleccionar "Java Build Path", luego "Libraries" y luego el botón "Add External JARs".
4 - Seleccionar los archivos framework.jar y drivertxtfile.jar (que descargamos en el punto 1).

Luego de realizar estos pasos el proyecto estará habilitado para trabajar con JAF.


Acceder a un Archivo

En este tutorial utilizaremos el archivo EMPLEADOS.txt cuyo contenido vemos a continuación.

EMPLEADOS.txt

Alberto   ,00001,001500.50,San Martin 23  ,00002
Pedro     ,00002,001800.00,Los Patos 2623 ,00002
Jorge     ,00003,001000.00,Tandil 345     ,00002
Pablo     ,00004,000800.00,J. B. Justo 652,00007
Luisa     ,00005,002500.00,Alvear 43      ,00007
Martin    ,00006,003500.00,Remedios 776   ,00012
Maria     ,00007,003800.00,Zelarrayan 3   ,00012
Federico  ,00008,003200.50,Pje. El Tala 21,00012
Mercedes  ,00009,003200.50,Tucuman 443    ,00032
Norberto  ,00010,002300.50,Viamonte 54    ,00032
Fernando  ,00011,003000.00,Paraguay 5665  ,00001
Susana    ,00012,002600.00,Corrientes 221 ,00001
Analia    ,00013,003800.00,Medrano 981    ,00001
Carla     ,00014,001850.00,Mozart 2300    ,00001

Los campos se separan con "," (coma) y cada línea corresponde a un registro. Vemos que todos los registros tienen exactamente la misma longitud ya que tienen la misma cantidad de campos y la longitud de cada campo es la misma para todos los registro.

Los campos del registro de EMPLEADOS.txt son los siguientes:

• nombre - string[10]
• legajo - entero (5 dígitos)
• sueldo - real (6,2 entero/decimal dígitos)
• dirección - string[15]
• sector - entero (5 dígitos)

Para acceder a un archivo utilizando JAF necesitamos crear una clase Java con tantos atributos como campos tenga el registro del archivo y luego escribir un archivo XML al que llamaremos "descriptor" donde le indicaremos a JAF la ruta del archivo al que queremos acceder, con que clase vamos a "mapear" sus registros, la relación entre los campos del registro y los atributos de la clase que lo mapea, etc.

El primer paso entonces será crear una clase que extienda a JARecord y que tenga tantos atributos (con sus setters y getters) como campos tenga el registro del archivo al que queremos acceder.

REmpleado.java

   1:
   2:package demo;
   3:
   4:import framework.JARecord;
   5:
   6:public class REmpleado extends JARecord
   7:{
   8:   // atributos
   9:   private String nombre;
  10:   private int legajo;
  11:   private double sueldo;
  12:   private String direccion;
  13:   private int sector;
  14:
  15:   // setters y getters
  16:
  17:   public String getDireccion()
  18:   {
  19:      return direccion;
  20:   }
  21:
  22:   public void setDireccion(String direccion)
  23:   {
  24:      this.direccion = direccion;
  25:   }
  26:
  27:   public int getLegajo()
  28:   {
  29:      return legajo;
  30:   }
  31:
  32:   public void setLegajo(int legajo)
  33:   {
  34:      this.legajo = legajo;
  35:   }
  36:
  37:   public String getNombre()
  38:   {
  39:      return nombre;
  40:   }
  41:
  42:   public void setNombre(String nombre)
  43:   {
  44:      this.nombre = nombre;
  45:   }
  46:
  47:   public int getSector()
  48:   {
  49:      return sector;
  50:   }
  51:
  52:   public void setSector(int sector)
  53:   {
  54:      this.sector = sector;
  55:   }
  56:
  57:   public double getSueldo()
  58:   {
  59:      return sueldo;
  60:   }
  61:
  62:   public void setSueldo(double sueldo)
  63:   {
  64:      this.sueldo = sueldo;
  65:   }
  66:}
  67:

Entre las líneas 9 y 13 definimos los atributos de la clase. Los tipos de datos los elegimos en función de la documentación provista por el fabricante del driver (driver_readme.txt).

A esta clase la podemos llamar "bean" ya que solo tiene atributos, setters y getters. También podríamos llamarla "POJO" (Plain and Ordinary Java Object) o bien "la clase" o "el registro".


El siguiente paso será escribir el descriptor. Podemos crearlo, por ejemplo, en la carpeta del proyecto en el que estamos trabajando haciendo "botón derecho" sobre el proyecto, luego seleccionamos "New", luego "File" y escribirmos el nombre del archivo que vamos a crear: descriptor.xml.

descriptor.xml

   1:
   2:<jaframework xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="jaframework.xsd">
   3:
   4:   <!-- define que driver vamos a usar -->
   5:   <driver class="driver.textfile.DOSTextFileDriver">
   6:
   7:      <!-- define un tipo de registro -->
   8:      <record name="REmpleado" class="demo.REmpleado">
   9:         <field name="nombre" att="nombre" class="STRING" size="10" type="String" />
  10:         <field name="legajo" att="legajo" class="INTEGER" type="int" />
  11:         <field name="sueldo" att="sueldo" class="REAL" type="double" />
  12:         <field name="direccion" att="direccion" class="STRING" size="15" type="String" />
  13:         <field name="sector" att="sector" class="INTEGER" type="int" />
  14:      </record>
  15:
  16:      <!-- define un archivo con registros tipo REmpleado -->
  17:      <file name="EMPLEADOS.txt"  record="REmpleado"  />
  18:
  19:   </driver>
  20:</jaframework>
  21:

Antes de analizar este archivo debemos asegurarnos de copiar en el mismo directorio el archivo jaframework.xsd (que descargamos más arriba).

Ahora si, en la línea 5 indicamos cual es el driver que JAF debe utilizar para acceder al archivo. Esta información la debe brindar el proveedor del driver. Es decir: quien escriba un driver específico que permita a JAF acceder a un determinado tipo de archivo también tiene que proveer al usuario la información tal como "cual es la clase que implementa el driver" y "que tipos de datos se pueden utilizar para mapear los campos del archivo".

En el caso del driver de texto esta información está disponible en el siguiente archivo: driver_readme.txt.

Luego describimos el registro que utilizaremos para leer el archivo de empleados. En la línea 8 definimos un nombre para el registro e indicamos con que clase lo vamos a "mapear".

Dentro de <record> tenemos varias entradas <field>, una por cada campo del registro en las que indicamos:

• name - nombre del campo
• att - nombre del atributo (en la clase)
• class - tipo de dato del campo (según documentación del driver)
• type - tipo de dato del atributo (según documentación del driver)
• size - si corresponde se puede indicar la longitud del campo

Con el registro definido podemos ahora definir el archivo como vemos en la línea 17 donde indicamos el nombre del archivo, el tipo de registro (que coincide con el nombre del registro que especificamos en la línea 8) y el path donde el archivo está ubicado. Si no especificamos el path entonces, por default, se considerará que el archivo se encuentra en el mismo directorio en donde está el descriptor.

Ahora si, con el archivo y el registro correctamente mapeados podemos pasar a ver diferentes ejemplos simples con los que vamos a ilustrar la funcionalidad de JAF.

.