java - serializar - ¿Qué significa Serializable?

serialización en netbeans

Question

¿Qué significa exactamente que una clase sea Serializable en Java? O en general, para el caso ...

Answer 1

Aunque la mayoría de los usuarios ya dieron la respuesta, me gustaría agregar un ejemplo para quienes lo necesitan para explicar la idea:

Supongamos que tiene una persona de clase como la siguiente:

public class Person implements java.io.Serializable {
/**
*
*/
private static final long serialVersionUID = 1L;
public String firstName;
public String lastName;
public int age;
public String address;
public void play() {
System.out.println(String.format(
"If I win, send me the trophy to this address: %s", address));
}
@Override
public String toString() {
return String.format(".....Person....../nFirst Name = %s/nLast Name = %s", firstName, lastName);
}
}

y luego creas un objeto como este:

Person william = new Person();
william.firstName = "William";
william.lastName = "Kinaan";
william.age = 26;
william.address = "Lisbon, Portugal";

Puede serializar ese objeto a muchas secuencias. Haré eso a dos corrientes:

Serialización a salida estándar:

public static void serializeToStandardOutput(Person person)
throws IOException {
OutputStream outStream = System.out;
ObjectOutputStream stdObjectOut = new ObjectOutputStream(outStream);
stdObjectOut.writeObject(person);
stdObjectOut.close();
outStream.close();
}

Serialización a un archivo:

public static void serializeToFile(Person person) throws IOException {
OutputStream outStream = new FileOutputStream("person.ser");
ObjectOutputStream fileObjectOut = new ObjectOutputStream(outStream);
fileObjectOut.writeObject(person);
fileObjectOut.close();
outStream.close();
}

Entonces:

Deserializar del archivo:

public static void deserializeFromFile() throws IOException,
ClassNotFoundException {
InputStream inStream = new FileInputStream("person.ser");
ObjectInputStream fileObjectIn = new ObjectInputStream(inStream);
Person person = (Person) fileObjectIn.readObject();
System.out.println(person);
fileObjectIn.close();
inStream.close();
}

Answer 2

La serialización es una técnica para almacenar o escribir los objetos y datos en los archivos. Mediante el uso de las clases ObjectOutputStream y FileOutputStream . Estas clases tienen sus métodos específicos para persistir en los objetos. como writeObject();

para una explicación clara con figuras. Vea aqui para mas informacion

Answer 3

La serialización implica guardar el estado actual de un objeto en una secuencia y restaurar un objeto equivalente desde esa secuencia. La secuencia funciona como un contenedor para el objeto

Answer 4

Para presentar desde otra perspectiva. La serialización es un tipo de interfaz llamada ''interfaz de marcador''. Una interfaz de marcador es una interfaz que no contiene declaraciones de métodos, sino que simplemente designa (o "marca") una clase que implementa la interfaz como si tuviera alguna propiedad. Si entiendes el polimorfismo, esto tendrá mucho sentido. En el caso de la interfaz de marcador Serializable, el método ObjectOutputStream.write (Object) fallará si su argumento no implementa la interfaz. Este es un error potencial en Java, podría haber sido ObjectOutputStream.write (Serializable)

Muy recomendable: leer el elemento 37 de Effective Java de Joshua Bloch para obtener más información.

Answer 5

Serializable se llama como una interfaz, pero es más como una bandera para el compilador. Dice que este objeto se puede guardar. Se guardarán todas las variables de instancia de Objetos, con la excepción de los objetos serializables y los que no lo sean.

Imagine que su aplicación puede cambiar de color como una opción, sin mantener esa configuración externa que necesitaría para cambiar el color cada vez que la ejecutó.

Answer 6

Significa que las instancias de la clase pueden convertirse en un byte-stream (por ejemplo, para guardarse en un archivo) y luego volver a convertirse en clases. Esta recarga podría ocurrir en una instancia diferente del programa, o incluso en una máquina diferente. Sin embargo, la serialización (en cualquier idioma) involucra todo tipo de problemas, especialmente cuando tiene referencias a otros objetos dentro del serial serializable.

Answer 7

Solo para agregar a las otras respuestas y con respecto a la generalidad. La serialización a veces se conoce como archivo, por ejemplo en Objective-C.

Answer 8

Serialization persiste en un objeto de la memoria a una secuencia de bits, por ejemplo, para guardar en el disco. La deserialización es lo opuesto: leer datos del disco para hidratar / crear un objeto.

En el contexto de su pregunta, es una interfaz que si se implementa en una clase, esta clase puede ser serializada y deserializada automáticamente por diferentes serializadores.

Answer 9

Aquí hay una explicación detallada de la serialización : (mi propio blog)

Publicación por entregas:

La serialización es el proceso de serialización del estado de un objeto que se representa y almacena en forma de una secuencia de bytes. Esto puede ser almacenado 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 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, puede transferirse 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 Serialization podemos recuperar el estado Object.

Ejemplo de código y explicación:

Primero echemos un vistazo a la clase de artículo:

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. Este número es calculado por el compilador basado en el estado de la clase y los atributos de clase. Este es el número que ayudará al jvm a identificar el estado de un objeto cuando lee el estado del objeto desde el archivo.

Para eso podemos echarle un vistazo a la Documentación oficial de Oracle:

El tiempo de ejecución de serialización asocia a cada clase serializable un número de versión, llamado serialVersionUID, que se utiliza durante la deserialización para verificar que el emisor y el receptor de un objeto serializado tengan clases cargadas para ese objeto que sean compatibles con la serialización. Si el receptor ha cargado una clase para el objeto que tiene un serialVersionUID diferente al de la clase del remitente correspondiente, la deserialización dará como resultado una InvalidClassException. Una clase serializable puede declarar su propio serialVersionUID explícitamente al declarar un campo llamado "serialVersionUID" que debe ser estático, final y de tipo long: ANY-ACCESS-MODIFIER static final serial serialVersionUID = 42L; Si una clase serializable no declara explícitamente un serialVersionUID, el tiempo de ejecución de serialización calculará un valor de serialVersionUID predeterminado para esa clase en función de varios aspectos de la clase, como se describe en la especificación de serialización de objetos de Java (TM). Sin embargo, se recomienda encarecidamente que todas las clases serializables declaren explícitamente los valores de serialVersionUID, ya que el cómputo serialVersionUID predeterminado es muy sensible a los detalles de clase que pueden variar dependiendo de las implementaciones del compilador, y puede dar como resultado inesperadas InvalidClassExceptions durante la deserialización. Por lo tanto, para garantizar un valor consistente de SerialVersionUID en diferentes implementaciones del compilador Java, una clase serializable debe declarar un valor serialVersionUID explícito. También se recomienda encarecidamente que las declaraciones explícitas de serialVersionUID usen el modificador privado siempre que sea posible, ya que tales declaraciones se aplican solo a la clase de declaración inmediata: los campos serialVersionUID no son útiles como miembros heredados.

Si ha notado que hay otra palabra clave que hemos usado que es transitoria .

Si un campo no es serializable, debe estar marcado como transitorio. Aquí marcamos el ítem CostoPrecio 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 léalo 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 fue escrito.

Answer 10

Serialización: escribir el estado del objeto en el archivo / red o en cualquier lugar. (Forma soportada por el objeto Java medio para el formulario compatible con el archivo o el formulario compatible con la red)

Deserialización: leer el estado del objeto desde un archivo / red o desde cualquier lugar. (Formulario soportado por medio de archivo / red compatible con Java Object Supported)