Crear un SequenceFile
Crearemos un SequenceFile de un texto, que es un poema, y le pondremos como key el número correspondiente a cada línea.
public class CreateSequenceFile {
private static final String[] POEMA = {
"El ciego sol se estrella",
"en las duras aristas de las armas,",
"llaga de luz los petos y espaldares",
"y flamea en las puntas de las lanzas.",
"El ciego sol, la sed y la fatiga",
"Por la terrible estepa castellana,",
"al destierro, con doce de los suyos",
"-polvo, sudor y hierro- el Cid cabalga.",
"Cerrado está el mesón a piedra y lodo.",
"Nadie responde... Al pomo de la espada",
"y al cuento de las picas el postigo",
"va a ceder ¡Quema el sol, el aire abrasa!"};
private static final String rutaDestino
= new String ("pruebas/poemasequencefile");
public static void main(String[] args) throws IOException {
Configuration conf = new Configuration();
FileSystem fs = FileSystem.get( conf);
Path path = new Path(rutaDestino);
IntWritable key = new IntWritable();
Text value = new Text();
//Creamos el writer del SequenceFile para poder ir añadiendo
// los pares key/value al fichero.
SequenceFile.Writer writer = new SequenceFile.Writer(fs,
conf, path, key.getClass(), value.getClass());
for (int i = 0; i < POEMA.length; i++) {
// La key es el número de línea
key.set(i+1);
// El value es la línea del poema correspondiente
value.set(POEMA[i]);
// Escribimos el par en el sequenceFile
writer.append(key, value);
}
writer.close();
}
}
Leer un SequenceFile
En este ejemplo no sólo vamos a leer el fichero creado anteriormente, sino que también vamos a buscar y a usar los puntos de sincronización, vamos a ver las posiciones del fichero y vamos a desplazarnos a alguna.
public class ReadSequenceFile {
private static final String rutaOrigen
= new String ("pruebas/poemasequencefile");
public static void main(String[] args)
throws Exception {
Configuration conf = new Configuration();
FileSystem fs = FileSystem.get( conf);
Path path = new Path(rutaOrigen);
//Creamos el Reader del SequenceFile
SequenceFile.Reader reader =
new SequenceFile.Reader(fs, path, conf);
// Leemos la key y value del SequenceFile, los tipos son conocidos,
// por lo que se declaran variables de esos tipos.
IntWritable key =
(IntWritable) reader.getKeyClass().newInstance();
Text value =
(Text) reader.getValueClass().newInstance();
StringBuilder strBuilder;
boolean haySync = false;
long posSync = 0;
//Recorremos el reader recuperando los pares key/value
while(reader.next(key,value)){
// Comprobamos si la posición es un punto de sync
// En principio en este fichero no encontrará ninguno ya que es muy
// pequeño, si fuera uno más grande y tuviera varios puntos de sync
// se guardará el último punto encontrado.
if(reader.syncSeen()){
haySync = true;
posSync = reader.getPosition();
}
strBuilder = new StringBuilder("Posición: ").
append(reader.getPosition()).append(" - Key: ").
append(key.toString()).append(" Value: " ).
append(value.toString());
System.out.println(strBuilder);
}
if(haySync){
// reader.sync posicionará el reader en el sync siguiente más próximo,
// si no hay ninguno se posicionará al final del fichero.
// En este caso se posicionará en el punto dado, ya que es de sync.
strBuilder = new StringBuilder("Sync en el punto: ").
append(posSync);
System.out.println(strBuilder);
reader.sync(posSync);
}else{
// Es un valor conocido, si no existiera, habría un error
// al realizar el reader.next.
posSync = 459;
reader.seek(posSync);
}
// En un caso o en otro a pesar de haber finalizado la iteración
// hemos posicionado el reader en un punto intermedio, así que
// seguimos recorriéndolo (repetimos las líneas)
// hasta finalizar de nuevo.
strBuilder = new StringBuilder("Volvemos a la posición: ")
.append(posSync);
System.out.println(strBuilder);
System.out.println("Seguimos recorriendo el reader: ");
while(reader.next(key,value)){
strBuilder = new StringBuilder("Posición: ").
append(reader.getPosition()).append(" - Key: ").
append(key.toString()).append(" Value: " ).
append(value.toString());
System.out.println(strBuilder);
}
reader.close();
}
}
