java - usar - tipos de serializacion

Objeto Serializable de Java a Byte Array

Question

Digamos que tengo una clase serializable AppMessage .

Me gustaría transmitirlo como byte[] través de sockets a otra máquina donde se reconstruye a partir de los bytes recibidos.

¿Cómo podría lograr esto?

Answer 1

Me gustaría transmitirlo como byte [] sobre sockets a otra máquina

// When you connect
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
// When you want to send it
oos.writeObject(appMessage);

donde se reconstruye a partir de los bytes recibidos.

// When you connect
ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
// When you want to receive it
AppMessage appMessage = (AppMessage)ois.readObject();

Answer 2

La mejor manera de hacerlo es usar SerializationUtils de Apache Commons Lang .

Para serializar:

byte[] data = SerializationUtils.serialize(yourObject);

Para deserializar:

YourObject yourObject = SerializationUtils.deserialize(data)

Como se mencionó, esto requiere la biblioteca Commons Lang. Se puede importar utilizando Gradle:

compile ''org.apache.commons:commons-lang3:3.5''

Maven

<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.5</version>
</dependency>

Archivo jar

Y más maneras mencionadas here

Alternativamente, toda la colección puede ser importada. Consulte este enlace

Answer 3

Preparar bytes para enviar:

ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutput out = null;
try {
out = new ObjectOutputStream(bos);
out.writeObject(yourObject);
out.flush();
byte[] yourBytes = bos.toByteArray();
...
} finally {
try {
bos.close();
} catch (IOException ex) {
// ignore close exception
}
}

Crear objeto a partir de bytes:

ByteArrayInputStream bis = new ByteArrayInputStream(yourBytes);
ObjectInput in = null;
try {
in = new ObjectInputStream(bis);
Object o = in.readObject();
...
} finally {
try {
if (in != null) {
in.close();
}
} catch (IOException ex) {
// ignore close exception
}
}

Answer 4

Se puede realizar mediante SerializationUtils , mediante el método de serialización y deserialización de ApacheUtils para convertir el objeto en byte [] y viceversa, como se indica en @uris answer.

Para convertir un objeto a byte [] mediante la serialización:

byte[] data = SerializationUtils.serialize(object);

Para convertir el byte [] en objeto deserializando ::

Object object = (Object) SerializationUtils.deserialize(byte[] data)

Haga clic en el enlace para descargar org-apache-commons-lang.jar

Integrar el archivo .jar haciendo clic en:

Nombre de archivo -> Abrir configuración de Medule -> Seleccione su módulo -> Dependencias -> Agregar archivo Jar y listo.

Espero que esto ayude .

Answer 5

Si usa Java> = 7, podría mejorar la solución aceptada usando try with resources :

private byte[] convertToBytes(Object object) throws IOException {
try (ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutput out = new ObjectOutputStream(bos)) {
out.writeObject(object);
return bos.toByteArray();
}
}

Y a la inversa:

private Object convertFromBytes(byte[] bytes) throws IOException, ClassNotFoundException {
try (ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
ObjectInput in = new ObjectInputStream(bis)) {
return in.readObject();
}
}

Answer 6

También recomiendo usar la herramienta SerializationUtils. Quiero hacer un ajuste en un comentario equivocado por @Abilash. El método SerializationUtils.serialize() no está restringido a 1024 bytes, a diferencia de otra respuesta aquí.

public static byte[] serialize(Object object) {
if (object == null) {
return null;
}
ByteArrayOutputStream baos = new ByteArrayOutputStream(1024);
try {
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(object);
oos.flush();
}
catch (IOException ex) {
throw new IllegalArgumentException("Failed to serialize object of type: " + object.getClass(), ex);
}
return baos.toByteArray();
}

A primera vista, puede pensar que el new ByteArrayOutputStream(1024) solo permitirá un tamaño fijo. Pero si observa detenidamente ByteArrayOutputStream , descubrirá que la secuencia crecerá si es necesario:

Esta clase implementa un flujo de salida en el que los datos se escriben en una matriz de bytes. El búfer crece automáticamente a medida que se escriben los datos en él. Los datos se pueden recuperar utilizando toByteArray() y toString() .