Serialização – Transformando Objetos em Bytes

By Felipe Saab

Serialização… funcionalidade bem interesante do Java (e muitas outras linguagens).

Afinal, o que é a serialização?

Serialização é a técnica que permite transformar objetos em bytes, e uma vez que eles são bytes, eles podem ser salvos em disco ou enviados através de um stream (via HTTP, via socket, entre outros).

Vou exemplificar apenas como salvar e recuperar os objetos no disco, uma vez que eu não estou muito acostumado com os sockets e enviar requisições HTTP iria extender muito o tópico.

No exemplo iremos utilizar a classe Tenis (não sei de onde eu tirei isso…).

Tenis.java

public class Tenis implements java.io.Serializable {
 
    private int tamanho;
    private String marca;
    private String modelo;
 
    public Tenis() {
    }
 
    public Tenis(int tamanho, String marca, String modelo) {
        this.tamanho = tamanho;
        this.marca = marca;
        this.modelo = modelo;
    }
 
    public String getMarca() {
        return marca;
    }
 
    public void setMarca(String marca) {
        this.marca = marca;
    }
 
    public String getModelo() {
        return modelo;
    }
 
    public void setModelo(String modelo) {
        this.modelo = modelo;
    }
 
    public int getTamanho() {
        return tamanho;
    }
 
    public void setTamanho(int tamanho) {
        this.tamanho = tamanho;
    }
 
    public String toString(){
        return this.marca + " " + this.modelo + " - Tamanho: " + String.valueOf(this.tamanho);
    }
}

OBS: todo objeto que você quer serializar deve OBRIGATORIAMENTE implementar a interface java.io.Serializable. Essa interface não possui nenhum método, é apenas uma indicação para a JVM saber que este objeto pode ser serializado.

Segue o código do programa principal do nosso exemplo:

public static void main(String[] args) {
 
	ArrayList<tenis> listaTenis = new ArrayList<tenis>();
	listaTenis.add(new Tenis(44, "Nike", "Shoks TL 2"));
	listaTenis.add(new Tenis(42, "Adidas", "Microbounce"));
 
	serializaListaTenis(listaTenis, "D:\serializados.dat");
 
	ArrayList<tenis> listaRecuperada = deserializaListaTenis("D:\serializados.dat");
 
	for (Tenis t : listaRecuperada) {
		System.out.println(t);
	}
}

Uma lista de Tenis foi criada e foram adicionados dois objetos. Depois foi chamado um método serializaListaTenis que vai ser responsável por serializar a lista e salvá-la no arquivo informado no segundo parâmetro.
Logo depois é criada uma nova lista que recebe o retorno do método deserializaListaTenis cuja função é recuperar a lista do arquivo passado por parâmetro.
Por fim a lista que foi recuperada é percorrida e os objetos são exibidos no console.

Vamos ao método que serializa a lista então:

private static void serializaListaTenis(ArrayList<tenis> listaTenis, String arquivo) {
	FileOutputStream arq = null;
	ObjectOutputStream out = null;
	try {
		//arquivo no qual os dados vao ser gravados
		arq = new FileOutputStream(arquivo);
 
		//objeto que vai escrever os dados
		out = new ObjectOutputStream(arq);
 
		//escreve todos os dados
		out.writeObject(listaTenis);
	} catch (IOException ex) {
		ex.printStackTrace();
	} finally {
		try {
			arq.close();
			out.close();
		} catch (IOException ex) {
			ex.printStackTrace();
		}
	}
}

Os comentários estão bem claros e o código é bem simples de entender. É definido um objeto que representa o arquivo no qual os dados vão ser gravados e um outro objeto que irá escrever os dados no arquivo. Por fim a lista é “escrita” no arquivo através do método writeObject do objeto ObjectOutputStream.

Não sei se você percebeu mas o que nós gravamos foi um objeto ArrayList que contém alguns objetos Tenis. Lembrando que para um objeto ser serializado ele deve implementar a interface Serializable, ou seja, a classe ArrayList deve implementar essa interface para poder ser gravada em disco também (e todos os objetos que a lista contém). Olhando na documentação da classe nós iremos encontrar:

A classe ArrayList já implementa a interface Serializable, por isso nós podemos guardar objetos ArrayList no disco (desde que todos os objetos que estejam na lista também implementem esta interface).

Vamos então ao método que recupera a lista do arquivo:

private static ArrayList<tenis> deserializaListaTenis(String arquivo) {
	FileInputStream arqLeitura = null;
	ObjectInputStream in = null;
	ArrayList<tenis> lista = null;
	try {
		//arquivo onde estao os dados serializados
		arqLeitura = new FileInputStream(arquivo);
 
		//objeto que vai ler os dados do arquivo
		in = new ObjectInputStream(arqLeitura);
 
		//recupera os dados
		lista = (ArrayList<tenis>) in.readObject();
	} catch (ClassNotFoundException ex) {
		ex.printStackTrace();
	} catch (IOException ex) {
		ex.printStackTrace();
	} finally {
		try {
			arqLeitura.close();
			in.close();
		} catch (IOException ex) {
			ex.printStackTrace();
		}
	}
 
	return lista;
}

Assim como no método que serializa a lista, este também tem um objeto que representa o arquivo que vai ser lido e um objeto que lê os dados (deserializa). O código é completamente o inverso do outro: referencia o arquivo, cria um objeto que vai ler do arquivo, e recupera os dados.

Então é isso, serializar um objeto pode ser bem útil quando se precisa fazer algo rápido, algo que não compense o esforço de utilizar um banco de dados.

O projeto está disponível aqui. Sintam-se a vontade para baixar e testar.

[]s e até a próxima,
Saab.