Dominio de la Serialización Mágica

Introducción

En este laboratorio, aprenderá a racionalizar el proceso de catalogación de la vasta colección de libros mágicos de la ilustre Academia Mágica. A través del poder de Hadoop MapReduce, manejará la serialización de los datos de los libros, lo que garantizará un procesamiento y análisis sin problemas. Esto le permitirá almacenar y procesar eficientemente la información de los libros, lo que finalmente mejorará el servicio a la facultad y los estudiantes de la academia.

Skills Graph

Implementando la interfaz Writable

En este paso, crearemos una clase Writable personalizada para representar los datos de los libros. Esta clase implementará la interfaz Writable proporcionada por Apache Hadoop, lo que permitirá una serialización y deserialización eficiente de datos durante el proceso MapReduce.

Primero, debe usar el comando su - hadoop para convertirse en un usuario hadoop y crear un nuevo archivo Java llamado Book.java en el directorio /home/hadoop con el siguiente contenido:

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
import org.apache.hadoop.io.Writable;

// La clase Book representa un libro con un título, un autor y un año de publicación.
// Implementa la interfaz Writable para la serialización de Hadoop.
public class Book implements Writable {
    // Campos privados para el título del libro, el autor y el año de publicación.
    private String title;
    private String author;
    private int year;

    // Constructor predeterminado - necesario para crear una nueva instancia para la deserialización.
    public Book() {}

    // Constructor con parámetros para inicializar los campos con valores dados.
    public Book(String title, String author, int year) {
        this.title = title;
        this.author = author;
        this.year = year;
    }

    // El método write serializa los campos del objeto al DataOutput.
    public void write(DataOutput out) throws IOException {
        out.writeUTF(title); // Escribe el título como UTF-8
        out.writeUTF(author); // Escribe el autor como UTF-8
        out.writeInt(year); // Escribe el año de publicación como un entero
    }

    // El método readFields deserializa los campos del objeto desde el DataInput.
    public void readFields(DataInput in) throws IOException {
        title = in.readUTF(); // Lee el título como UTF-8
        author = in.readUTF(); // Lee el autor como UTF-8
        year = in.readInt(); // Lee el año de publicación como un entero
    }

    // El método toString proporciona una representación en cadena del objeto,
    // que es útil para imprimir y registrar.
    @Override
    public String toString() {
        return "Title: " + title + ", Author: " + author + ", Year: " + year;
    }

    // Los getters y setters se omiten por brevedad pero son necesarios para acceder a los campos.
}

Esta clase Book contiene campos para el título del libro, el autor y el año de publicación. El método write serializa los datos del libro a un flujo de bytes, mientras que el método readFields deserializa los datos de un flujo de bytes. Ambos métodos son requeridos por la interfaz Writable.

Luego, deberá compilar las clases Java usando los siguientes comandos:

## Compile las clases Java
javac -source 8 -target 8 -classpath $HADOOP_HOME/share/hadoop/common/hadoop-common-3.3.6.jar:$HADOOP_HOME/share/hadoop/mapreduce/hadoop-mapreduce-client-core-3.3.6.jar:. Book.java

Implementando el Mapper y el Reducer

En este paso, crearemos una clase Mapper y una clase Reducer para procesar los datos de los libros utilizando el paradigma MapReduce.

BookMapper personalizado

Primero, cree un nuevo archivo Java llamado BookMapper.java en el directorio /home/hadoop con el siguiente contenido:

import java.io.IOException;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

// BookMapper extiende la clase Mapper para procesar archivos de entrada de texto
// Las parejas de claves-valores de entrada son LongWritable (número de línea) y Text (contenido de línea)
// Las parejas de claves-valores de salida son Text (nombre del autor) y Book (detalles del libro)
public class BookMapper extends Mapper<LongWritable, Text, Text, Book> {
    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        // Divide la línea de entrada por coma
        String[] bookData = value.toString().split(",");
        // Extrae el título, el autor y el año de la línea de entrada
        String title = bookData[0];
        String author = bookData[1];
        int year = Integer.parseInt(bookData[2]);
        // Escribe el autor y los detalles del libro en el contexto
        context.write(new Text(author), new Book(title, author, year));
    }
}

Esta clase BookMapper toma una línea de datos de entrada en el formato "título,autor,año" y emite una pareja de claves-valores con el autor como clave y un objeto Book como valor.

BookReducer personalizado

A continuación, cree un nuevo archivo Java llamado BookReducer.java en el directorio /home/hadoop con el siguiente contenido:

import java.io.IOException;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

// BookReducer extiende la clase Reducer para agrupar los detalles de los libros por autor
// Las parejas de claves-valores de entrada son Text (nombre del autor) y Book (detalles del libro)
// Las parejas de claves-valores de salida son Text (nombre del autor) y Book (detalles de los libros agrupados)
public class BookReducer extends Reducer<Text, Book, Text, Book> {
    @Override
    protected void reduce(Text key, Iterable<Book> values, Context context) throws IOException, InterruptedException {
        // Itera a través de los libros del mismo autor y escribe cada libro en el contexto
        for (Book book : values) {
            context.write(key, book);
        }
    }
}

Esta clase BookReducer simplemente emite las parejas de claves-valores de entrada tal como están, agrupando efectivamente los libros por autor.

Compilar los archivos

Finalmente, deberá compilar las clases Java usando los siguientes comandos:

## Compile las clases Java
javac -source 8 -target 8 -classpath $HADOOP_HOME/share/hadoop/common/hadoop-common-3.3.6.jar:$HADOOP_HOME/share/hadoop/mapreduce/hadoop-mapreduce-client-core-3.3.6.jar:. BookMapper.java BookReducer.java

Ejecutando el trabajo MapReduce

En este paso, crearemos una clase Driver para ejecutar el trabajo MapReduce y procesar los datos de los libros.

BookDriver personalizado

Primero, cree un nuevo archivo Java llamado BookDriver.java en el directorio /home/hadoop con el siguiente contenido:

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

// BookDriver configura y envía el trabajo MapReduce
public class BookDriver {
    public static void main(String[] args) throws Exception {
        // Crea una nueva configuración de trabajo de Hadoop
        Configuration conf = new Configuration();
        // Instancia un objeto Job con la configuración del trabajo
        Job job = Job.getInstance(conf, "Procesamiento de Libros");
        // Especifica el archivo JAR del trabajo por clase
        job.setJarByClass(BookDriver.class);
        // Establece la clase Mapper del trabajo
        job.setMapperClass(BookMapper.class);
        // Establece la clase Reducer del trabajo
        job.setReducerClass(BookReducer.class);
        // Establece la clase de clave de salida del trabajo
        job.setOutputKeyClass(Text.class);
        // Establece la clase de valor de salida del trabajo
        job.setOutputValueClass(Book.class);
        // Establece la ruta de entrada del trabajo
        FileInputFormat.addInputPath(job, new Path(args[0]));
        // Establece la ruta de salida del trabajo
        FileOutputFormat.setOutputPath(job, new Path(args[1]));
        // Sale con el estado de finalización del trabajo
        System.exit(job.waitForCompletion(true)? 0 : 1);
    }
}

Esta clase BookDriver configura y ejecuta el trabajo MapReduce. Configura el trabajo con las clases BookMapper y BookReducer, establece las rutas de entrada y salida y espera a que el trabajo se complete.

Ejecutando el trabajo

Para ejecutar el trabajo MapReduce, deberá compilar las clases Java y crear un archivo JAR. Puede usar los siguientes comandos:

## Compile las clases Java
javac -source 8 -target 8 -classpath $HADOOP_HOME/share/hadoop/common/hadoop-common-3.3.6.jar:$HADOOP_HOME/share/hadoop/mapreduce/hadoop-mapreduce-client-core-3.3.6.jar:. BookDriver.java

## Crea un archivo JAR
jar -cvf book.jar *.class

A continuación, deberá crear un directorio de entrada y copiar algunos datos de libros de muestra en él. Puede usar los siguientes comandos:

## Crea un directorio de entrada
hdfs dfs -mkdir /input

## Copia los datos de muestra al directorio de entrada
hdfs dfs -put./data.txt /input

Finalmente, puede ejecutar el trabajo MapReduce usando el siguiente comando:

hadoop jar book.jar BookDriver /input /output

Este comando ejecutará la clase BookDriver, usando los datos de entrada de /input y escribiendo los resultados en /output. Puede ver el resultado con el siguiente comando.

hdfs dfs -cat /output/part-r-00000

Resumen

¡Felicidades! Ha dominado con éxito la serialización en Hadoop MapReduce, navegando por la creación de clases Writable personalizadas. A través de un escenario en el que el Bibliotecario Principal de una Academia Mágica gestiona una vasta colección de libros, ha creado una clase Book que implementa la interfaz Writable para una serialización y deserialización de datos sin problemas. Creando una clase BookMapper para extraer información de los libros y una clase BookReducer para agrupar eficientemente los libros por autor, ha coordinado el proceso con una clase BookDriver. Esto incluyó tareas como compilar clases Java, crear un archivo JAR y ejecutar el trabajo en el clúster de Hadoop. A lo largo de todo esto, ha adquirido una experiencia invaluable en Hadoop MapReduce, perfeccionando habilidades en clases Writable personalizadas, clases Mapper y Reducer, y coordinando trabajos MapReduce para tareas de procesamiento de datos a gran escala.