Serialização em Java

Salve! Salve! Pessoal. Hoje vou falar de um assunto que é cobrado na certificação SCJP e que é está dentro de qualquer bom livro de Java básico. Serialização: para que serve? O que é isso? Não consigo entender a essência desse recurso?

Tentarei no post de hoje, buscar explicar  o processo de serialização.  Como envolve códigos nesse post, achei melhor colocar os códigos com a sintaxe grande para download. Assim evitando um post imenso devido aos códigos.

 Let’s GO… 

A serialização resume-se em um único objetivo salvar, gravar, capturar o estado de um objeto. Ou seja, tenho um objeto de uma classe e quero salvar seu estado uso serialização, pois quando quiser usar  esse objeto com seu ultimo estado gravado é somente des-serializa-lo.

Mas por que usar isso?

Usar serialização permite o seguinte: você cria o objeto  ou uma variável de instancia de uma class  e quer gravar em um arquivo para futuramente utilizar esse objeto/variável com seu estado que foi gravado, então basta usar serialização pelo seguinte motivo:

• Lembre-se: quando o construtor é executado os valores são perdidos objeto = null, e os tipos primitivos recebem seus valores padrões.

Com a serialização isso é quebrado a partir que serializo um objeto ou uma variável de instancia seu valor é gravado(em um arquivo), armazenado e futuramente posso obter esse valor através da des-serialização.

Um exemplo básico do código de serialização e des-serialização de objetos.

import java.io.*;

 class Cat implements Serializable{} //1

class SerializeCat{

 public static void main(String args[]){

 Cat c = new Cat(); //criando o objeto

   //aqui vou serializar meu objeto da class cat

   try{

   FileOutputStream fo = new FileOutputStream(“test.ser”);

    ObjectOutputStream oo = new ObjectOutputStream(fo);

        oo.writeObject(c); // serializo objeto cat

         oo.close();

  System.out.println(“Class Cat – object serializado com sucesso”);

       }

    catch(Exception e){e.printStackTrace();}                            

           //des-serializo o objeto

       try{

          FileInputStream fi = new FileInputStream(“test.ser”);

          ObjectInputStream oi = new ObjectInputStream(fi);

                c =(Cat) oi.readObject();

                  oi.close();

           System.out.println(“agora ele foi des-serializado com sucesso”);

              }catch(Exception e){e.printStackTrace();}                          

                }}

//1 criei uma class Cat que implementa a interface (marcadora) Serializable (essa interface  não possui nenhum método a ser implementado)

//ObjectxxxStream é a classe que possui o método mágico de serialização write e read – Object.

//writeObject –> serializa objeto depois escreve o objeto ja serializado no arquivo

 Herança  e Serialização

Quando temos uma subclasse que herda tudo da sua class pai o que acontece com serialização? Nesse caso temos uma pequena regra a seguir, se sua class PAI, implementar Serializable então a sua subclasse implicitamente já  faz Serializable.

Agora se sua classe PAI, não implementa Serializable e sua subclasse implementa então apenas  os objetos da sua subclasse vamos serializar o da class PAI infelizmente terá seus valores iniciais ou padrão. Um exemplo prático:

class Animal{}

class Dog extends Animal implements Serializable{}

No exemplo anterior apenas Dog é serializado.

 Um exemplo mais prático:

class Foo implements Serializable{

int num = 3;

void Num(){num=10;}

}

A class Foo quando for serializada e rodar o método Num() ela vai gravar o valor 10 para a variável int que criamos e quando for des-serializada é ideal que ela mantenha esse valor.

Tenha em mente:

Um objeto des-serializado nós NÃO:

-Queremos que a inicialização normal rode.

-Não queremos que os construtores rodem.

-E não queremos que os valores explicitamente declarados sejam atribuídos.

 Na verdade QUEREMOS apenas um retorno do estado que foi gravado, serializado.

 Serialização não estar para static  

Quando se diz: “A serialização não está para static” isso não quer dizer que seu código não vai compilar ou vai lançar alguma exceção caso tente serializar uma variável static. Simplesmente diz que não é possível gravar o estado de uma variável static. Mas por quê?

 Devido à variável static não ter objetos, ela pertence à class. Ao contrario das  variáveis de instancia que pertencem a um objeto. Sabemos que static o valor da variável é compartilhado para todos então se serializo 10, mas depois altero o valor para 20. Então  na des-serializacao retorna 20 já que não temos instancia nenhuma do static ele vai trazer o ultimo valor.

Exemplo prático

Algumas regras importantes:

– modificador Transient:  ignora o objeto ou variável durante a serialização, isso aqui não vai serializado. (exemplos veja)

– Caso o arquivo especificado na des-serialização não exista ele não é des-serializado e então acontece a serialização mais uma exceção é lançada por o arquivo não existir

– as classes precisam implementar a interface Serializable para que os seus objetos possam ser serializados (exemplos veja).

– Se a superclasse implementar Serializable, então as suas subclasses também a implementam automaticamente.

– Se  a superclass não implementar Serializable, então quando um objeto da subclasse for des-serializado o construtor da superclasse será executado.

– Se sua class serializable tiver referencia para outra classe que não eh serializable uma exceção ocorre em tempo de exceção.

– Posso serializar apenas objeto (autoboxing funciona primitivo >> objeto)

– ObjectInputStream à ler e dês-serializa

– ObjectOutputStream à escreve e serializa

 

Essas são algumas regras e funcionamento de Serialização, espero ter tirado as duvidas e contribuído para o aprendizado. Um abraço a todos! E até a próxima!