O que é serialização de object?

O que se entende por “serialização de objects”? Você pode, por favor, explicar isso com alguns exemplos?

Serialização é a conversão de um object para uma série de bytes, para que o object possa ser facilmente salvo no armazenamento persistente ou transmitido em um link de comunicação. O stream de bytes pode então ser desserializado – convertido em uma réplica do object original.

Você pode pensar em serialização como o processo de converter uma instância de object em uma seqüência de bytes (que pode ser binária ou não, dependendo da implementação).

É muito útil quando você deseja transmitir dados de um object pela rede, por exemplo, de uma JVM para outra.

Em Java, o mecanismo de serialização é embutido na plataforma, mas você precisa implementar a interface Serializable para tornar um object serializável.

Você também pode impedir que alguns dados em seu object sejam serializados marcando o atributo como transitório .

Finalmente, você pode replace o mecanismo padrão e fornecer o seu próprio; isso pode ser adequado em alguns casos especiais. Para fazer isso, você usa um dos resources ocultos em java .

É importante notar que o que é serializado é o “valor” do object, ou o conteúdo, e não a definição da class. Assim, os methods não são serializados.

Aqui está uma amostra muito básica com comentários para facilitar sua leitura:

import java.io.*; import java.util.*; // This class implements "Serializable" to let the system know // it's ok to do it. You as programmer are aware of that. public class SerializationSample implements Serializable { // These attributes conform the "value" of the object. // These two will be serialized; private String aString = "The value of that string"; private int someInteger = 0; // But this won't since it is marked as transient. private transient List unInterestingLongLongList; // Main method to test. public static void main( String [] args ) throws IOException { // Create a sample object, that contains the default values. SerializationSample instance = new SerializationSample(); // The "ObjectOutputStream" class has the default // definition to serialize an object. ObjectOutputStream oos = new ObjectOutputStream( // By using "FileOutputStream" we will // Write it to a File in the file system // It could have been a Socket to another // machine, a database, an in memory array, etc. new FileOutputStream(new File("o.ser"))); // do the magic oos.writeObject( instance ); // close the writing. oos.close(); } } 

Quando executamos este programa, o arquivo “o.ser” é criado e podemos ver o que aconteceu por trás.

Se alterarmos o valor de: someInteger para, por exemplo, Integer.MAX_VALUE , podemos comparar a saída para ver qual é a diferença.

Aqui está uma captura de canvas mostrando precisamente essa diferença:

texto alternativo

Você consegue identificar as diferenças? 😉

Existe um campo adicional relevante na serialização Java: O serialversionUID, mas eu acho que isso já é muito longo para cobri-lo.

Ousar responder a pergunta de 6 anos, adicionando apenas um nível muito alto de compreensão para pessoas novas em Java

O que é serialização?

Convertendo um object para bytes e bytes de volta ao object (desserialização).

quando a serialização é usada?

Quando queremos persistir o object. Quando queremos que o object exista além do tempo de vida da JVM.

Exemplo do mundo real:

ATM: Quando o titular da conta tenta sacar dinheiro do servidor através do checkbox eletrônico, as informações do proprietário da conta, como detalhes de retirada, são serializadas e enviadas ao servidor, onde os detalhes são desserializados e usados ​​para executar as operações.

Como serialização é executada em java.

  1. Implemente a interface java.io.Serializable (interface do marcador para que nenhum método seja implementado).

  2. Persistir o object: Use a class java.io.ObjectOutputStream , um stream de filtro que é um wrapper em torno de um stream de bytes de nível inferior (para gravar objects em filesystems ou transferir um object nivelado através de um fio de rede e reconstruí-lo do outro lado).

    • writeObject(<>) – para escrever um object
    • readObject() – para ler um object serializado

Lembrar:

Quando você serializa um object, somente o estado do object será salvo, não o arquivo ou methods da class do object.

Quando você serializou um object de 2 bytes, você vê um arquivo serializado de 51 bytes.

Passos como o object é serializado e desserializado.

Responder para: Como se converteu em arquivo de 51 bytes?

  • Primeiro, grava os dados mágicos do stream de serialização (STREAM_MAGIC = “AC ED” e STREAM_VERSION = versão da JVM).
  • Em seguida, grava os metadados da class associada a uma instância (comprimento da class, o nome da class, serialVersionUID).
  • Então, recursivamente escreve os metadados da superclass até encontrar java.lang.Object .
  • Em seguida, começa com os dados reais associados à instância.
  • Por fim, grava os dados dos objects associados à instância, começando dos metadados para o conteúdo real.

Se você está interessado em mais informações sobre o departamento de Java Serialization, por favor, verifique este link .

Edit : Mais um bom link para ler.

Isso responderá a algumas perguntas frequentes:

  1. Como não serializar qualquer campo na class.
    Resp: use palavras-chave temporárias

  2. Quando a class filha é serializada, a class pai é serializada?
    Resposta: Não, se o pai não estiver estendendo o campo pais da interface Serializable, não fique serializado.

  3. Quando pai é serializado, a class filha é serializada?
    Resposta: Sim, por padrão, a class filha também é serializada.

  4. Como evitar que uma class filha seja serializada?
    Resposta: a. Substituir writeObject e readObject método e lançar NotSerializableException .

    b. você também pode marcar todos os campos transitórios na class filho.

  5. Algumas classs de nível de sistema, como Thread, OutputStream e suas subclasss, e Socket não são serializáveis.

Serialização é levar um object “vivo” na memory e convertê-lo em um formato que pode ser armazenado em algum lugar (por exemplo, na memory, no disco) e depois “desserializado” de volta a um object ativo.

Eu gostei do jeito que o @OscarRyz apresenta. Embora aqui eu esteja continuando a história da serialização que foi originalmente escrita por @amitgupta.

Mesmo sabendo sobre a estrutura da class do robô e tendo dados serializados, os cientistas da Terra não foram capazes de desserializar os dados que podem fazer os robôs trabalharem.

 Exception in thread "main" java.io.InvalidClassException: SerializeMe; local class incompatible: stream classdesc : 

Os cientistas de Marte esperavam o pagamento completo. Depois que o pagamento foi feito, os cientistas de Marte compartilharam a versão serial com os cientistas da Terra. O cientista da Terra definiu a class do robô e tudo ficou bem.

Serialização significa objects persistentes em java. Se você deseja salvar o estado do object e deseja reconstruir o estado mais tarde (pode estar em outra JVM), a serialização pode ser usada.

Observe que as propriedades de um object só serão salvas. Se você quiser ressuscitar o object novamente, você deve ter o arquivo de class, porque as variables ​​de membro serão armazenadas e não as funções de membro.

por exemplo:

 ObjectInputStream oos = new ObjectInputStream( new FileInputStream( new File("o.ser")) ) ; SerializationSample SS = (SearializationSample) oos.readObject(); 

O Searializable é uma interface de marcação que indica que sua class é serializável. A interface do marcador significa que é apenas uma interface vazia e o uso dessa interface notificará a JVM de que essa class pode ser serializada.

Meus dois centavos do meu 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 object. É representado e armazenado na forma de uma seqüência de bytes. Isso pode ser armazenado em um arquivo. O processo para ler o estado do object a partir do arquivo e restaurá-lo é chamado desserialização.

Qual é a necessidade de serialização?

Na arquitetura moderna, sempre é necessário armazenar o estado do object e, em seguida, recuperá-lo. Por exemplo, no Hibernate, para armazenar um object, devemos tornar a class Serializable. O que acontece é que, uma vez que o estado do object é salvo na forma de bytes, ele pode ser transferido para outro sistema, que pode então ler o estado e recuperar a class. O estado do object pode vir de um database ou de um jvm diferente ou de um componente separado. Com a ajuda da serialização, podemos recuperar o estado do object.

Exemplo de código e explicação:

Primeiro vamos dar uma olhada na Classe de 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 class Item implementa Serializable .

Essa é a interface que permite que uma class seja serializável.

Agora podemos ver uma variável chamada serialVersionUID é inicializada para a variável Long. Esse número é calculado pelo compilador com base no estado da class e nos atributos da class. Esse é o número que ajudará o jvm a identificar o estado de um object quando ler o estado do object do arquivo.

Para isso, podemos dar uma olhada na Documentação oficial da Oracle:

O runtime de serialização associa a cada class serializável um número de versão, chamado serialVersionUID, que é usado durante a desserialização para verificar se o emissor e o receptor de um object serializado carregaram classs para esse object que são compatíveis com relação à serialização. Se o receptor tiver carregado uma class para o object que tenha um serialVersionUID diferente daquele da class do remetente correspondente, a desserialização resultará em um InvalidClassException. Uma class serializável pode declarar seu próprio serialVersionUID explicitamente declarando um campo chamado “serialVersionUID” que deve ser estático, final e do tipo long: ANY-ACCESS-MODIFIER estático final final serialVersionUID = 42L; Se uma class serializável não declarar explicitamente um serialVersionUID, o runtime de serialização calculará um valor serialVersionUID padrão para essa class com base em vários aspectos da class, conforme descrito na Especificação de Serialização de Objetos Java (TM). No entanto, é altamente recomendável que todas as classs serializáveis ​​declarem explicitamente valores de serialVersionUID, pois o cálculo serialVersionUID padrão é altamente sensível a detalhes de class que podem variar dependendo das implementações do compilador e podem resultar em InvalidClassExceptions inesperadas durante a desserialização. Portanto, para garantir um valor serialVersionUID consistente em diferentes implementações do compilador java, uma class serializável deve declarar um valor serialVersionUID explícito. Também é fortemente recomendado que as declarações explícitas de serialVersionUID usem o modificador privado sempre que possível, uma vez que tais declarações se aplicam somente aos campos de class-serialVersionUID imediatamente declarantes que não são úteis como membros herdados.

Se você percebeu, há outra palavra-chave que usamos, que é transitória .

Se um campo não for serializável, ele deve ser marcado como transitório. Aqui marcamos o itemCostPrice como transiente e não queremos que seja escrito em um arquivo

Agora vamos dar uma olhada em como escrever o estado de um object no arquivo e depois lê-lo de lá.

 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(); } } } 

Acima, podemos ver um exemplo de serialização e desserialização de um object.

Para isso usamos duas classs. Para serializar o object, usamos ObjectOutputStream. Nós usamos o método writeObject para escrever o object no arquivo.

Para a desserialização, usamos ObjectInputStream, que lê o object do arquivo. Usa readObject para ler os dados do object do 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 object desserializado é nulo, pois não foi gravado.

Já discutimos as noções básicas de Java Serialization na parte I deste artigo.

Agora vamos discutir profundamente e como funciona.

Primeiro vamos começar com o serialversionuid.

O serialVersionUID é usado como um version control em uma class Serializable.

Se você não declarar explicitamente um serialVersionUID, a JVM fará isso automaticamente, com base em várias propriedades da class Serializable.

Algoritmo de cálculo de Java serialversionuid (Leia mais detalhes aqui)

  1. O nome da class.
    1. Os modificadores de class escritos como um inteiro de 32 bits.
    2. O nome de cada interface classificada por nome.
    3. Para cada campo da class classificado pelo nome do campo (exceto os campos temporários privados e transientes privados: O nome do campo. Os modificadores do campo gravados como um inteiro de 32 bits. O descritor do campo.
    4. Se existir um inicializador de class, escreva o seguinte: O nome do método,.
    5. O modificador do método, java.lang.reflect.Modifier.STATIC, escrito como um inteiro de 32 bits.
    6. O descritor do método, () V.
    7. Para cada construtor não privado classificado por nome e assinatura do método: O nome do método,. Os modificadores do método escritos como um inteiro de 32 bits. O descritor do método.
    8. Para cada método não particular classificado por nome e assinatura do método: O nome do método. Os modificadores do método escritos como um inteiro de 32 bits. O descritor do método.
    9. O algoritmo SHA-1 é executado no stream de bytes produzidos pelo DataOutputStream e produz cinco valores de 32 bits sha [0..4]. O valor de hash é montado a partir dos primeiros e segundos valores de 32 bits do resumo da mensagem SHA-1. Se o resultado da mensagem digest, as cinco palavras de 32 bits H0 H1 H2 H3 H4, estiverem em uma matriz de cinco valores int denominados sha, o valor de hash seria 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 de Java

O algoritmo para serializar um object é descrito abaixo:
1. Escreve os metadados da class associada a uma instância.
2. Escreve recursivamente a descrição da superclass até encontrar java.lang.object .
3. Assim que terminar de gravar as informações de metadados, elas serão iniciadas com os dados reais associados à instância. Mas desta vez, começa da superclass mais alta.
4. Ele recursivamente grava os dados associados à instância, começando da menor superclass até a class mais derivada.

Coisas a ter em mente:

  1. Campos estáticos em uma class não podem ser serializados.

     public class A implements Serializable{ String s; static String staticString = "I won't be serializable"; } 
  2. Se o serialversionuid for diferente na class de leitura, ele lançará uma exceção InvalidClassException .

  3. Se uma class implementar serializável, todas as suas subclasss também serão serializáveis.

     public class A implements Serializable {....}; public class B extends A{...} //also Serializable 
  4. Se uma class tiver uma referência de outra class, todas as referências devem ser serializáveis, caso contrário o processo de serialização não será executado. Nesse caso, NotSerializableException é lançado no tempo de execução.

Por exemplo:

 public class B{ String s, A a; // class A needs to be serializable ie it must implement Serializable } 

Serialização é o processo de converter o estado de um object em bits para que ele possa ser armazenado em um disco rígido. Quando você desserializar o mesmo object, ele manterá seu estado mais tarde. Ele permite recriar objects sem precisar salvar as propriedades dos objects manualmente.

http://en.wikipedia.org/wiki/Serialization

Serialização é o processo de salvar um object em um meio de armazenamento (como um arquivo ou um buffer de memory) ou transmiti-lo por uma conexão de rede em formato binário. Os objects serializados são independentes da JVM e podem ser re-serializados por qualquer JVM. Nesse caso, o estado dos objects java “na memory” é convertido em um stream de bytes. Este tipo de arquivo não pode ser entendido pelo usuário. É um tipo especial de object, ou seja, reutilizado pela JVM (Java Virtual Machine). Esse processo de serializar um object também é chamado de desinflar ou empacotar um object.

O object a ser serializado deve implementar a interface java.io.Serializable . O mecanismo de serialização padrão para um object grava a class do object, a assinatura da class e os valores de todos os campos não temporários e não estáticos.

 class ObjectOutputStream extends java.io.OutputStream implements ObjectOutput, 

ObjectOutput interface ObjectOutput estende a interface DataOutput e adiciona methods para serializar objects e gravar bytes no arquivo. O ObjectOutputStream estende o java.io.OutputStream e implementa a interface ObjectOutput . Ele serializa objects, matrizes e outros valores para um stream. Assim, o construtor de ObjectOutputStream é escrito como:

 ObjectOutput ObjOut = new ObjectOutputStream(new FileOutputStream(f)); 

O código acima foi usado para criar a instância da class ObjectOutput com o construtor ObjectOutputStream( ) que usa a instância do FileOuputStream como um parâmetro.

A interface ObjectOutput é usada implementando a class ObjectOutputStream . O ObjectOutputStream é construído para serializar o object.

Desserializando um object em java

A operação oposta da serialização é chamada desserialização, isto é, extrair os dados de uma série de bytes é conhecida como desserialização, que também é chamada de insuflação ou desarmar.

ObjectInputStream estende java.io.InputStream e implementa a interface ObjectInput . Ele desserializa objects, matrizes e outros valores de um stream de input. Assim, o construtor de ObjectInputStream é escrito como:

 ObjectInputStream obj = new ObjectInputStream(new FileInputStream(f)); 

O código acima do programa cria a instância da class ObjectInputStream para desserializar o arquivo que foi serializado pela class ObjectInputStream . O código acima cria a instância usando a instância da class FileInputStream que contém o object de arquivo especificado que precisa ser desserializado porque o construtor ObjectInputStream() precisa do stream de input.

Serialização é o processo de transformar um object Java em matriz de bytes e, em seguida, retornar ao object novamente com seu estado preservado. Útil para várias coisas, como enviar objects pela rede ou armazenar em cache as coisas no disco.

Leia mais deste pequeno artigo que explica muito bem a parte de programação do processo e depois passe para o javadoc Serializável . Você também pode estar interessado em ler esta questão relacionada .

Retorna o arquivo como um object: http://www.tutorialspoint.com/java/java_serialization.htm

  import java.io.*; public class SerializeDemo { public static void main(String [] args) { Employee e = new Employee(); e.name = "Reyan Ali"; e.address = "Phokka Kuan, Ambehta Peer"; e.SSN = 11122333; e.number = 101; try { FileOutputStream fileOut = new FileOutputStream("/tmp/employee.ser"); ObjectOutputStream out = new ObjectOutputStream(fileOut); out.writeObject(e); out.close(); fileOut.close(); System.out.printf("Serialized data is saved in /tmp/employee.ser"); }catch(IOException i) { i.printStackTrace(); } } } import java.io.*; public class DeserializeDemo { public static void main(String [] args) { Employee e = null; try { FileInputStream fileIn = new FileInputStream("/tmp/employee.ser"); ObjectInputStream in = new ObjectInputStream(fileIn); e = (Employee) in.readObject(); in.close(); fileIn.close(); }catch(IOException i) { i.printStackTrace(); return; }catch(ClassNotFoundException c) { System.out.println("Employee class not found"); c.printStackTrace(); return; } System.out.println("Deserialized Employee..."); System.out.println("Name: " + e.name); System.out.println("Address: " + e.address); System.out.println("SSN: " + e.SSN); System.out.println("Number: " + e.number); } } 

Serialização de Objetos Java

insira a descrição da imagem aqui

Serialization é um mecanismo para transformar um gráfico de objects Java em uma matriz de bytes para armazenamento ( to disk file ) ou transmissão ( across a network ), em seguida, usando a desserialização , podemos restaurar o gráfico de objects. Gráficos de objects são restaurados corretamente usando um mecanismo de compartilhamento de referência. Mas antes de armazenar, verifique se serialVersionUID do arquivo de input / rede e do arquivo .class serialVersionUID são os mesmos. Se não, lance um java.io.InvalidClassException .

Cada class versionada deve identificar a versão original da class para a qual é capaz de gravar streams e a partir da qual pode ler. Por exemplo, uma class com versão deve declarar:

Sintaxe de serialVersionUID

 // ANY-ACCESS-MODIFIER static final long serialVersionUID = (64-bit has)L; private static final long serialVersionUID = 3487495895819393L; 

serialVersionUID é essencial para o processo de serialização. Mas é opcional para o desenvolvedor adicioná-lo ao arquivo de origem java. Se um serialVersionUID não for incluído, o tempo de execução de serialização gerará um serialVersionUID e o associará à class. O object serializado conterá este serialVersionUID juntamente com outros dados.

Observação – É altamente recomendável que todas as classs serializáveis ​​declarem explicitamente um serialVersionUID, since the default serialVersionUID computation is highly sensitive to class details that may vary depending on compiler implementations e podem resultar em conflitos inesperados serialVersionUID durante a desserialização, causando a desserialização.

Inspecionando Classes Serializáveis

insira a descrição da imagem aqui


Um object Java é apenas serializável. se uma class ou qualquer de suas superclasss implementa a interface java.io.Serializable ou sua subinterface, java.io.Externalizable .

  • Uma class deve implementar a interface java.io.Serializable para serializar seu object com sucesso. Serializable é uma interface de marcador e usada para informar ao compilador que a class que o implementa tem que ser adicionada ao comportamento serializável. Aqui o Java Virtual Machine (JVM) é responsável por sua serialização automática.

    Palavra-chave temporária: java.io.Serializable interface

    Ao serializar um object, se não queremos que certos membros de dados do object sejam serializados, podemos usar o modificador transitório. A palavra-chave temporária impedirá que esse membro de dados seja serializado.

    • Campos declarados como transientes ou estáticos são ignorados pelo processo de serialização.

    TRANSIENTE E VOLÁTIL

     +--------------+--------+-------------------------------------+ | Flag Name | Value | Interpretation | +--------------+--------+-------------------------------------+ | ACC_VOLATILE | 0x0040 | Declared volatile; cannot be cached.| +--------------+--------+-------------------------------------+ |ACC_TRANSIENT | 0x0080 | Declared transient; not written or | | | | read by a persistent object manager.| +--------------+--------+-------------------------------------+ 
     class Employee implements Serializable { private static final long serialVersionUID = 2L; static int id; int eno; String name; transient String password; // Using transient keyword means its not going to be Serialized. } 
  • A implementação da interface Externalizável permite que o object assuma controle total sobre o conteúdo e o formato do formulário serializado do object. Os methods da interface Externalizável, writeExternal e readExternal, são chamados para salvar e restaurar o estado dos objects. Quando implementados por uma class, eles podem escrever e ler seu próprio estado usando todos os methods de ObjectOutput e ObjectInput. É responsabilidade dos objects manipular qualquer version control que ocorra.

     class Emp implements Externalizable { int eno; String name; transient String password; // No use of transient, we need to take care of write and read. @Override public void writeExternal(ObjectOutput out) throws IOException { out.writeInt(eno); out.writeUTF(name); //out.writeUTF(password); } @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { this.eno = in.readInt(); this.name = in.readUTF(); //this.password = in.readUTF(); // java.io.EOFException } } 
  • Somente objects que suportam a interface java.io.Serializable ou java.io.Externalizable podem ser written to / read from streams. A class de cada object serializável é codificada, incluindo o nome da class e a assinatura da class, os valores dos campos e matrizes do object e o encerramento de quaisquer outros objects referenciados a partir dos objects iniciais.

Exemplo serializável para arquivos

 public class SerializationDemo { static String fileName = "D:/serializable_file.ser"; public static void main(String[] args) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException { Employee emp = new Employee( ); Employee.id = 1; // Can not Serialize Class data. emp.eno = 77; emp.name = "Yash"; emp.password = "confidential"; objects_WriteRead(emp, fileName); Emp e = new Emp( ); e.eno = 77; e.name = "Yash"; e.password = "confidential"; objects_WriteRead_External(e, fileName); /*String stubHost = "127.0.0.1"; Integer anyFreePort = 7777; socketRead(anyFreePort); //Thread1 socketWrite(emp, stubHost, anyFreePort); //Thread2*/ } public static void objects_WriteRead( Employee obj, String serFilename ) throws IOException{ FileOutputStream fos = new FileOutputStream( new File( serFilename ) ); ObjectOutputStream objectOut = new ObjectOutputStream( fos ); objectOut.writeObject( obj ); objectOut.close(); fos.close(); System.out.println("Data Stored in to a file"); try { FileInputStream fis = new FileInputStream( new File( serFilename ) ); ObjectInputStream ois = new ObjectInputStream( fis ); Object readObject; readObject = ois.readObject(); String calssName = readObject.getClass().getName(); System.out.println("Restoring Class Name : "+ calssName); // InvalidClassException Employee emp = (Employee) readObject; System.out.format("Obj[No:%s, Name:%s, Pass:%s]", emp.eno, emp.name, emp.password); ois.close(); } catch (ClassNotFoundException e) { e.printStackTrace(); } } public static void objects_WriteRead_External( Emp obj, String serFilename ) throws IOException { FileOutputStream fos = new FileOutputStream(new File( serFilename )); ObjectOutputStream objectOut = new ObjectOutputStream( fos ); obj.writeExternal( objectOut ); objectOut.flush(); fos.close(); System.out.println("Data Stored in to a file"); try { // create a new instance and read the assign the contents from stream. Emp emp = new Emp(); FileInputStream fis = new FileInputStream(new File( serFilename )); ObjectInputStream ois = new ObjectInputStream( fis ); emp.readExternal(ois); System.out.format("Obj[No:%s, Name:%s, Pass:%s]", emp.eno, emp.name, emp.password); ois.close(); } catch (ClassNotFoundException e) { e.printStackTrace(); } } } 

Exemplo serializável em rede

Distribuir o estado do object em diferentes espaços de endereço, seja em diferentes processos no mesmo computador ou até mesmo em vários computadores conectados por meio de uma rede, mas que trabalham juntos, compartilhando dados e invocando methods.

  • Marshalling de dados
  • Esboços e esqueletos
 /** * Creates a stream socket and connects it to the specified port number on the named host. */ public static void socketWrite(Employee objectToSend, String stubHost, Integer anyFreePort) { try { // CLIENT - Stub[marshalling] Socket client = new Socket(stubHost, anyFreePort); ObjectOutputStream out = new ObjectOutputStream(client.getOutputStream()); out.writeObject(objectToSend); out.flush(); client.close(); } catch (IOException e) { e.printStackTrace(); } } // Creates a server socket, bound to the specified port. public static void socketRead( Integer anyFreePort ) { try { // SERVER - Stub[unmarshalling ] ServerSocket serverSocket = new ServerSocket( anyFreePort ); System.out.println("Server serves on port and waiting for a client to communicate"); /*System.in.read(); System.in.read();*/ Socket socket = serverSocket.accept(); System.out.println("Client request to communicate on port server accepts it."); ObjectInputStream in = new ObjectInputStream(socket.getInputStream()); Employee objectReceived = (Employee) in.readObject(); System.out.println("Server Obj : "+ objectReceived.name ); socket.close(); serverSocket.close(); } catch (IOException | ClassNotFoundException e) { e.printStackTrace(); } } 

@Vejo

  • implementando Serializable vs Externalizable

| * | Serializando uma class: convertendo um object em bytes e bytes de volta ao object (desserialização).

 class NamCls implements Serializable { int NumVar; String NamVar; } 

|>> Object-Serialization é o processo de converter o estado de um object em vapor de bytes.

  • | -> Implementar quando você deseja que o object exista além da vida útil da JVM.
  • | -> O object serilizado pode ser armazenado no database.
  • | -> Serializable-obects não podem ser lidos e compreendidos por humanos para que possamos alcançar segurança.

A desserialização de object é o processo de obter o estado de um object e armazená-lo em um object (java.lang.Object).

  • | -> Antes de armazenar seu estado, verifique o arquivo serial de tempo serialVersionUID arquivo de input / rede e o arquivo .class serialVersionUID são os mesmos.
    & nbsp & nbspSe não lançar java.io.InvalidClassException.

||> Um object Java é apenas serializável, se sua class ou qualquer de suas superclasss

  • implementa a interface java.io.Serializable ou
  • sua subinterface, java.io.Externalizable.

| => Campos estáticos em uma class não podem ser serializados.

 class NamCls implements Serializable { int NumVar; static String NamVar = "I won't be serializable";; } 

| => Se você não deseja serializar uma variável de uma class, use a palavra-chave temporária

 class NamCls implements Serializable { int NumVar; transient String NamVar; } 

||> Se uma class implementar serializável, todas as suas subclasss também serão serializáveis.

||> Se uma class tiver uma referência de outra class, 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çado no tempo de execução.

Java fornece um mecanismo, chamado de serialização de object, em que um object pode ser representado como uma seqüência de bytes que inclui os dados do object, bem como informações sobre o tipo do object e os tipos de dados armazenados no object. É usado principalmente para percorrer o estado do object na rede (conhecido como marshaling).