Meus dois centavos do meu próprio blog:
Aqui está uma explicação detalhada da serialização : (meu próprio blog)
Serialização:
Serialização é o processo de persistir o estado de um objeto. É representado e armazenado na forma de uma sequência de bytes. Isso pode ser armazenado em um arquivo. O processo para ler o estado do objeto no arquivo e restaurá-lo é chamado desserialização.
Qual é a necessidade de serialização?
Na arquitetura moderna, sempre há a necessidade de armazenar o estado do objeto e depois recuperá-lo. Por exemplo, no Hibernate, para armazenar um objeto, devemos tornar a classe Serializable. O que ele faz é que, uma vez que o estado do objeto é salvo na forma de bytes, ele pode ser transferido para outro sistema que pode ler o estado e recuperar a classe. O estado do objeto pode vir de um banco de dados ou de uma jvm diferente ou de um componente separado. Com a ajuda da serialização, podemos recuperar o estado do objeto.
Código Exemplo e explicação:
Primeiro, vamos dar uma olhada na classe Item:
public class Item implements Serializable{
/**
* This is the Serializable class
*/
private static final long serialVersionUID = 475918891428093041L;
private Long itemId;
private String itemName;
private transient Double itemCostPrice;
public Item(Long itemId, String itemName, Double itemCostPrice) {
super();
this.itemId = itemId;
this.itemName = itemName;
this.itemCostPrice = itemCostPrice;
}
public Long getItemId() {
return itemId;
}
@Override
public String toString() {
return "Item [itemId=" + itemId + ", itemName=" + itemName + ", itemCostPrice=" + itemCostPrice + "]";
}
public void setItemId(Long itemId) {
this.itemId = itemId;
}
public String getItemName() {
return itemName;
}
public void setItemName(String itemName) {
this.itemName = itemName;
}
public Double getItemCostPrice() {
return itemCostPrice;
}
public void setItemCostPrice(Double itemCostPrice) {
this.itemCostPrice = itemCostPrice;
}
}
No código acima, pode ser visto que a classe Item implementa Serializable .
Essa é a interface que permite que uma classe seja serializável.
Agora podemos ver uma variável chamada serialVersionUID é inicializada na variável Long. Esse número é calculado pelo compilador com base no estado da classe e nos atributos da classe. Este é o número que ajudará a jvm a identificar o estado de um objeto ao ler o estado do objeto no arquivo.
Para isso, podemos dar uma olhada na documentação oficial da Oracle:
O tempo de execução de serialização associa a cada classe serializável um número de versão, chamado serialVersionUID, usado durante a desserialização para verificar se o remetente e o destinatário de um objeto serializado carregaram classes para esse objeto que são compatíveis com a serialização. Se o receptor carregou uma classe para o objeto que possui um serialVersionUID diferente daquele da classe do remetente correspondente, a desserialização resultará em uma InvalidClassException. Uma classe serializável pode declarar seu próprio serialVersionUID explicitamente declarando um campo denominado "serialVersionUID" que deve ser estático, final e do tipo long: ANY-ACCESS-MODIFIER static final long serial serialVersionUID = 42L; Se uma classe serializável não declarar explicitamente um serialVersionUID, o tempo de execução da serialização calculará um valor serialVersionUID padrão para essa classe com base em vários aspectos da classe, conforme descrito na Especificação de serialização de objetos Java (TM). No entanto, é altamente recomendável que todas as classes serializáveis declarem explicitamente os valores serialVersionUID, pois a computação serialVersionUID padrão é altamente sensível aos detalhes da classe que podem variar dependendo das implementações do compilador e, portanto, resultar em InvalidClassExceptions inesperadas durante a desserialização. Portanto, para garantir um valor consistente serialVersionUID em diferentes implementações do compilador java, uma classe serializável deve declarar um valor explícito serialVersionUID. Também é altamente recomendável que declarações explícitas serialVersionUID usem o modificador privado sempre que possível,
Se você notou que existe outra palavra-chave que é transitória .
Se um campo não for serializável, ele deve ser marcado como transitório. Aqui, marcamos o itemCostPrice como transitório e não queremos que ele seja gravado em um arquivo
Agora vamos dar uma olhada em como escrever o estado de um objeto no arquivo e depois ler a partir daí.
public class SerializationExample {
public static void main(String[] args){
serialize();
deserialize();
}
public static void serialize(){
Item item = new Item(1L,"Pen", 12.55);
System.out.println("Before Serialization" + item);
FileOutputStream fileOut;
try {
fileOut = new FileOutputStream("/tmp/item.ser");
ObjectOutputStream out = new ObjectOutputStream(fileOut);
out.writeObject(item);
out.close();
fileOut.close();
System.out.println("Serialized data is saved in /tmp/item.ser");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void deserialize(){
Item item;
try {
FileInputStream fileIn = new FileInputStream("/tmp/item.ser");
ObjectInputStream in = new ObjectInputStream(fileIn);
item = (Item) in.readObject();
System.out.println("Serialized data is read from /tmp/item.ser");
System.out.println("After Deserialization" + item);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
No exemplo acima, podemos ver um exemplo de serialização e desserialização de um objeto.
Para isso, usamos duas classes. Para serializar o objeto, usamos ObjectOutputStream. Nós usamos o método writeObject para gravar o objeto no arquivo.
Para desserializar, usamos ObjectInputStream que lê o objeto no arquivo. Ele usa readObject para ler os dados do objeto no arquivo.
A saída do código acima seria como:
Before SerializationItem [itemId=1, itemName=Pen, itemCostPrice=12.55]
Serialized data is saved in /tmp/item.ser
After DeserializationItem [itemId=1, itemName=Pen, itemCostPrice=null]
Observe que itemCostPrice do objeto desserializado é nulo pois não foi gravado.
Já discutimos o básico sobre serialização de Java na parte I deste artigo.
Agora vamos discutir profundamente e como funciona.
Primeiro vamos começar com o serialversionuid.
O serialVersionUID é usado como um controle de versão em uma classe Serializable.
Se você não declarar explicitamente um serialVersionUID, a JVM fará isso para você automaticamente, com base em várias propriedades da classe Serializable.
Algoritmo de cálculo de serialversionuid de Java (Leia mais detalhes aqui)
- O nome da turma.
- Os modificadores de classe escritos como um número inteiro de 32 bits.
- O nome de cada interface classificada por nome.
- Para cada campo da classe classificado por nome do campo (exceto campos estáticos e transitórios privados: O nome do campo. Os modificadores do campo gravados como um número inteiro de 32 bits. O descritor do campo.
- Se existir um inicializador de classe, escreva o seguinte: O nome do método,.
- O modificador do método, java.lang.reflect.Modifier.STATIC, gravado como um número inteiro de 32 bits.
- O descritor do método, () V.
- Para cada construtor não particular classificado por nome e assinatura do método: O nome do método,. Os modificadores do método gravados como um número inteiro de 32 bits. O descritor do método.
- Para cada método não privado classificado por nome e assinatura do método: O nome do método. Os modificadores do método gravados como um número inteiro de 32 bits. O descritor do método.
- O algoritmo SHA-1 é executado no fluxo de bytes produzido pelo DataOutputStream e produz cinco valores de 32 bits sha [0..4]. O valor do hash é montado a partir dos primeiro e segundo valores de 32 bits do resumo da mensagem SHA-1. Se o resultado do resumo da mensagem, as cinco palavras de 32 bits H0 H1 H2 H3 H4, estiverem em uma matriz de cinco valores int denominados sha, o valor do hash será calculado da seguinte forma:
long hash = ((sha[0] >>> 24) & 0xFF) |
> ((sha[0] >>> 16) & 0xFF) << 8 |
> ((sha[0] >>> 8) & 0xFF) << 16 |
> ((sha[0] >>> 0) & 0xFF) << 24 |
> ((sha[1] >>> 24) & 0xFF) << 32 |
> ((sha[1] >>> 16) & 0xFF) << 40 |
> ((sha[1] >>> 8) & 0xFF) << 48 |
> ((sha[1] >>> 0) & 0xFF) << 56;
Algoritmo de serialização do Java
O algoritmo para serializar um objeto é descrito abaixo:
1. Ele grava os metadados da classe associada a uma instância.
2. Escreve recursivamente a descrição da superclasse até encontrar java.lang.object .
3. Depois de terminar de gravar as informações de metadados, ele começa com os dados reais associados à instância. Mas desta vez, começa na superclasse superior.
4. Grava recursivamente os dados associados à instância, iniciando da superclasse mínima para a classe mais derivada.
Coisas para manter em mente:
Os campos estáticos em uma classe não podem ser serializados.
public class A implements Serializable{
String s;
static String staticString = "I won't be serializable";
}
Se o serialversionuid for diferente na classe de leitura, será lançada uma InvalidClassExceptionexceção.
Se uma classe implementar serializável, todas as suas subclasses também serão serializáveis.
public class A implements Serializable {....};
public class B extends A{...} //also Serializable
Se uma classe tiver uma referência a outra classe, todas as referências deverão ser Serializáveis, caso contrário, o processo de serialização não será executado. Nesse caso, NotSerializableException é lançada em tempo de execução.
Por exemplo:
public class B{
String s,
A a; // class A needs to be serializable i.e. it must implement Serializable
}
