Serialização de objetos I - Salvando objetos em arquivos

Serialização: como salvar seus objetos Java par utilizar quando precisar 

Serialização de objetos é a possibilidade de salvar uma cópia completa de um objeto ou de uma coleção de objetos em um fluxo de saída (arquivo externo), de modo que o objeto pode ser recriado a partir da cópia serializada  quando necessário .


A serialização de objetos Java,  fornece um recurso para transformar um grupo ou um único objeto em um fluxo de bits, ou um array de bytes para armazenar ou enviar pela rede,  de modo que o  referido fluxo de bits ou uma matriz de bytes pode ser transformado novamente em objetos Java.


O processo de serialização também é conhecido como marshaling de um objeto, e de-serialização é conhecido como un-marshaling.

Assim a serialização oferece os seguintes benefícios:

• Um sistema para persistência de objetos, ou seja, escrever as suas propriedades em arquivos externos ou discos, ou salvá-las em um banco de dados.
• Um sistema para chamadas de procedimentos remotos.
• Um sistema de distribuição de objetos, por exemplo, componentes de software, como COM, COBRA.

Para entender completamente o conceito de serialização é preciso ter um entendimento claro da persistência do objeto e Streams. Aqui faremos uma breve explicação de cada.

Streams

Todo programa precisa escrever os seus dados para um local ou canal, cada programa precisa ler dados de um canal bem. Em Java esses canais, de onde um programa escreve ou lê dados são conhecidos como Stream.

Streams são de dois tipos, basicamente:

• Byte Stream-Classes (* Streams)
• Character Stream-Classes (* Reader * e Writer)

Cada fluxo que tem a capacidade de gravar dados contém um conjunto de métodos de gravação. E cada fluxo que pode ler dados a partir de qualquer fonte tem um conjunto semelhante de métodos de leitura. Uma vez que o fluxo é criado todos esses métodos devem ser chamados.

Persistência

Persistência é a capacidade de objetos permanecerem ativos nos aplicativos. Um objeto sem utilização em um aplicativo ( sem referencia apontando para ele) é invariavelmente apagado pelo garbage colector da JVM . A API de  persistência permite armazenar esse objeto, dessa forma ele pode  ser acessado na próxima vez que o aplicativo é executado. 

Objetos serializados não são nada além de objetos convertidos em fluxos e enviados através de arquivos ou através de rede para armazenamento e recuperação. Em tempo, a persistência também é bem comum de acontecer armazenando os dados dos objetos em Banco de dados... mas essa não é a técnica utilizada na serialização.

Implementar a interface Serializable

Qualquer classe deve implementar a interface java.io.Serializable para ser serializável. A interface Serializable não tem métodos e atua somente como um marcador para identificar a classe considerada para serialização.

Nos casos de objetos como uma referência a outro objeto, os campos do objeto também são serializados se a classe que o objeto tenha sido marcado como Serializable. Em outras palavras quando você marca uma classe como serializable, qualquer referencia a outras classes (Objetos) serão serializadas se essas classes também implementarem a interface Serializable. Imagine uma classe chamada Turma que possui varios objetos alunos declarados, para a serialização acontecer sem erros tanto a classe Turma quanto a classe Alunos teria que implementar a interface Serializable.


As  classes principais que ajudam a implementar interface Serializable são:

• ObjectInputStream - Entrada de Stream
• ObjectInputStream - Entrada de Stream para arquivo
• FileOutputStream - Saída de stream para arquivo
• ObjectOutputStream - Saida de Stream

Exemplo prático 

Primeiramente vamos supor que temos o seguinte cenario:

Uma classe aluno que guarda nome e idade
Uma classe principal que armazena 3 alunos em um ArrayList e depois imprime seu conteúdo na tela


Classe Aluno

public class Aluno {
    
    private String nome;
    private int idade;

    public Aluno(String nome, int idade) {
        this.nome = nome;
        this.idade = idade;
    }

    public int getIdade() {
        return idade;
    }

    public void setIdade(int idade) {
        this.idade = idade;
    }

    public String getNome() {
        return nome;
    }

    public void setNome(String nome) {
        this.nome = nome;
    }
    
   
}

Classe Principal

import java.io.*;
import java.util.ArrayList;
/**
 *
 * @author JoaoSantanna
 */
public class ManipulacaoArquivo {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        
        Aluno a1,a2,a3;
        
        a1 = new Aluno("Joao", 33);
        a2 = new Aluno("Pedro", 25);
        a3 = new Aluno("Maria", 30);
        
        ArrayList  turma = new ArrayList( );
        
        turma.add(a1);
        turma.add(a2);
        turma.add(a3);
        
        for ( Aluno a : turma){
            System.out.println("Nome:" + a.getNome( ) + " Idade:" + a.getIdade( ) );
        }
        
    }
}

Agora vem a parte boa, para serializar uma classe precisamos usar a interface Serializable que permite ter acesso aos métodos de serialização, nesse exempo vamos implementar o método salvarDados em uma classe auxiliar chamada armazenamento e lá colocaremos o codigo necessario a operacao, mas para que os objetos alunos contidos no arrayList possa ser serializado a classe Aluno deve implementar a interface Serializable , isso vai dizer a JVM que o Objeto pode ser serializado.

Classe Auxiliar Armazenamento

import java.util.ArrayList;
import java.io.*;

/**
 *
 * @author JoaoSantanna
 */
public class Armazenamento {
    
     public int salvarDados(ArrayList dados ){
        try{
            
            FileOutputStream fs = new FileOutputStream("dadosApp.arq"); //tanto faz o nome do arquivo
            ObjectOutputStream os = new ObjectOutputStream(fs);
            os.writeObject(dados); //referencia a estrutura que se quer armazenar
            os.close( );
            System.out.println("Dados Salvos com Sucesso!");
            return 0;
        }catch(Exception ex){
            return -1;
            
        }
    }   
}

Classe Aluno Modificada ( só trecho modificado )

public class Aluno implements Serializable {

Já na classe principal temos que adicionar um objeto Armazenamento para poder usar o método de serialização, veja abaixo

Aluno a1,a2,a3;
        Armazenamento dados = new Armazenamento( );//novo objeto Armazenamento
        a1 = new Aluno("Joao", 33);
        a2 = new Aluno("Pedro", 25);
        a3 = new Aluno("Maria", 30);
        
        ArrayList  turma = new ArrayList( );
        
        turma.add(a1);
        turma.add(a2);
        turma.add(a3);
        //imprime os dados da turma
        for ( Aluno a : turma){
            System.out.println("Nome:" + a.getNome( ) + " Idade:" + a.getIdade( ) );
        }  
       dados.salvarDados(turma);//metodo para salvar dados
    }

Para salvar objetos em arquivos basta isso.
A segunda parte desse post é como recuperar esses dados e carrega-los novamente em memoria para que o porgrama possa utilizar.

Veja como fazer isso no post : Serialização II: Lendo Objetos de arquivos