Página Inicial>Tutorial de programação de redes>Java Tutorial

Análise aprofundada do mecanismo e princípios de serialização Java

Autor：Eve Cole Data da Última Atualização：2024-11-24 10:48:02

Análise do algoritmo de serialização Java

A serialização é um processo de descrição de um objeto como uma série de bytes. A desserialização é um processo de reconstrução desses bytes em um objeto; A API Java Serialization fornece um mecanismo padrão para lidar com a serialização de objetos. Aqui você pode aprender como serializar um objeto, quando a serialização é necessária, e o algoritmo de serialização Java. Usamos um exemplo para demonstrar como os bytes após a serialização descrevem as informações de um objeto.
A necessidade de serialização

Em Java, tudo é um objeto. Em um ambiente distribuído, muitas vezes é necessário transferir objetos de uma rede ou dispositivo para outro. Isso requer um protocolo que possa transmitir dados em ambas as extremidades. O mecanismo de serialização Java foi criado para resolver este problema.
Como serializar um objeto

O pré-requisito para que um objeto seja serializável é implementar a interface Serializable. A interface Serializable não possui métodos e é mais parecida com um marcador. Classes com esta tag podem ser processadas pelo mecanismo de serialização.

Copie o código do código da seguinte forma:

importar java.io.Serializable;
classe TestSerial implementa Serializable {
versão de byte público = 100;
contagem de bytes públicos = 0;
}

Em seguida, escrevemos um programa para serializar o objeto e produzi-lo. ObjectOutputStream pode gerar Object em um fluxo de bytes. Armazenamos temporariamente o fluxo de bytes no arquivo temp.out.
Copie o código do código da seguinte forma:

public static void main(String args[]) lança IOException {
FileOutputStream fos = new FileOutputStream("temp.out");
ObjectOutputStream oos = new ObjectOutputStream(fos);
TestSerial ts = new TestSerial();
oos.writeObject(ts);
oos.flush();
oos.close();
}

Se você quiser ler Bytes de um arquivo persistente para reconstruir o objeto, podemos usar ObjectInputStream.
Copie o código do código da seguinte forma:

public static void main(String args[]) lança IOException {
FileInputStream fis = new FileInputStream("temp.out");
ObjectInputStream oin = new ObjectInputStream(fis);
TestSerial ts = (TestSerial) oin.readObject();
System.out.println("versão="+ts.versão);
}

O resultado da execução é

100.
O formato de serialização do objeto

Qual é a aparência de um objeto depois de ser serializado? Abra o arquivo temp.out que acabamos de serializar e gerar o objeto e exibi-lo em hexadecimal. O conteúdo deverá ser o seguinte:

Copie o código do código da seguinte forma:

CA ED 00 05 73 72 00 0A 53 65 72 69 61 6C 54 65

73 74 A0 0C 34 00 FE B1 DD F9 02 00 02 42 00 05

63 6F 75 6E 74 42 00 07 76 65 72 73 69 6F 6E 78

70 00 64


Este conjunto de bytes é usado para descrever o objeto TestSerial após a serialização. Notamos que existem apenas dois campos na classe TestSerial:

versão de byte público = 100;

contagem de bytes públicos = 0;

Ambos são do tipo byte Em teoria, são necessários apenas 2 bytes para armazenar esses dois campos, mas na verdade temp.out ocupa 51 bytes, o que significa que além dos dados, inclui também outras descrições do objeto serializado.
Algoritmo de serialização Java

O algoritmo de serialização geralmente executa as seguintes etapas:

◆Metadados de classe de saída relacionados a instâncias de objetos.

◆ Produza recursivamente a descrição da superclasse da classe até que não haja mais superclasses.

◆ Após a conclusão dos metadados da classe, os valores reais dos dados da instância do objeto são gerados a partir da superclasse de nível superior.

◆ Gerar dados de instância recursivamente de cima para baixo

Vamos ilustrar com outro exemplo que cobre de forma mais completa todas as situações possíveis:

Copie o código do código da seguinte forma:

classe pai implementa Serializable {
int parentVersion = 10;
}

classe contém implementos Serializable{
int contémVersão = 11;
}

classe pública SerialTest estende pai implementa Serializable {
versão interna = 66;
contém con = new contém();
public int getVersão() {
versão de retorno;
}
public static void main(String args[]) lança IOException {
FileOutputStream fos = new FileOutputStream("temp.out");
ObjectOutputStream oos = new ObjectOutputStream(fos);
SerialTest st = new SerialTest();
oos.writeObject(st);
oos.flush();
oos.close();
}
}


Este exemplo é bastante simples. A classe SerialTest implementa a superclasse Parent e também contém um objeto Container internamente.

O formato serializado é o seguinte:

CA ED 00 05 7372 00 0A 53 65 72 69 61 6C 54 65

73 74 05 52 81 5A CA 66 02 F6 02 00 0249 00 07

76 65 72 73 69 6F 6E4C00 03 63 6F 6E74 00 09

4C63 6F 6E 74 61 69 6E 3B 7872 00 06 70 61 72

65 6E 74 0E DB D2 BD 85 EE 63 7A 02 00 0149 00

0D 70 61 72 65 6E 74 56 65 72 73 69 6F 6E 78 70

0000000A 0000004273 72 00 07 63 6F 6E 74

61 69 6E FC BB E6 0E FB CB 60 C7 02 00 0149 00

0E 63 6F 6E 74 61 69 6E 56 65 72 73 69 6F 6E 78

700000000B

Vamos dar uma olhada mais de perto no que esses bytes representam. Começando, veja cor:

  1. AC ED: STREAM_MAGIC Declara que o protocolo de serialização é usado.
  2. 00 05: STREAM_VERSION Versão do protocolo de serialização.
  3. 0x73: TC_OBJECT. Declare este como um novo objeto.

A primeira etapa no algoritmo de serialização é gerar uma descrição da classe relacionada do objeto. O objeto mostrado no exemplo é uma instância da classe SerialTest, portanto a descrição da classe SerialTest é exibida a seguir. Veja cores:

  1. 0x72: TC_CLASSDESC. Declare uma nova classe para começar aqui.
  2. 00 0A: O comprimento do nome da classe.
  3. 53 65 72 69 61 6c 54 65 73 74: SerialTest, nome da classe.
  4. 05 52 81 5A AC 66 02 F6: SerialVersionUID, ID de serialização Se não for especificado, um ID de 8 bytes será gerado aleatoriamente pelo algoritmo.
  5. 0x02: Número da tag Este valor declara que o objeto suporta serialização.
  6. 00 02: O número de domínios incluídos nesta classe.

A seguir, o algoritmo gera um dos campos, inversão=66, veja cor:

  1. 0x49: O tipo de campo 49 representa "I", que é Int.
  2. 00 07: O comprimento do nome de domínio.
  3. 76 65 72 73 69 6F 6E: versão, descrição do nome de domínio.

Então, o algoritmo gera o próximo domínio, contém con = new contém (); isso é um pouco especial, é um objeto. Ao descrever referências de tipo de objeto, você precisa usar a notação de assinatura de objeto padrão da JVM, consulte a cor:

  1. 0x4C: Tipo de domínio.
  2. 00 03: Comprimento do nome de domínio.
  3. 63 6F 6E: Descrição do nome de domínio, con
  4. 0x74: TC_STRING Representa uma nova String. Use String para referenciar o objeto.
  5. 00 09: O comprimento da String.
  6. 4C 63 6F 6E 74 61 69 6E 3B:Lcontain;, a notação padrão de assinatura de objeto da JVM.
  7. 0x78: TC_ENDBLOCKDATA, sinal de fim do bloco de dados do objeto

.Em seguida, o algoritmo produzirá a descrição da superclasse, que é a classe Pai. Veja a cor:

  1. 0x72: TC_CLASSDESC. Declare que esta é uma nova classe.
  2. 00 06: Comprimento do nome da classe.
  3. 70 61 72 65 6E 74: pai, descrição do nome da classe.
  4. 0E DB D2 BD 85 EE 63 7A:SerialVersionUID, ID de serialização.
  5. 0x02: Número da tag Este valor declara que o objeto suporta serialização.
  6. 00 01: O número de campos na classe.

Em seguida, produza a descrição do domínio da classe pai, intparentVersion=100, veja também color:

  1. 0x49: O tipo de campo 49 representa "I", que é Int.
  2. 00 0D: Comprimento do nome de domínio.
  3. 70 61 72 65 6E 74 56 65 72 73 69 6F 6E: parentVersion, descrição do nome de domínio.
  4. 0x78: TC_ENDBLOCKDATA, sinal de fim do bloco do objeto.
  5. 0x70: TC_NULL, indicando que não há outro sinalizador de superclasse. .

Até agora, o algoritmo produziu as descrições de todas as classes. A próxima etapa é gerar o valor real do objeto de instância. Neste momento, ele parte do domínio da classe pai, veja a cor:

  1. 0000000A: 10, o valor do campo parentVersion.

Existem também campos da classe SerialTest:

  1. 00000042: 66, o valor do campo de versão.

Os bytes a seguir são mais interessantes. O algoritmo precisa descrever as informações da classe contém. Lembre-se, a classe contém ainda não foi descrita.

  1. 0x73: TC_OBJECT, declara que este é um novo objeto.
  2. 0x72: TC_CLASSDESC declara uma nova classe para começar aqui.
  3. 00 07: O comprimento do nome da classe.
  4. 63 6F 6E 74 61 69 6E: contém, descrição do nome da classe.
  5. FC BB E6 0E FB CB 60 C7:SerialVersionUID, ID de serialização.
  6. 0x02: Vários sinalizadores Número da tag Este valor declara que o objeto suporta serialização.
  7. 00 01: Número de domínios dentro da classe.

.Produza a descrição exclusiva do domínio de contains, intcontainVersion=11;

  1. 0x49: Tipo de domínio 49 representa "I", que é Int..
  2. 00 0E: Comprimento do nome de domínio.
  3. 63 6F 6E 74 61 69 6E 56 65 72 73 69 6F 6E: contémVersão, descrição do nome de domínio.
  4. 0x78: Sinalizador de final de bloco de objeto TC_ENDBLOCKDATA.

Neste momento, o algoritmo de serialização verificará se contém possui uma superclasse e, em caso afirmativo, irá produzi-la.

  1. 0x70: TC_NULL, não há superclasse.

Finalmente, o valor real do domínio da classe contém é gerado.

  1. 0000000B: 11, o valor de conteVersion.

OK, discutimos o mecanismo e os princípios da serialização Java e esperamos que seja útil para os alunos.

Artigos Relacionados