1. Serialización personalizada
El proceso de serialización proporcionado por el lenguaje Java es suficiente para la mayor parte de
las clases, ahora bien, se puede personalizar para aquellos casos específicos.
Para personalizar la serialización, es necesario definir dos funciones miembros writeObject y
readObject. El primero, controla que información es enviada al flujo de salida. La segunda, lee la
información escrita por writeObject .
La definición de writeObject ha de ser la siguiente
private void writeObject (ObjectOutputStream s) throws IOException{
s.defaultWriteObject();
//...código para escribir datos
}
La función readObject ha de leer todo lo que se ha escrito con writeObject en el mismo orden en el
que se ha escrito. Además, puede realizar otras tareas necesarias para actualizar el estado del
objeto.
private void readObject (ObjectInputStream s) throws IOException{
s.defaultReadObject();
//...código para leer datos
//...
//actualización del estado del objeto, si es necesario
}
Para un control explícito del proceso de serialización la clase ha de implementar el interface
Externalizable. La clase es responsable de escribir y de leer su contenido, y ha de estar coordinada
con sus calses base para hacer esto.
La definición del interface Externalizable es la siguiente
packege java.io;
public interface Externalizable extends Serializable{
public void writeExternal(ObjectOutput out) throws IOException;
public void readExternal(ObjectOutput in) throws IOException,
java.lang.ClassNotFoundException;;
}
A continuación veremos un ejemplo que consistirá en:




Una clase Empleado con los atributos legajo, apellido y nombre, y sus respectivos getters.
Un método serializar, que recibirá como parámetro el nombre del archivo donde escribirá el archivo.
Un método hidratar, que recibirá como parámetro el nombre del archivo de donde recuperará el
objeto.
Una clase Test con el método main, que se encargará de crear el objeto empleado y serializarlo, y
luego de recuperarlo (hidratarlo)

2. /**
* Empleado.java
*
*/
package serializacion;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
/**
* @author Luciano
* @version 1.0
*
*/
@SuppressWarnings("serial")
public class Empleado implements Serializable {
/**
* Atributos de clase
*/
int legajo;
String apellido;
String nombre;
/**
* Constructor
*
* @param legajo Legajo del empleado
* @param apellido Apellido del empleado
* @param nombre Nombre del empleado
*/
public Empleado(int legajo, String apellido, String nombre) {
super();
this.legajo = legajo;
this.apellido = apellido;
this.nombre = nombre;
}
/**
* Constructor
*
*/
public Empleado() {
super();
}

3. /**
* Escribe a archivo el objeto Empleado
*
* @param archivo Nombre de archivo
* @throws IOException Excepción de entrada/salida
*/
public void serializar (String archivo) throws IOException {
ObjectOutputStream salida = new ObjectOutputStream(new FileOutputStream(archivo));
salida.writeObject(this);
}
/**
*
* @param archivo Nombre de archivo
* @return Objeto hidratado
* @throws IOException Excepción de entrada/salida
* @throws ClassNotFoundException Escepción de clase no encontrada
*/
public Empleado hidratar (String archivo) throws IOException, ClassNotFoundException {
ObjectInputStream entrada = new ObjectInputStream(new FileInputStream(archivo));
return (Empleado) entrada.readObject();
}
/**
* Getter de Apellido de Empleado
* @return Apellido del empleado
*/
public String getApellido() {
return apellido;
}
/**
* Getter de Legajo de Empleado
* @return Legajo del empleado
*/
public int getLegajo() {
return legajo;
}
/**
* Getter de Nombre de Empleado
* @return Nombre del empleado
*/
public String getNombre() {
return nombre;
}
}

4. /**
* Test.java
*
*/
package serializacion;
import java.io.IOException;
public class Test {
/**
* Main
*
* @param args
*/
public static void main(String[] args) {
/* Creación y serialización del objeto Empleado */
Empleado s = new Empleado(122,"Fernandez","Jorge");
try {
s.serializar("empleado_serializado");
} catch (IOException e1) {
System.err.print(e1.getMessage());
}
/* Creación de un objeto Empleado vacío e hidratación */
Empleado h = new Empleado();
try {
h = h.hidratar("empleado_serializado");
System.out.println("Legajo....: " + h.getLegajo());
System.out.println("Apellido..: " + h.getApellido());
System.out.println("Nombre....: " + h.getNombre());
} catch (IOException e1) {
System.err.print(e1.getMessage());
} catch (ClassNotFoundException e1) {
System.err.print(e1.getMessage());
}
}
}