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() .