O que é serialização de objeto?
https://stackoverflow.com/questions/447898
-
19-08-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
O que se entende por "serialização de objeto"?Você pode por favor explicar com alguns exemplos?
Solução
A serialização é a conversão de um objeto em uma série de bytes, para que o objeto possa ser facilmente salvo para armazenamento persistente ou transmitido por um link de comunicação. O fluxo de bytes pode então ser desserializado - convertido em uma réplica do objeto original.
Outras dicas
Você pode pensar na serialização como o processo de conversão de uma instância de objeto em uma sequência de bytes (que pode ser binário ou não dependendo da implementação).
É muito útil quando você deseja transmitir dados de um objeto em toda a rede, por exemplo, de uma JVM para outra.
Em Java, o mecanismo de serialização é incorporado na plataforma, mas você precisa implementar o Serializável interface para tornar um objeto serializável.
Você também pode impedir que alguns dados em seu objeto sejam serializados marcando o atributo como transitório.
Finalmente, você pode substituir 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 Recursos ocultos em java.
É importante notar que o que é serializado é o "valor" do objeto, ou o conteúdo, e não a definição de classe. Assim, os métodos 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<File> 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: AlgumInteger para, por exemplo Integer.max_value, podemos comparar a saída para ver qual é a diferença.
Aqui está uma captura de tela mostrando com precisão essa diferença:
Você consegue identificar as diferenças? ;)
Existe um campo adicional relevante na serialização de Java: o SerialversionUid Mas acho que isso já é muito longo para cobri -lo.
A ousadia de resposta de 6 anos de idade pergunta, adicionando apenas um nível muito elevado de compreensão, de novas pessoas para o Java
O que é Serialização?
A conversão de um objeto para bytes e bytes de volta ao objeto (Serialização).
quando é serialização utilizado?
Quando queremos manter o Objeto.Quando queremos o objeto para existir além do tempo de vida da JVM.
Exemplo Do Mundo Real:
ATM:Quando o titular da conta tenta levantar dinheiro a partir do servidor, através de MULTIBANCO, o titular da conta informações como withdrawl detalhes serão serializados e enviados para o servidor, onde os detalhes são desserializado e utilizados para executar as operações.
Como serialização é executada em java.
Implementar
java.io.Serializableinterface (marcador de interface de modo nenhum método para implementar).Manter o objeto:Utilização
java.io.ObjectOutputStreamclasse, um filtro de fluxo, que é um wrapper em torno de um nível inferior de fluxo de bytes (para escrever Objeto para sistemas de arquivos ou transferência achatada objeto através de uma rede de arame e reconstruído no outro lado).writeObject(<<instance>>)- para escrever um objectoreadObject()- para ler um Objeto serializado
Lembre-se:
Quando você serializar um objeto, apenas o estado do objeto será salvo, e não o objecto de ficheiro de classe ou métodos.
Quando você serializado um byte 2 objeto, você verá 51 bytes serializado arquivo.
Passos como o objeto é serializado e des-serializado.
Resposta para:Como converter para 51 bytes do arquivo?
- Primeiro escreve a serialização de fluxo de dados mágica (STREAM_MAGIC= "CA ED" e STREAM_VERSION=versão do JVM).
- Em seguida, ele escreve os metadados da classe associada a uma instância (comprimento da classe, o nome da classe, serialVersionUID).
- Em seguida, recursivamente escreve os metadados da superclasse até encontrar
java.lang.Object. - Em seguida, inicia-se com os dados reais associados com a instância.
- Finalmente grava os dados de objetos associados com a instância de partida a partir de metadados ao conteúdo real.
Se você estiver interessado em mais de departamento de informações sobre a Serialização de Java por favor, verifique esta link.
Editar :Mais uma boa link ler.
Isto irá responder a algumas perguntas frequentes:
Como não serializar qualquer campo em sala de aula.
Ans:o uso transitório de palavras-chaveQuando a criança de classe é serializado faz classe pai ser serializada?
Ans:Não, Se o pai não é estender interface Serializable pais de campo não ser serializada.Quando o pai é serializado faz criança de classe ser serializada?
Ans:Sim, por padrão, filho de classe também ser serializada.Como evitar criança de classe de ficar serializado?
Ans:um.Substituir writeObject e readObject método e jogarNotSerializableException.b.você também pode marcar todos os campos transitório na classe filha.
- Algumas nível do sistema de classes tais como Thread, OutputStream e suas subclasses, e o Soquete não são serializáveis.
A serialização está pegando um objeto "ao vivo" na memória e convertendo -o em um formato que pode ser armazenado em algum lugar (por exemplo, na memória, no disco) e posteriormente "desserializou" de volta em um objeto vivo.
Gostei da maneira como @Soscarryz apresenta. Embora aqui eu esteja continuando o história de serialização que foi originalmente escrito por @amitgupta.
Mesmo saber sobre a estrutura da classe de robôs e ter dados serializados sobre os cientistas da Terra, não foram capazes de desserializar os dados que podem fazer com que os robôs funcionassem.
Exception in thread "main" java.io.InvalidClassException:
SerializeMe; local class incompatible: stream classdesc
:
Os cientistas de Marte estavam aguardando o pagamento completo. Uma vez que o pagamento foi feito, os cientistas de Marte compartilharam o SerialversionUid com os cientistas da Terra. O cientista da Terra colocou -o para a classe de robôs e tudo ficou bem.
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.Ele é representado e armazenado na forma de uma seqüência de bytes.Isso pode ser armazenado em um arquivo.O processo de ler o estado do objeto do arquivo e restaurá-lo é chamado de desserialização.
Qual é a necessidade de Serialização?
Nos dias modernos de arquitetura, há sempre uma necessidade para armazenar o estado do objeto e, em seguida, recuperá-lo.Por exemplo, em Hibernação, para armazenar um objeto deve-se fazer a classe Serializável.O que ele faz, é que uma vez que o estado do objeto é salvo no formato de bytes que pode ser transferida para outro sistema, que pode, em seguida, ler o estado e a recuperar a classe.O estado do objeto pode vir de um banco de dados ou em um diferente jvm ou a partir de um componente separado.Com a ajuda de Serialização podemos recuperar o estado do Objeto.
O código de Exemplo e explicação:
Primeiro vamos dar uma olhada na Classe do 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 Item classe implementa Serializable.
Esta é a interface que permite que uma classe para ser serializável.
Agora podemos ver uma variável chamada serialVersionUID é inicializada a variável Longa.Este número é calculado pelo compilador com base no estado da classe e os atributos de classe.Este é o número que vai ajudar a jvm identificar o estado de um objeto quando ele lê o estado do objeto de arquivo.
Para que possamos ter um olhar para o oficial de Documentação do Oracle:
A serialização de tempo de execução associa a cada classe serializável um número de versão, chamada serialVersionUID, que é utilizado durante a desserialização para verificar se o remetente e o receptor de um serializado objecto de ter carregado classes de objeto que são compatíveis com respeito a serialização.Se o receptor tem carregado de uma classe para o objeto que tem um diferente serialVersionUID do que o correspondente do remetente classe e, em seguida, a desserialização irá resultar em um InvalidClassException.Uma classe serializável pode declarar o seu próprio serialVersionUID explicitamente declarando um campo chamado "serialVersionUID", que deve ser static, final, e do tipo long:QUALQUER ACESSO MODIFICADOR static final long serialVersionUID = 42L;Se um classe serializável não declarar explicitamente um serialVersionUID, em seguida, a serialização de tempo de execução irá calcular um padrão serialVersionUID valor para essa classe, baseado em diversos aspectos do de classe, conforme descrito no Java(TM) de Serialização de Objeto Especificação.No entanto, é altamente recomendável que todos os classes serializáveis declarar explicitamente serialVersionUID valores, desde o padrão serialVersionUID cálculo é altamente sensível para a classe detalhes que podem variar dependendo do compilador implementações, e pode resulta, portanto, inesperado durante InvalidClassExceptions desserialização.Portanto, para garantir uma consistente serialVersionUID valor através de diferentes compilador java implementações, serializável classe deve declarar explicitamente uma serialVersionUID valor.Ele também é fortemente recomendado que explícita serialVersionUID declarações de usar o privado modificador, sempre que possível, uma vez que tais declarações se aplicam apenas para imediatamente declaração de classe--serialVersionUID campos não são útil como herdadas membros.
Se você tem notado é que há outra palavra-chave temos utilizado, que é transitórias.
Se um campo não é serializável, ele deve ser marcado transitória.Aqui marcamos o itemCostPrice como transitório e não quero isso para ser escrito em um arquivo
Agora vamos dar uma olhada em como gravar o estado de um objeto no arquivo e, em seguida, 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();
}
}
}
No exemplo acima podemos ver um exemplo de serialização e desserialização de um objeto.
Para que nós usamos duas classes.Para serializar o objeto temos usado ObjectOutputStream.Temos usado o método writeObject para escrever o objeto no arquivo.
Para anular a serialização de nós temos usado ObjectInputStream que lê a partir do objeto do arquivo.Ele usa readObject para ler o objeto de dados de um arquivo.
A saída do código acima seria:
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 a partir de anular a serialização de objeto é null como ele não foi escrito.
Já discutimos as noções básicas de Serialização de Java na parte I deste artigo.
Agora vamos discutir profundamente e como ele funciona.
Primeiro vamos começar com o serialversionuid.
O serialVersionUID é usado como um controle de versão em uma classe Serializável.
Se você não declarar explicitamente um serialVersionUID, a JVM vai fazer isso para você automaticamente, com base em várias propriedades da classe Serializável.
Java do Algoritmo de Cálculo de serialversionuid (Leia mais detalhes aqui)
- O nome da classe.
- Os modificadores de classe escrito como um número inteiro de 32 bits.
- O nome de cada interface, ordenados por nome.
- Para cada campo da classe classificados por nome de campo (exceto estático privado e privado transitória campos:O nome do campo.O modificadores do campo escrito como um número inteiro de 32 bits.O descritor de do campo.
- Se uma classe inicializador de existir, escreva o seguinte:O nome do método .
- O modificador do método, java.lang.refletir.Modificador.ESTÁTICO, escrito como um número inteiro de 32 bits.
- O descritor do método ()V.
- Para cada não-construtor particular ordenados pelo nome do método e assinatura:O nome do método .Os modificadores do método de escrita como um inteiro de 32 bits.O descritor do método.
- Para cada não-privado método de ordenadas pelo nome do método e assinatura:O nome do método.Os modificadores do método de escrita como um Inteiro de 32 bits.O descritor do método.
- O algoritmo SHA-1 é executada a sequência de bytes, produzido por DataOutputStream e produz cinco valores de 32 bits sha[0..4].O valor de hash é montado a partir de primeiro e segundo valores de 32 bits do SHA-1 síntese da mensagem.Se o resultado da síntese da mensagem, cinco Palavras de 32 bits H0 H1 H2 H3 H4, está em uma matriz de cinco valores int nome 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;
Java do algoritmo de serialização
O algoritmo para serializar um objeto é descrito como abaixo:
1.Ele escreve os metadados da classe associada a uma instância.
2.Recursivamente escreve a descrição da superclasse até encontrar o java.lang.objeto.
3.Depois que ele termina de escrever as informações de metadados, em seguida, ele começa com os dados reais associados com a instância.Mas, desta vez, começa a partir da primeira superclasse.
4.Recursivamente grava os dados associados com o exemplo, a partir de menos de superclasse para a maioria da classe derivada.
Coisas Para Manter Em Mente:
Campos estáticos em uma classe não pode ser serializado.
public class A implements Serializable{ String s; static String staticString = "I won't be serializable"; }Se o serialversionuid é diferente na leitura de classe, ele irá gerar um
InvalidClassExceptionexceção.Se uma classe implementa serializable, em seguida, todas as suas sub-classes também ser serializável.
public class A implements Serializable {....}; public class B extends A{...} //also SerializableSe uma classe tem uma referência de outra classe, todas as referências devem ser Serializáveis caso contrário processo de serialização não será executada.Em tal caso, NotSerializableException é jogado 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
}
Serialização significa a persistência de objetos em java.Se você deseja salvar o estado do objeto e deseja reconstruir o estado posterior (pode estar em outra JVM) serialização pode ser usado.
Observe que as propriedades de um objeto só vai ser salvo.Se você quer ressuscitar o objeto novamente, você deve ter o arquivo de classe, porque as variáveis de membros só poderão ser 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 é um marcador de interface que marca que a sua classe é serializável.Marcador de interface significa que ele é apenas um vazio interface e usando a interface irá notificar a JVM que esta classe pode ser feita serializável.
A serialização é o processo de converter o estado de um objeto em bits para que possa ser armazenado em um disco rígido. Quando você desfruta do mesmo objeto, ele manterá seu estado mais tarde. Permite recriar objetos sem precisar salvar as propriedades dos objetos manualmente.
A serialização é o processo de salvar um objeto em um meio de armazenamento (como um arquivo ou um buffer de memória) ou transmiti -lo por uma conexão de rede em formato binário. Os objetos serializados são independentes da JVM e podem ser re-reerializados por qualquer JVM. Nesse caso, o estado de Java "In Memory" é convertido em um fluxo de bytes. Esse tipo de arquivo não pode ser entendido pelo usuário. É um tipo especial de objeto, ou seja, reutilizado pela JVM (Java Virtual Machine). Esse processo de serializar um objeto também é chamado de esvaziar ou marcar um objeto.
O objeto a ser serializado deve implementar java.io.Serializable Interface. O mecanismo de serialização padrão para um objeto grava a classe do objeto, a assinatura da classe e os valores de todos os campos não transitórios e não estáticos.
class ObjectOutputStream extends java.io.OutputStream implements ObjectOutput,
ObjectOutput A interface estende o DataOutput Interface e adiciona métodos para serializar objetos e escrever bytes ao arquivo. o ObjectOutputStream estende -se java.io.OutputStream e implementos ObjectOutput interface. Ele serializa objetos, matrizes e outros valores para um fluxo. Assim, o construtor de ObjectOutputStream está escrito como:
ObjectOutput ObjOut = new ObjectOutputStream(new FileOutputStream(f));
O código acima foi usado para criar a instância do ObjectOutput classe com o ObjectOutputStream( ) construtor que leva a instância do FileOuputStream como um parâmetro.
o ObjectOutput A interface é usada implementando o ObjectOutputStream classe. o ObjectOutputStream é construído para serializar o objeto.
Desserializando um objeto em Java
A operação oposta da serialização é chamada de deserialização, ou seja, para extrair os dados de uma série de bytes é conhecida como deserialização, que também é chamada de inflação ou solucionamento.
ObjectInputStream estende -se java.io.InputStream e implementos ObjectInput interface. Ele desapealiza objetos, matrizes e outros valores de um fluxo de entrada. Assim, o construtor de ObjectInputStream está escrito como:
ObjectInputStream obj = new ObjectInputStream(new FileInputStream(f));
O código acima do programa cria a instância do ObjectInputStream classe para desserializar aquele arquivo que havia sido serializado pelo ObjectInputStream classe. O código acima cria a instância usando a instância do FileInputStream classe que contém o objeto de arquivo especificado que deve ser desserializado porque o ObjectInputStream() Construtor precisa do fluxo de entrada.
Serialization é um mecanismo para transformar um gráfico de objetos Java em uma matriz de bytes para armazenamento(to disk file) ou de transmissão(across a network) e, em seguida, usando desserialização podemos restaurar o gráfico de objetos.Gráficos de objetos são restaurados corretamente usando uma referência mecanismo de partilha. Mas antes de armazenar o equipamento, verifique se o serialVersionUID a partir do ficheiro de entrada/e de rede .arquivo de classe serialVersionUID são os mesmos.Se não, jogue um java.io.InvalidClassException.
Cada versão de classe deve identificar a classe original versão para o qual ele é capaz de gravar fluxos e a partir do qual ele pode ler.Por exemplo, uma versão de classe deve declarar:
serialVersionUID Sintaxe
// 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 ele é opcional para o desenvolvedor para adicioná-lo no arquivo de origem java.Se um serialVersionUID não está incluído, a serialização de tempo de execução irá gerar um serialVersionUID e associá-lo com a classe.O objeto serializado vai conter este serialVersionUID, juntamente com outros dados.
Nota - Recomenda-se que todas as classes serializáveis declarar explicitamente um serialVersionUID, since the default serialVersionUID computation is highly sensitive to class details that may vary depending on compiler implementations, e , portanto, podem resultar em inesperado serialVersionUID conflitos durante a desserialização, causando a anulação da serialização para falhar.
Inspecionar Classes Serializáveis
Um objeto Java só é serializável.se uma classe ou qualquer de suas superclasses implementa o o java.io.Serializable interface ou sua subinterface, o java.io.Externalizable.
Uma classe deve implementar o java.io.Interface Serializable para serializar o seu objeto com êxito.Serializable é um marcador de interface e usada para informar ao compilador que a classe de implementação tem de ser adicionado serializable comportamento. Aqui a Máquina Virtual Java (JVM) é responsável pelo seu automática de serialização.
transitória de palavras-Chave:
java.io.Serializable interfaceAo serializar um objeto, se não queremos que certos membros de dados do objeto a ser serializado, podemos usar o transiente de modificador.O transiente de palavras-chave irá impedir que dados membro que está sendo serializado.
- Campos declarados como transitório ou estáticos são ignorados pelo processo de serialização.
+--------------+--------+-------------------------------------+ | 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. }Implementar o Externalizable interface permite que o objeto para assumir controle total sobre o conteúdo e formato do objeto serializado formulário.Os métodos da Externalizable interface, writeExternal e readExternal, são chamados para salvar e restaurar os objectos de estado.Quando implementado por uma classe, eles podem escrever e ler seu próprio estado, usando de todos os métodos de ObjectOutput e ObjectInput.É da responsabilidade dos objectos para lidar com qualquer versão que ocorre.
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 } }Apenas objetos que oferecem suporte a java.io.Serializable ou java.io.Externalizable interface pode ser
written to/read fromfluxos.A classe de cada objeto serializável é codificada, incluindo o nome da classe e a assinatura da classe, os valores dos campos do objeto e matrizes, e o fechamento de quaisquer outros objetos referenciados objetos iniciais.
Serializable Exemplo 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();
}
}
}
Serializable Exemplo, Através De Rede
A distribuição de objeto's do estado em diferentes espaços de endereçamento, ou em processos diferentes no mesmo computador, ou até mesmo em vários computadores conectados através de uma rede, mas que trabalham em conjunto através da partilha de dados e a invocação de métodos.
/**
* 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();
}
}
@veja
A serialização é o processo de transformar um objeto Java em matriz de bytes e depois voltar ao objeto novamente com seu estado preservado. Útil para várias coisas, como enviar objetos sobre rede ou armazenar em cache para o disco.
Leia mais de Este pequeno artigo que explica a parte da programação do processo muito bem e depois vá para Javadoc serializável. Você também pode estar interessado em ler esta pergunta relacionada.
Retorne o arquivo como um objeto: 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 uma classe :A conversão de um objeto para bytes e bytes de volta ao objeto (Serialização).
class NamCls implements Serializable
{
int NumVar;
String NamVar;
}
|=> Objeto-Serialização é o processo de converter o estado de um objeto em vapor de bytes.
- |-> Implementar quando você deseja que o objeto para existir além do tempo de vida da JVM.
- |-> Objeto serializado pode ser armazenado no Banco de dados.
- |-> Serializable-objetos não podem ser lidas e entendidas por seres humanos para que possamos alcançar a segurança.
|=> Objeto-a anulação da Serialização é o processo de se obter o estado de um objeto e armazená-lo em um objeto(java.lang.Objeto).
- |-> Antes de armazenar seu estado, ele verifica se serialVersionUID formulário de entrada de arquivo/rede e de .arquivo de classe serialVersionUID são as mesmas.
Se não lançar o java.io.InvalidClassException.
|=> Um objeto Java só é serializável, se sua classe ou qualquer de suas superclasses
- implementa o java.io.Interface Serializable ou
- sua subinterface, java.io.Externalizable.
|=> Os campos estáticos em uma classe não pode ser serializado.
class NamCls implements Serializable
{
int NumVar;
static String NamVar = "I won't be serializable";;
}
|=> Se você não deseja serialise uma variável de uma classe de uso transitório de palavras-chave
class NamCls implements Serializable
{
int NumVar;
transient String NamVar;
}
|=> Se uma classe implementa serializable, em seguida, todas as suas sub-classes também ser serializável.
|=> Se uma classe tem uma referência de outra classe, todas as referências devem ser Serializáveis caso contrário processo de serialização não será executada.Em tal caso,
NotSerializableException é jogado em tempo de execução.
