Serialização Java

Java provides an object serialization mechanism in which an object can be represented as a byte sequence, which includes the data of the object, information about the object's type, and the types of data stored in the object.

After writing the serialized object to a file, it can be read from the file and deserialized, which means that the type information of the object, the data of the object, and the data types stored in the object can be used to create a new object in memory.

The entire process is independent of the Java Virtual Machine (JVM), which means that an object serialized on one platform can be deserialized on a completely different platform.

The ObjectInputStream and ObjectOutputStream classes are high-level data streams that contain methods for deserializing and serializing objects.

The ObjectOutputStream class contains many write methods for writing various data types, but there is an exception to this:

public final void writeObject(Object x) throws IOException

The above method serializes an object and sends it to the output stream. A similar ObjectInputStream class contains the following method for deserializing an object:

public final Object readObject() throws IOException,　
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　ClassNotFoundException

Este método remove o próximo objeto do fluxo e deserializa o objeto. Seu valor de retorno é Object, então você precisa convertê-lo para o tipo de dados apropriado.

Para demonstrar como a serialização funciona no Java, eu vou usar a classe Employee mencionada anteriormente no tutorial, supondo que tenhamos definido a seguinte classe Employee, que implementa a interface Serializable.

public class Employee implements java.io.Serializable
{
　　　public String name;
　　　public String address;
　　　public transient int SSN;
　　　public int number;
　　　public void mailCheck()
　　　{
　　　　　　System.out.println("Enviando um cheque para "　+　name
　　　　　　　　　　　　　　　　　　　　　　　　　　　+　" "　+　address);
　　　}
}

Observe que para que um objeto de uma classe seja serializado com sucesso, ele deve atender a duas condições:

Essa classe deve implementar a interface java.io.Serializable.

Todas as propriedades dessa classe devem ser serializáveis. Se uma propriedade não for serializável, deve ser marcada como temporária.

Se você quiser saber se uma classe padrão do Java é serializável, consulte a documentação da classe. Verificar se um exemplo de classe é serializável é muito simples, basta verificar se a classe implementa a interface java.io.Serializable.

Serialização de objetos

A classe ObjectOutputStream é usada para serializar um objeto. O exemplo a seguir, SerializeDemo, instancia um objeto Employee e serializa esse objeto para um arquivo.

Após a execução deste programa, é criado um arquivo chamado employee.ser. O programa não tem saída, mas você pode entender a função do programa através da análise do código.

Atenção: Quando serializar um objeto para um arquivo, conforme a convenção padrão do Java, é dado ao arquivo uma extensão .ser.

import java.io;*;
　
public class SerializeDemo
{
　　　public static void main(String [] args)
　　　{
　　　　　　Employee e = new Employee();
　　　　　　e.name = "Reyan Ali";
　　　　　　e.address = "Phokka Kuan, Ambehta Peer";
　　　　　　e.SSN =　11122333;
　　　　　　e.number =　101;
　　　　　　try
　　　　　　{
　　　　　　　　　FileOutputStream fileOut =
　　　　　　　　　new FileOutputStream("/tmp/employee.ser);
　　　　　　　　　ObjectOutputStream out = new ObjectOutputStream(fileOut);
　　　　　　　　　out.writeObject(e);
　　　　　　　　　out.close();
　　　　　　　　　fileOut.close();
　　　　　　　　　System.out.printf("Os dados serializados são salvos em　/tmp/employee.ser);
　　　　　　catch(IOException i)
　　　　　　{
　　　　　　　　　　i.printStackTrace();
　　　　　　}
　　　}
}

deserialização do objeto

O programa DeserializeDemo a seguir exemplifica a deserialização,/tmp/employee.ser armazenou o objeto Employee.

import java.io;*;
　
public class DeserializeDemo
{
　　　public static void main(String [] args)
　　　{
　　　　　　Employee e = null;
　　　　　　try
　　　　　　{
　　　　　　　　　FileInputStream fileIn = new FileInputStream("/tmp/employee.ser);
　　　　　　　　　ObjectInputStream in = new ObjectInputStream(fileIn);
　　　　　　　　　e = (Employee) in.readObject();
　　　　　　　　　in.close();
　　　　　　　　　fileIn.close();
　　　　　　catch(IOException i)
　　　　　　{
　　　　　　　　　i.printStackTrace();
　　　　　　　　　return;
　　　　　　catch(ClassNotFoundException c)
　　　　　　{
　　　　　　　　　System.out.println("Employee class not found");
　　　　　　　　　c.printStackTrace();
　　　　　　　　　return;
　　　　　　}
　　　　　　System.out.println("Deserialized Employee...");
　　　　　　System.out.println("Name: ");　+　e.name);
　　　　　　System.out.println("Address: ");　+　e.address);
　　　　　　System.out.println("SSN: ");　+　e.SSN);
　　　　　　System.out.println("Número: ")　+　e.number);
　　　　}
}

O resultado da compilação e execução do programa acima é mostrado a seguir:

Employee Deserializado...
Nome: Reyan Ali
Endereço: Phokka Kuan, Ambehta Peer
SSN: 0
Número:101

Aqui, é importante notar os seguintes pontos:

O método readObject() dentro do try/O bloco catch tenta capturar a exceção ClassNotFoundException. Para que um objeto possa ser desserializado pelo JVM, ele deve ser possível encontrar o bytecode da classe. Se o JVM não encontrar a classe durante o processo de deserialização, ele lança uma exceção ClassNotFoundException.

Atenção, o valor de retorno do método readObject() é convertido para referência Employee.

Quando o objeto é serializado, o valor do atributo SSN é 111222333Mas, pois o atributo é temporário, o valor não foi enviado para o fluxo de saída. Portanto, após a desserialização, o atributo SSN do objeto Employee é 0.