¿Qué es la serialización de objetos? [duplicar]

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 dependiendo de 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 necesita implementar la interfaz Serializable para hacer que un objeto sea serializable.

También puedes evite que algunos datos de su objeto sean serializados marcando el atributo como transient.

Finalmente puede anular el mecanismo predeterminado y proporcionar el suyo propio; esto puede ser adecuado en algunos casos especiales. Para hacer esto, se utiliza una de las 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 la clase. Por lo tanto, los métodos no son serializados.

Aquí hay un muy muestra básica 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 qué pasó detrás.

Si cambiamos el valor de: someInteger a, por ejemplo, Entero.MAX_VALUE , podemos comparar la salida para ver cuál es la diferencia.

Aquí hay una captura de pantalla que muestra precisamente esa diferencia:

_{¿Puedes encontrar las diferencias? ;)}

Hay un campo adicional relevante en la serialización de Java: El serialVersionUID pero supongo que esto ya es demasiado largo para cubrirlo.

Atreverse a responder a la pregunta de 6 años de edad, añadiendo solo una comprensión de muy alto nivel para las personas nuevas en Java

¿Qué es la serialización?

Convertir un objeto a bytes y bytes de vuelta a objeto (Deserialización).

¿Cuándo se utiliza la serialización?

Cuando queremos persistir el Objeto. Cuando queremos que el objeto exista más allá de la vida 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 withdrawl, se serializará y se enviará al servidor donde los detalles se deserializarán y se utilizarán para realizar operaciones.

Cómo se realiza la serialización en java.

1. Implementar interfaz java.io.Serializable (interfaz de marcador, por lo que no hay método para implementar).

2. Persist the object: Use java.io.ObjectOutputStream class, un flujo de filtro que es un contenedor alrededor de un byte de nivel inferior stream (para escribir un Objeto en sistemas de archivos o transferir un objeto aplanado a través de un cable de red y reconstruirlo en el otro lado).

   • writeObject(<<instance>>) - para escribir un objeto
   • readObject() - para leer un Objeto serializado

Recuerda:

Cuando se serializa un objeto, solo se guardará el estado del objeto, no el archivo de clase o los métodos del objeto.

Cuando se serializa un objeto de 2 bytes, se ve un archivo serializado de 51 bytes.

Indica cómo se serializa y deserializa el objeto.

Respuesta para: ¿Cómo se convirtió a un archivo de 51 bytes?

• Primero escribe los datos mágicos de la secuencia 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 metadatos al contenido real.

Si está interesado en obtener más información del departamento sobre la serialización de Java, consulte este enlace.

Edit : One more good link to read.

Esto responderá a algunas preguntas frecuentes:

1. Cómo no serializar ningún campo en clase.
   Ans: use la palabra clave transitoria

2. Cuando la clase hijo se serializa, ¿la clase padre se serializa?
   Respuesta: No, Si el padre no está extendiendo la interfaz serializable, el campo padres no se serializará.

3. Cuando el padre es serializado ¿la clase del hijo es serializada?
   Ans: Sí, por defecto la clase hija también se serializa.

4. ¿Cómo evitar que la clase infantil sea serializada?
   Ans: a. Override Los métodos writeObject y readObject y throw NotSerializableException.
   

   B. también puede marcar todos los campos transient en la clase hija.

5. Algunas clases a nivel de sistema como Thread, OutputStream y sus subclases, y Socket no son serializables.
   

La serialización es tomar un objeto "vivo" en la memoria y convertirlo a un formato que se puede almacenar en algún lugar (por ejemplo. en memoria, en disco) y más tarde "deserializado" de nuevo en 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.

A pesar de conocer la estructura de clases de los robots y tener datos serializados, los científicos de la Tierra no fueron capaces de 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 hecho el pago, los científicos de Marte compartieron el serialVersionUID con Científicos de la Tierra. El científico de la Tierra lo puso en clase robot y todo se puso bien.

Serialización significa objetos persistentes en java. Si desea guardar el estado del objeto y desea reconstruir el estado más tarde (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 de nuevo, debe tener el archivo de clase, porque solo se almacenarán las variables miembro y no las funciones miembro.

Eg:

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

El Searializable es una interfaz de marcador que marca que su clase es serializable. 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 ser serializable.

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 desde el archivo y restaurarlo se llama deserialización.

¿Cuál es la necesidad de La serialización?

En la arquitectura moderna, siempre hay una necesidad de almacenar el estado del objeto y luego recuperarlo. Por ejemplo, en Hibernate, para almacenar un objeto debemos hacer que la clase sea 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 desde el estado y recuperar la clase. El estado del objeto puede provenir de una base de datos o de una jvm diferente o de un componente separado. Con la ayuda de 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 una variable llamada serialVersionUID se inicializa a variable Larga. Este número es calculado por el compilador basado 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 desde el 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 emisor y el receptor de un serializado objeto tener clases cargadas para ese objeto que sean compatibles con respecto a la serialización. Si el receptor ha cargado una clase para el objeto que tiene un serialVersionUID diferente al de la la clase del remitente correspondiente, luego la deserialización resultará en 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: ANY-ACCESS-MODIFICADOR estático final largo serialVersionUID = 42L; Si a la clase serializable no declara explícitamente un serialVersionUID, a continuación, el tiempo de ejecución de serialización calculará un valor predeterminado serialVersionUID valor 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 predeterminado serialVersionUID es altamente sensible a la clase detalles que pueden variar dependiendo de las implementaciones del compilador, y pueden por lo tanto, dar lugar a inesperadas InvalidClassExceptions durante deserialización. Por lo tanto, para garantizar una constante serialVersionUID valor a través de diferentes implementaciones de compilador de Java, un serializable la clase debe declarar un valor serialVersionUID explícito. También es se recomienda encarecidamente que las declaraciones serialVersionUID explícitas utilicen modificador privado siempre que sea posible, ya que tales declaraciones se aplican únicamente a el declarando inmediatamente class ser serialVersionUID los campos no son útil como miembros heredados.

Si has notado que hay otra palabra clave que hemos usado que es transient.

Si un campo no es serializable, debe estar marcado como transitorio. Aquí marcamos el itemCostPrice como transitorio y no queremos que se escriba en un archivo

Ahora echemos un vistazo a cómo escribir el estado de un objeto en el archivo y luego leerlo desde alli.

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 Deserializar hemos usado ObjectInputStream que lee desde el objeto desde el archivo. Utiliza readObject para leer los datos del objeto desde el archivo.

La salida 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 itemCostPricedel objeto deserializado es null ya que no fue escrito.

Ya hemos discutido los fundamentos de la serialización de Java en la parte I de este artículo.

Ahora vamos a discutirlo profundamente y cómo funciona.

Primero comencemos con el serialversionuid.

El serialVersionUID se usa como un control de versiones en una clase Serializable.

Si no declara explícitamente una serialVersionUID, JVM lo hará por usted automáticamente, basado en varias propiedades de la clase Serializable.

Algoritmo de Java para calcular serialversionuid (Leer más detalles aquí)

1. El nombre de la clase.
   1. Los modificadores de clase escritos como un entero de 32 bits.
   2. El nombre de cada interfaz ordenado por nombre.
   3. Para cada campo de la clase ordenado por nombre de campo (excepto los campos privados estáticos y privados transitorios: El nombre del campo. El modificadores del campo escritos como un entero de 32 bits. Descriptor del campo.
   4. Si existe un inicializador de clases, escriba lo siguiente: El nombre del método, .
   5. El modificador del método java.lang.reflejar.Modificador.ESTÁTICO, escrito como un entero de 32 bits.
   6. El descriptor del método, () V.
   7. Para cada constructor no privado ordenado por nombre de método y firma: El nombre del método, . Los modificadores de la método escrito como un entero de 32 bits. El descriptor del método.
   8. Para cada método no privado ordenado por nombre y firma del método: El nombre del método. Los modificadores del método escritos como un Entero de 32 bits. El descriptor del método.
   9. El algoritmo SHA-1 se ejecuta en el flujo de bytes producidos por DataOutputStream y produce cinco valores de 32 bits sha[0..4]. El 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 palabras de 32 bits H0 H1 H2 H3 H4, está en una matriz de cinco valores int nombrados 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 recursivamente el descripción de la superclase hasta que encuentre java.lang.objeto.
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 recursivamente los datos asociados con la instancia, comenzando desde la superclase menor a la clase más derivada.

Cosas A Tener En Cuenta:

1. Campos estáticos en una clase no se puede serializar.

   public class A implements Serializable{
        String s;
        static String staticString = "I won't be serializable";
   }
   

2. Si el serialversionuid es diferente en la clase read lanzará una excepción InvalidClassException.

3. Si una clase implementa serializable entonces todas sus subclases también serán serializables.

   public class A implements Serializable {....};
   
   public class B extends A{...} //also Serializable
   

4. 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, NotSerializableException se lanza a ejecución.

Eg:

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

La serialización es el proceso de convertir el estado de un objeto en bits para que pueda almacenarse en un disco duro. Al deserializar el objeto mismo, conservará su estado más adelante. Le permite recrear objetos sin tener que guardar las propiedades de los objetos a mano.

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

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 pueden ser re-serializados por cualquier JVM. En este caso, el estado de los objetos java "en memoria" se convierte en un flujo de bytes. Este tipo de archivo no puede ser entendido por el usuario. Es un tipo especial de objeto, es decir, reutilizado por la JVM (Máquina Virtual Java). Este proceso de serializar un objeto también se denomina desinflar o ordenar un objeto.

El objeto a serializado debe implementar la interfaz java.io.Serializable. El mecanismo de serialización predeterminado para un objeto escribe la clase del objeto, la firma de clase y los valores de todos los campos no transitorios y no estáticos.

class ObjectOutputStream extends java.io.OutputStream implements ObjectOutput,

ObjectOutput interfaz extiende la interfaz DataOutput y añade métodos para serializar objetos y escribir bytes en el archivo. El ObjectOutputStream extiende java.io.OutputStream e implementa la interfaz ObjectOutput. 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 de la clase ObjectOutput con el constructor ObjectOutputStream( ) que toma la instancia de FileOuputStream como parámetro.

La interfaz ObjectOutput se utiliza implementando la clase ObjectOutputStream. El ObjectOutputStream está construido para serializar el objeto.

Deserializar un Objeto en java

La operación opuesta de la serialización se llama deserialización, es decir, para extraer los datos de una serie de bytes se conoce como deserialización que también se llama inflar o unmarshalling.

ObjectInputStream extiende java.io.InputStream e implementa la interfaz ObjectInput. 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 de la clase ObjectInputStream para deserializar ese archivo que había sido serializado por la clase ObjectInputStream. El código anterior crea la instancia usando la instancia de la clase FileInputStream que contiene el objeto file especificado que tiene que ser deserializado porque el constructor ObjectInputStream() necesita el flujo de entrada.

La serialización es el proceso de convertir un objeto Java en una matriz de bytes y luego de nuevo en objeto con su estado preservado. Útil para varias cosas como enviar objetos a través de la red o almacenar cosas en caché en el disco.

Lee más de este breve artículo que explica bastante bien la parte de programación del procesoy luego pasa a Serializable javadoc. También puede interesarle leer esta pregunta relacionada.

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

Java Serialización De Objetos

Serialization es un mecanismo para transformar un gráfico de objetos Java en una matriz de bytes para el almacenamiento(to disk file) o transmisión(across a network), luego mediante el uso de deserialización podemos restaurar el gráfico de objetos. Los gráficos de los objetos se restauran correctamente utilizando un mecanismo de intercambio de referencias. Pero antes de almacenar, compruebe si serialVersionUID de input-file / network y .archivo de clase serialVersionUID son los mismos. Si no, lanza un java.io.InvalidClassException.

Cada clase versionada debe identificar la versión original de la clase para la cual es capaz de escribir flujos y de la cual puede leer. Por ejemplo, una clase versionada debe declarar:

SerialVersionUID Sintaxis

// 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 a serialVersionUID no está incluido, 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 puede resultar en conflictos inesperados serialVersionUID durante la deserialización, causando deserialización a fallar.

Inspección de clases serializables

Un objeto Java solo es serializable. si una clase o de cualquiera de sus superclases implementa el java.io.Serializable interfaz o su subinterface, java.io.Externalizable.

• Una clase debe implementar java.io.Serializable interfaz para serializar su objeto con éxito. Serializable es un marcador interfaz y se utiliza para informar al compilador que la clase que lo implementa tiene que ser añadido comportamiento serializable. Aquí Java Virtual Machine (JVM) es responsable de su serialización automática.

  Palabra Clave Transitoria: java.io.Serializable interface

  Al serializar un objeto, si no queremos que ciertos miembros de datos del objeto sean serializados, podemos usar el modificador transitorio. La palabra clave transient evitará que ese miembro de datos sea serializado.

  • Los campos declarados como transitorios o estáticos son ignorados por el proceso de serialización.

  TRANSITORIOS & 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.
  }
  

• La implementación de la interfaz externalizable permite al objeto asumir 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 son implementados por una clase pueden escribir y leer su propio estado usando todos los métodos de ObjectOutput y ObjectInput. Es responsabilidad de los objetos manejar cualquier control de versiones 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 soportan la interfaz java.io.Serializable o java.io.Externalizable pueden ser written to/read from corrientes. La clase de cada objeto serializable está codificada incluyendo el nombre y la firma de la clase, los valores de los campos y matrices del objeto, y el cierre de cualquier otro objeto al que se haga referencia desde los objetos iniciales.

Ejemplo Serializable Para Files

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 Sobre Red

Distribuir el estado de object a través de diferentes espacios de direcciones, ya sea en diferentes procesos en el mismo equipo, o incluso en varios equipos conectados a través de una red, pero que trabajan juntos compartiendo datos e invocando método.

• Clasificación de datos
• Talones y 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();
    }
}

@ver

• implementando Serializable vs Externalizable

|*| Serialización de una clase : Conversión de un objeto a bytes y bytes de vuelta a objeto (Deserialización).

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

|=> Objeto-Serialización es el proceso de convertir el estado de un objeto en vapor de bytes.

• | -> Implementar cuando desee que el objeto exista más allá de la vida útil de la JVM.
  
• | -> El objeto serilizado se puede almacenar en la base de datos.
  
• / - > Serializable-los obectos no pueden ser leídos y entendidos por los humanos para que podamos seguridad.
  

|=> Deserialización de objetos es el proceso de obtener el estado de un objeto y almacenarlo en un objeto(java.lang.Objeto).

• / - > Antes de almacenar su estado, compruebe el tiempo serialVersionUID form input-file / network and.los archivos de clase serialVersionUID son los mismos.
  &nbsp&nbspIf no tirar de java.io.InvalidClassException.
  

/ = > Un objeto Java solo es serializable, si su clase o cualquiera de sus superclases

• implementa la interfaz java.io.Serializable o
  
• su subinterfaz, java. io. Externalizable.
  

|=> Los campos estáticos en una clase no pueden ser serializados.

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 entonces 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,
NotSerializableException se lanza en tiempo de ejecución.

Java proporciona un mecanismo, llamado serialización de objetos, donde un objeto puede ser representado como una secuencia de bytes que incluye los datos del objeto, así como información sobre el tipo del objeto y los tipos de datos almacenados en el objeto. Se utiliza principalmente para viajar el estado del objeto en la red (conocido como marshaling).