¿Qué es la serialización de objetos?
https://stackoverflow.com/questions/447898
-
19-08-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPregunta
¿Qué se entiende por "serialización de objetos"?¿Puedes explicarlo con algunos ejemplos?
Solución
La serialización es la conversión de un objeto a una serie de bytes, de modo que el objeto puede guardarse fácilmente en un almacenamiento persistente o transmitirse a través de un enlace de comunicación. La secuencia de bytes se puede deserializar, convertir en una réplica del objeto original.
Otros consejos
Puede pensar en la serialización como el proceso de convertir una instancia de objeto en una secuencia de bytes (que puede ser binaria o no según la implementación).
Es muy útil cuando desea transmitir datos de un objeto a través de la red, por ejemplo de una JVM a otra.
En Java, el mecanismo de serialización está integrado en la plataforma, pero es necesario implementar el Serializable interfaz para hacer que un objeto sea serializable.
También puede evitar que algunos datos de su objeto se serialicen marcando el atributo como transitorio.
Finalmente puedes anular el mecanismo predeterminado y proporcionar el tuyo propio;esto puede ser adecuado en algunos casos especiales.Para hacer esto, utiliza uno de los características ocultas en java.
Es importante notar que lo que se serializa es el "valor" del objeto, o el contenido, y no la definición de clase.Por tanto, los métodos no están serializados.
A continuación se muestra un ejemplo muy básico con comentarios para facilitar su lectura:
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();
}
}
Cuando ejecutamos este programa se crea el archivo "o.ser" y podemos ver lo que pasó detrás.
Si cambiamos el valor de: algún número entero a, por ejemplo Entero.MAX_VALUE, podemos comparar el resultado para ver cuál es la diferencia.
Aquí hay una captura de pantalla que muestra precisamente esa diferencia:
¿Puedes ver las diferencias?;)
Hay un campo relevante adicional en la serialización de Java:El versión serialUID pero supongo que esto ya es demasiado largo para cubrirlo.
Atreverse a contestar preguntas de 6 años, agregando solo un muy alto nivel de comprensión para las personas nuevas en Java
¿Qué es la serialización?
Convertir un objeto a bytes y bytes nuevamente a objeto (Deserialización).
¿cuándo se usa la serialización?
Cuando queremos persistir el objeto. Cuando queremos que el objeto exista más allá de la vida útil de la JVM.
Ejemplo del mundo real:
ATM: cuando el titular de la cuenta intenta retirar dinero del servidor a través de ATM, la información del titular de la cuenta, como los detalles de retiro, se serializará y se enviará al servidor donde los detalles se deserializan y se utilizan para realizar operaciones.
Cómo se realiza la serialización en java.
-
Implementar
java.io.Serializableinterfaz (interfaz de marcador, por lo que no hay método para implementar). -
Persistir el objeto: utilice la clase
java.io.ObjectOutputStream, una secuencia de filtro que es una envoltura alrededor de una secuencia de bytes de nivel inferior (para escribir Objeto en sistemas de archivos o transferir un objeto aplanado a través de un cable de red y reconstruido en el otro lado).-
writeObject(<<instance>>)- para escribir un objeto -
readObject()- para leer un Objeto serializado
-
Recuerda:
Cuando serializa un objeto, solo se guardará el estado del objeto, no el archivo de clase o los métodos del objeto.
Cuando serializa un objeto de 2 bytes, ve un archivo serializado de 51 bytes.
Muestra cómo se serializa y se deserializa el objeto.
Respuesta para: ¿Cómo se convirtió al archivo de 51 bytes?
- Primero escribe los datos mágicos del flujo de serialización (STREAM_MAGIC = " AC ED " y STREAM_VERSION = versión de la JVM).
- Luego escribe los metadatos de la clase asociada con una instancia (longitud de la clase, el nombre de la clase, serialVersionUID).
- Luego escribe recursivamente los metadatos de la superclase hasta que encuentra
java.lang.Object. - Luego comienza con los datos reales asociados con la instancia.
- Finalmente escribe los datos de los objetos asociados con la instancia a partir de los metadatos al contenido real.
Si está interesado en obtener más información sobre el departamento de serialización de Java, consulte este enlace .
Editar : un buen enlace para leer.
Esto responderá algunas preguntas frecuentes:
-
Cómo no serializar ningún campo en la clase.
Respuesta: use la palabra clave transitoria -
Cuando la clase secundaria se serializa, ¿se serializa la clase primaria?
Respuesta: No, si el padre no amplía el campo de la interfaz serializable, los padres no se serializan. -
Cuando se serializa el padre, ¿se serializa la clase hija?
Respuesta: Sí, por defecto, la clase secundaria también se serializa. -
¿Cómo evitar que la clase secundaria se serialice?
Respuesta: a. Anule el método writeObject y readObject y arrojeNotSerializableException.
b. También puede marcar todos los campos como transitorios en la clase secundaria.
- Algunas clases de nivel de sistema como Thread, OutputStream y sus subclases, y Socket no son serializables.
La serialización está tomando un " live " objeto en la memoria y convertirlo a un formato que pueda almacenarse en algún lugar (por ejemplo, en la memoria, en el disco) y luego " deserialized " volver a un objeto vivo.
Me gustó la forma en que @OscarRyz presenta. Aunque aquí continúo la historia de serialización que fue escrita originalmente por @amitgupta.
Aunque conocer la estructura de clases de los robots y haber serializado los datos, los científicos de la Tierra no pudieron deserializar los datos que pueden hacer que los robots funcionen.
Exception in thread "main" java.io.InvalidClassException:
SerializeMe; local class incompatible: stream classdesc
:
Los científicos de Marte estaban esperando el pago completo. Una vez que se realizó el pago, los científicos de Mars compartieron el serialversionUID con los científicos de la Tierra. El científico de la Tierra lo configuró en clase robot y todo se puso bien.
Mis dos centavos de mi propio blog:
Aquí hay una explicación detallada de la serialización : (mi propio blog)
Serialización :
La serialización es el proceso de persistencia del estado de un objeto. Se representa y almacena en forma de una secuencia de bytes. Esto se puede almacenar en un archivo. El proceso para leer el estado del objeto del archivo y restaurarlo se llama deserialización.
¿Cuál es la necesidad de serialización?
En la arquitectura moderna, siempre es necesario almacenar el estado del objeto y luego recuperarlo. Por ejemplo, en Hibernate, para almacenar un objeto debemos hacer que la clase Serializable. Lo que hace es que una vez que el estado del objeto se guarda en forma de bytes, se puede transferir a otro sistema que luego puede leer el estado y recuperar la clase. El estado del objeto puede provenir de una base de datos o una jvm diferente o de un componente separado. Con la ayuda de la serialización podemos recuperar el estado del objeto.
Ejemplo de código y explicación:
Primero echemos un vistazo a la clase de elemento:
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;
}
}
En el código anterior se puede ver que la clase Item implementa Serializable .
Esta es la interfaz que permite que una clase sea serializable.
Ahora podemos ver que una variable llamada serialVersionUID se inicializa en la variable Long. El compilador calcula este número basándose en el estado de la clase y los atributos de la clase. Este es el número que ayudará a la jvm a identificar el estado de un objeto cuando lee el estado del objeto del archivo.
Para eso podemos echar un vistazo a la documentación oficial de Oracle:
El tiempo de ejecución de serialización se asocia con cada clase serializable a número de versión, llamado serialVersionUID, que se utiliza durante deserialización para verificar que el remitente y el receptor de un serializado objeto ha cargado clases para ese objeto que son compatibles con respecto a la serialización. Si el receptor ha cargado una clase para el objeto que tiene un serialVersionUID diferente al del clase del remitente correspondiente, luego la deserialización dará como resultado un InvalidClassException. Una clase serializable puede declarar su propia serialVersionUID explícitamente declarando un campo llamado " serialVersionUID " que debe ser estático, final y de tipo largo: CUALQUIER MODIFICADOR DE ACCESO estático final largo serialVersionUID = 42L; Si un la clase serializable no declara explícitamente un serialVersionUID, entonces el tiempo de ejecución de serialización calculará un valor predeterminado valor serialVersionUID para esa clase basado en varios aspectos de la clase, como se describe en la serialización de objetos Java (TM) Especificación. Sin embargo, se recomienda encarecidamente que todos Las clases serializables declaran explícitamente los valores serialVersionUID, ya que el cálculo de serialVersionUID predeterminado es muy sensible a la clase detalles que pueden variar según las implementaciones del compilador, y pueden por lo tanto, se producen inesperadas InvalidClassExceptions durante deserialización Por lo tanto, para garantizar un serialVersionUID consistente valor a través de diferentes implementaciones de compilador de Java, un serializable La clase debe declarar un valor serialVersionUID explícito. Tambien es Se recomienda encarecidamente que las declaraciones explícitas serialVersionUID utilicen modificador privado donde sea posible, ya que tales declaraciones se aplican solo a la clase de declaración inmediata: los campos serialVersionUID no son útil como miembros heredados.
Si ha notado que hay otra palabra clave que hemos usado que es transitoria .
Si un campo no es serializable, debe marcarse como transitorio. Aquí marcamos el itemCostPrice como transitorio y no queremos que se escriba en un archivo
Ahora veamos cómo escribir el estado de un objeto en el archivo y luego leerlo desde allí.
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();
}
}
}
En lo anterior podemos ver un ejemplo de serialización y deserialización de un objeto.
Para eso usamos dos clases. Para serializar el objeto, hemos utilizado ObjectOutputStream. Hemos utilizado el método writeObject para escribir el objeto en el archivo.
Para la deserialización, hemos utilizado ObjectInputStream que lee del objeto del archivo. Utiliza readObject para leer los datos del objeto del archivo.
El resultado del código anterior sería 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 del objeto deserializado es nulo ya que no se escribió.
Ya hemos discutido los conceptos básicos de la serialización de Java en la parte I de este artículo.
Ahora discutamos profundamente y cómo funciona.
Primero, comencemos con serialversionuid.
El serialVersionUID se usa como control de versión en una clase serializable.
Si no declara explícitamente un serialVersionUID, JVM lo hará por usted automáticamente, en función de varias propiedades de la clase Serializable.
Algoritmo de Java para calcular serialversionuid (Lea más detalles aquí)
- El nombre de la clase.
- Los modificadores de clase escritos como un entero de 32 bits.
- El nombre de cada interfaz ordenado por nombre.
- Para cada campo de la clase ordenado por nombre de campo (excepto campos privados estáticos y transitorios privados: el nombre del campo. modificadores del campo escrito como un entero de 32 bits. El descriptor en el campo.
- Si existe un inicializador de clase, escriba lo siguiente: El nombre del método,.
- El modificador del método, java.lang.reflect.Modifier.STATIC, escrito como un entero de 32 bits.
- El descriptor del método, () V.
- Para cada constructor no privado ordenado por nombre y firma del método: El nombre del método,. Los modificadores de la método escrito como un entero de 32 bits. El descriptor del método.
- Para cada método no privado ordenado por nombre y firma del método: El nombre del método. Los modificadores del método escrito como Entero de 32 bits. El descriptor del método.
- El algoritmo SHA-1 se ejecuta en la secuencia de bytes producidos por DataOutputStream y produce cinco valores de 32 bits sha [0..4]. los el valor hash se ensambla a partir del primer y segundo valor de 32 bits del Resumen del mensaje SHA-1. Si el resultado del resumen del mensaje, los cinco Las palabras de 32 bits H0 H1 H2 H3 H4, se encuentran en una matriz de cinco valores int llamados sha, el valor hash se calcularía de la siguiente manera:
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 serialización de Java
El algoritmo para serializar un objeto se describe a continuación:
1. Escribe los metadatos de la clase asociada a una instancia.
2. Escribe de forma recursiva la descripción de la superclase hasta que encuentre java.lang.object .
3. Una vez que termina de escribir la información de metadatos, comienza con los datos reales asociados con la instancia. Pero esta vez comienza desde la superclase más alta.
4. Escribe de forma recursiva los datos asociados con la instancia, comenzando desde la superclase mínima hasta la clase más derivada.
Cosas a tener en cuenta:
-
Los campos estáticos en una clase no se pueden serializar.
public class A implements Serializable{ String s; static String staticString = "I won't be serializable"; } -
Si el serialversionuid es diferente en la clase de lectura, arrojará una
InvalidClassExceptionexcepción. -
Si una clase implementa serializable, todas sus subclases también serán serializables.
public class A implements Serializable {....}; public class B extends A{...} //also Serializable -
Si una clase tiene una referencia de otra clase, todas las referencias deben ser serializables, de lo contrario no se realizará el proceso de serializaciónmedicina En tal caso, NotSerializableException se lanza en tiempo de ejecución.
Por ejemplo:
public class B{
String s,
A a; // class A needs to be serializable i.e. it must implement Serializable
}
Serialización significa objetos persistentes en java. Si desea guardar el estado del objeto y desea reconstruir el estado más adelante (puede estar en otra JVM), se puede utilizar la serialización.
Tenga en cuenta que las propiedades de un objeto solo se guardarán. Si desea resucitar el objeto nuevamente, debe tener el archivo de clase, porque las variables miembro solo se almacenarán y no las funciones miembro.
por ejemplo:
ObjectInputStream oos = new ObjectInputStream(
new FileInputStream( new File("o.ser")) ) ;
SerializationSample SS = (SearializationSample) oos.readObject();
El buscador es una interfaz de marcador que marca que su clase es serializable. La interfaz de marcador significa que es solo una interfaz vacía y el uso de esa interfaz notificará a la JVM que esta clase puede hacerse serializable.
La serialización es el proceso de convertir el estado de un objeto en bits para que pueda almacenarse en un disco duro. Cuando deserializa el mismo objeto, conservará su estado más adelante. Le permite recrear objetos sin tener que guardar las propiedades de los objetos a mano.
La serialización es el proceso de guardar un objeto en un medio de almacenamiento (como un archivo o un búfer de memoria) o transmitirlo a través de una conexión de red en forma binaria.Los objetos serializados son independientes de JVM y cualquier JVM puede volver a serializarlos.En este caso, el estado de los objetos Java "en memoria" se convierte en un flujo de bytes.El usuario no puede entender este tipo de archivo.Es un tipo especial de objeto, es decir.reutilizado por la JVM (Java Virtual Machine).Este proceso de serializar un objeto también se llama desinflar o ordenar un objeto.
El objeto a serializar debe implementar java.io.Serializable Interfaz.El mecanismo de serialización predeterminado para un objeto escribe la clase del objeto, la firma de la clase y los valores de todos los campos no transitorios y no estáticos.
class ObjectOutputStream extends java.io.OutputStream implements ObjectOutput,
ObjectOutput La interfaz amplía la DataOutput interfaz y agrega métodos para serializar objetos y escribir bytes en el archivo.El ObjectOutputStream se extiende java.io.OutputStream e implementos ObjectOutput interfaz.Serializa objetos, matrices y otros valores en una secuencia.Así, el constructor de ObjectOutputStream se escribe como:
ObjectOutput ObjOut = new ObjectOutputStream(new FileOutputStream(f));
El código anterior se ha utilizado para crear la instancia del ObjectOutput clase con el ObjectOutputStream( ) constructor que toma la instancia del FileOuputStream como parámetro.
El ObjectOutput La interfaz se utiliza implementando el ObjectOutputStream clase.El ObjectOutputStream se construye para serializar el objeto.
Deserializar un objeto en java
La operación opuesta a la serialización se llama deserialización, es decir.extraer los datos de una serie de bytes se conoce como deserialización, que también se llama inflar o descomponer.
ObjectInputStream se extiende java.io.InputStream e implementos ObjectInput interfaz.Deserializa objetos, matrices y otros valores de un flujo de entrada.Así, el constructor de ObjectInputStream se escribe como:
ObjectInputStream obj = new ObjectInputStream(new FileInputStream(f));
El código anterior del programa crea la instancia del ObjectInputStream clase para deserializar ese archivo que había sido serializado por el ObjectInputStream clase.El código anterior crea la instancia usando la instancia del FileInputStream clase que contiene el objeto de archivo especificado que debe deserializarse porque el ObjectInputStream() El constructor necesita el flujo de entrada.
Serialization es un mecanismo para transformar un gráfico de objetos Java en una matriz de bytes para almacenamiento (to disk file) o transmisión (across a network), luego, usando deserialización podemos Restaurar la gráfica de objetos.
Los gráficos de objetos se restauran correctamente utilizando un mecanismo para compartir referencias. Pero antes de almacenar, verifique si serialVersionUID de input-file / network y .class file serialVersionUID son iguales. De lo contrario, arroje un java.io.InvalidClassException.
Cada clase versionada debe identificar la versión de clase original para la cual es capaz de escribir secuencias y de la que puede leer. Por ejemplo, una clase versionada debe declarar:
sintaxis serialVersionUID
// ANY-ACCESS-MODIFIER static final long serialVersionUID = (64-bit has)L; private static final long serialVersionUID = 3487495895819393L;
serialVersionUID es esencial para el proceso de serialización. Pero es opcional para el desarrollador agregarlo al archivo fuente de Java. Si no se incluye un serialVersionUID, el tiempo de ejecución de serialización generará un serialVersionUID y lo asociará con la clase. El objeto serializado contendrá este serialVersionUID junto con otros datos.
Nota : se recomienda encarecidamente que todas las clases serializables declaren explícitamente un serialVersionUID, since the default serialVersionUID computation is highly sensitive to class details that may vary depending on compiler implementations y, por lo tanto, pueden dar lugar a conflictos inesperados de serialVersionUID durante la deserialización, lo que puede causar fallar.
Inspección de clases serializables
Un objeto Java solo es serializable. si una clase o cualquiera de sus superclases implementa la interfaz java.io.Serializable o su subinterfaz, java.io.Externalizable .
-
Una clase debe implementar java.io.Serializable interface para serializar su objeto con éxito. Serializable es una interfaz de marcador y se utiliza para informar al compilador que la clase que lo implementa tiene que agregar un comportamiento serializable. Aquí Java Virtual Machine (JVM) es responsable de su serialización automática.
Palabra clave transitoria:
java.io.Serializable interfaceMientras se serializa un objeto, si no queremos que ciertos miembros de datos del objeto se serialicen, podemos usar el modificador transitorio. La palabra clave transitoria evitará que ese miembro de datos se serialice.
- Los campos declarados como transitorios o estáticos son ignorados por el proceso de serialización.
TRANSITORIO & Amp; VOLATILE
+--------------+--------+-------------------------------------+ | 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. } -
La implementación de la interfaz Externalizable permite que el objeto asuma un control completo sobre el contenido y el formato de la forma serializada del objeto. Los métodos de la interfaz Externalizable, writeExternal y readExternal, se llaman para guardar y restaurar el estado de los objetos. Cuando los implementa una clase, pueden escribir y leer su propio estado utilizandoTodos los métodos de ObjectOutput y ObjectInput. Es responsabilidad de los objetos manejar cualquier versión que ocurra.
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 } } -
Solo los objetos que admiten la interfaz java.io.Serializable o java.io.Externalizable pueden ser
written to/read fromsecuencias. La clase de cada objeto serializable se codifica incluyendo el nombre de la clase y la firma de la clase, los valores de los campos y matrices del objeto, y el cierre de cualquier otro objeto referenciado desde los objetos iniciales.
Ejemplo serializable para archivos
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();
}
}
}
Ejemplo serializable a través de la red
Distribuyendo el estado del objeto en diferentes espacios de direcciones, ya sea en diferentes procesos en el mismo computadora, o incluso en varias computadoras conectadas a través de una red, pero que trabajan juntas al compartir datos e invocar 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();
}
}
@ver
La serialización es el proceso de convertir un objeto Java en una matriz de bytes y luego volverlo a convertir en objeto con su estado preservado. Útil para varias cosas como enviar objetos a través de la red o almacenar en caché cosas en el disco.
Lea más de este breve artículo que explica bastante bien la parte de programación del proceso y luego pasar a Serializable javadoc . También te puede interesar leer esta pregunta relacionada .
Devuelva el archivo como un 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);
}
}
| * | Serializar una clase: Convertir un objeto a bytes y bytes nuevamente a objeto (Deserialización).
class NamCls implements Serializable
{
int NumVar;
String NamVar;
}
| = > La serialización de objetos es el proceso de convertir el estado de un objeto en vapor de bytes.
- | - > Implemente cuando desee que el objeto exista más allá de la vida útil de la JVM.
- | - > El objeto serializado se puede almacenar en la base de datos.
- | - > Los seres serializables no pueden ser leídos y entendidos por los humanos para que podamos lograr la seguridad.
| = > La deserialización de objetos es el proceso de obtener el estado de un objeto y almacenarlo en un objeto (java.lang.Object).
- | - > Antes de almacenar su estado, verifica si serialVersionUID forma input-file / network y .class file serialVersionUID son iguales.
& amp; nbsp & amp; nbsp Si no arroja java.io.InvalidClassException.
| = > Un objeto Java solo es serializable, si su clase o alguna de sus superclases
- implementa la interfaz java.io.Serializable o
- su subinterfaz, java.io.Externalizable.
| = > Los campos estáticos en una clase no se pueden serializar.
class NamCls implements Serializable
{
int NumVar;
static String NamVar = "I won't be serializable";;
}
| = > Si no desea serializar una variable de una clase, use la palabra clave transitoria
class NamCls implements Serializable
{
int NumVar;
transient String NamVar;
}
| = > Si una clase implementa serializable, todas sus subclases también serán serializables.
| = > Si una clase tiene una referencia de otra clase, todas las referencias deben ser serializables, de lo contrario no se realizará el proceso de serialización. En tal caso, se lanza
NotSerializableException en tiempo de ejecución.
