https://drwn.wordpress.

com/2008/01/14/co
mo-leer-y-escribir-dbf-en-java/
Como leer y escribir dbf en java ?

Antes de empezar a documentar este post recuerdo la vez que quería

escribir y leer dbf desde java, empece buscando por Internet pero no
había mucha documentación disponible hasta que encontré algo y lo voy
a replicar por si a alguien mas le sirve ya sea para migrar sus bases de
datos.

Aquí les va la url:

http://sarovar.org/docman/view.php/32/23/javadbf-tutorial.html

Aunque esta en ingles me he tomado la molestia de traducirlo en este

post para aquellos que no son muy bilingues

tutorial de la libreria javadbf

(for JavaDBF ver. 0.4.0 and above)
Anil Kumar K.
anil at linuxense dot com
Linuxense Information Systems Pvt. Ltd., Trivandrum, India

1. Introducción

JavaDBF es una librería para leer y escribir archivos XBase. Estos son
bastantes en aplicaciones legales alrededor de los dbf como su primer
formato de almacenamiento. JavaDBF fue inicialmente escrito para
transferir datos con aplicaciones. Algo más que, hay requerimientos
para exportar datos desde una aplicación java a hojas de calculo como
Excel o Lotus 123. Un archivo DBF debe ser mas apropiado en otras
situaciones como son el CSV o un archivo HTML porque un archivo DBF
puede llevar campos de tipo de información. Mas sobre, formato XBase
es como un Open-standard; esto es entendible por casi todos los
programas de hojas de calculo.
2. Obteniendo e Instalando

Obtener la ultima versión de JavaDBF

desde http://sarovar.org/projects/javadbf/. Crear una carpeta en una
ubicación conveniente y hacerlo correr:

tar xvfz javadbf-x.x.x-tar.gz cd javadbf-x.x.x

En esta carpeta encontraras javadbf.jar que contiene la librería. Incluye

este archivo jar en su variable $CLASSPATH variable. Entonces estas listo
para avanzar.

3. Resumén de la librería

JavaDBF tiene un simple API propio y no implementa el API JDBC. Es

diseñado así porque JavaDBF no esta incluido en el soporte del estilo de
interacción con RDBMS. Si estas presumiendo usarlo como un back-end;
Simplemente no trabaja de esa forma . Entonces, JavaDBF no es
diseñado para hilos seguros; tenlo en mente cuando diseñes aplicaciones
de hilos . JavaDBF viene en el paquete com.linuxense.javadbf. Importa
ese paquete en tu código java. Los siguientes ejemplos te familiarizaran
con este API.

3.1. Tipo de Datos

En la versión 0.3.2, JavaDBF suporta casi todos los tipos de datos XBase
excepto el campo Memo. Mientras lee, esos tipos de datos son
interpretados como tipo de datos de java apropiados. La siguiente tabla
muestra el esquema de datos.

XBase Type XBase Symbol Java Type used in JavaDBF

Character C java.lang.String
Numeric N java.lang.Double
Double F lava.lang.Double
Logical L java.lang.Boolean
Date D java.util.Date
4. Leer un archivo DBF
Al leer un archivo DBF, JavaDBF provee una clase DBFReader. Lo
siguiente esta listo para compilar, el programa se explica describiendo
casi todas las características de la claseDBFReader. Copiar/Pegar el
listado y compilarlo. Manten un archivo .dbf manejable al pasarlo a este
programa como un argumento. (Es decir algo que puedas leer, que este
a tu alcance).
import java.io.*;
import com.linuxense.javadbf.*;
public class JavaDBFReaderTest {
public static void main( String args[]) {
try {
// create a DBFReader object
//
InputStream inputStream = new FileInputStream( args[ 0]); // take dbf
file as program argument
DBFReader reader = new DBFReader( inputStream);
// get the field count if you want for some reasons like the following
//
int numberOfFields = reader.getFieldCount();
// use this count to fetch all field information
// if required
//
for( int i=0; i<numberOfFields; i++) {
DBFField field = reader.getField( i);
// do something with it if you want
// refer the JavaDoc API reference for more details
//
System.out.println( field.getName());
}
// Now, lets us start reading the rows
//
Object []rowObjects;
while( (rowObjects = reader.nextRecord()) != null) {
for( int i=0; i<rowObjects.length; i++) {
System.out.println( rowObjects[i]);
}
}
// By now, we have itereated through all of the rows
inputStream.close();
}
catch( DBFException e) {
System.out.println( e.getMessage());
}
catch( IOException e) {
System.out.println( e.getMessage());
}
}
}

5. Escribiendo un archivo DBF

La clase complementaria a DBFReader es el DBFWriter. Mientras creas un

archivo de datos.dbf tendras que tratar con dos aspectos: 1. definir los
campos y 2. poblar o abastecer datos. Como mencione antes un campo
dbf es representado por la clase DBFField. Primero dejame
familiarizarte con esta clase.

5.1. Definiendo Campos

Crear un objeto de la clase DBFField:

DBFField field = new DBFField(); field.setField( "emp_name"); //

give a name to the field

field.setDataType( DBFField.FIELD_TYPE_C); // and set its type

field.setFieldLength( 25); // and length of the field

Bien, ahora un completo objeto DBFField listo para usar. Tenemos

creados muchos objetosDBFField como nosotros deseemos en el archivo
de datos .dbf. La clase DBFWriter aceptaDBFField en un arreglo. Ahora,
nos moveremos al próximo paso que sera abastecer de datos o llenarlo
con datos.

5.2. Preparando el Objeto DBFWriter

Un DBFWriter es usado para crear un archivo .dbf. Primero crearemos un
objetos DBFWriterllamándolo desde su constructor y entonces seteamos
sus campos a crear (como esta explicado arriba) llamando con el
método setFields.

DBFWriter writer = new DBFWriter();writer.setFields( fields); //

fields is a non-empty array of DBFField objects

Ahora, el objeto DBFWriter esta listo para ser llenado. El método para
agregar datos alDBFWriter es addRecord y toma un objeto array como
argumento. Este objeto array es el que supuestamente contiene los
valores para los campos agregados uno a uno correspondiente al campo
seteado o declarado anteriormente.

Lo siguiente es un programa completo explicando los pasos descritos en

la parte anterior:

import com.linuxense.javadbf.*;
import java.io.*;
public class DBFWriterTest {
public static void main( String args[])
throws DBFException, IOException {
// let us create field definitions first
// we will go for 3 fields
//
DBFField fields[] = new DBFField[ 3];
fields[0] = new DBFField();
fields[0].setName( “emp_code”);
fields[0].setDataType( DBFField.FIELD_TYPE_C);
fields[0].setFieldLength( 10);
fields[1] = new DBFField();
fields[1].setField( “emp_name”);
fields[1].setDataType( DBFField.FIELD_TYPE_C);
fields[1].setFieldLength( 20);
fields[2] = new DBFField();
fields[2].setField( “salary”);
fields[2].setDataType( DBFField.FIELD_TYPE_N);
fields[2].setFieldLength( 12);
fields[2].setDecimalCount( 2);
DBFWriter writer = new DBFWriter();
writer.setFields( fields);
// now populate DBFWriter
//
Object rowData[] = new Object[3];
rowData[0] = “1000”;
rowData[1] = “John”;
rowData[2] = new Double( 5000.00);
writer.addRecord( rowData);
rowData = new Object[3];
rowData[0] = “1001”;
rowData[1] = “Lalit”;
rowData[2] = new Double( 3400.00);
writer.addRecord( rowData);
rowData = new Object[3];
rowData[0] = “1002”;
rowData[1] = “Rohit”;
rowData[2] = new Double( 7350.00);
writer.addRecord( rowData);
FileOutputStream fos = new FileOutputStream( args[0]);
writer.write( fos);
fos.close();
}
}

Ten en mente que todavia el metodo write es llamado, y todos los datos
agregados seran mantenidos en memoria. Entonces, si tu estas
planeando escribir un gran monto de datos asegurate que sea seguro
ponerlos en memoria hasta que sean escritos a disco y el
objetoDBFWriter es garbage-collected. Leer la sección “Sync Mode” para
saber como JavaDBF usa una especial caracteristica sobre esto.

5.3. “Sync Mode” –Escribiendo registros a archivos como son

agregados

Este es muy usado cuando JavaDBF es usado para crear un DBF con un
gran número de registros. En este modo, el mantener registros en
memoria para escribir todos en una sola, registros son escritos al
archivo como addRecord() es llamado. Aqui esta como escribir en
modo Sync Mode:

Crear una instancia DBFWriter pasándole un objeto File que representa

uno nuevo/ no existente o archivo vacio. Y lo has hecho! Pero, como en
el modo normal, recuerda llamar a write() cuando tengas agregados
todos los registros. Esto ayuda a JavaDBF a escribir los meta datos con
los valores correctos. Aquí un código de ejemplo:

import com.linuxense.javadbf.*;import java.io.*;public class

DBFWriterTest {

public static void main( String args[])

throws DBFException, IOException {

// ...

DBFWriter writer = new DBFWriter( new File( "/path/to/a/new/file"));

/* this DBFWriter object is now in Syc Mode */

// ...

7. Agregando Registros

Desde la version 0.4.0 JavaDBF suporta agregar registros a un archivo

DBF existente. Usa el mismo constructor usado en Sync Mode para
alcanzar esto. Pero el objeto file pasado al constructor debe
representarse por el archivo dbf que los registros seran agregados.

Es ilegal llamar setFields en un objeto DBFWriter creado para agregar

datos. Aquí también se requiere llamar el método write después de
agregar todos los registros.

http://javaintercambios.blogspot.com/2014/02/leer-una-tabla-dbf-utilizando-la.html