cómo probar en Java que una clase implementa Serializable correctamente (no solo es una instancia de Serializable)

Question

Estoy implementando una clase para Serializable (por lo que es un objeto de valor para usar con RMI). Pero necesito probarlo. ¿Hay alguna manera de hacer esto fácilmente?

aclaración: Estoy implementando la clase, por lo que es trivial incluir Serializable en la definición de la clase. Necesito serializarlo/deserializarlo manualmente para ver si funciona.

He encontrado C# question, ¿hay alguna respuesta similar para Java?

Answer 1

La manera fácil es comprobar que el objeto es una instancia de java.io.Serializable o java.io.Externalizable, pero eso realmente no prueba que el objeto realmente es serializable.

La única manera de estar seguro es probarlo de verdad. La prueba más simple es algo así como:

new ObjectOutputStream(new ByteArrayOutputStream()).writeObject(myObject); 

y compruebe que no arroja una excepción.

Apache Commons Lang proporciona una versión bastante más breve:

SerializationUtils.serialize(myObject); 

y otra vez, la verificación de la excepción.

Usted puede ser más riguroso aún, y comprobar que deserializa de nuevo en algo igual a la original:

Serializable original = ... 
Serializable copy = SerializationUtils.clone(original); 
assertEquals(original, copy); 

y así sucesivamente.

Answer 2

Usted puede hacer siguiente prueba:

• objeto Serialize para presentar y hacer de que ninguna excepción.
• Además, deserializar el objeto y comparar con el objeto original.

Aquí es ejemplo para serializar y deserializar objetos de archivo:

http://www.rgagnon.com/javadetails/java-0075.html

http://www.javapractices.com/topic/TopicAction.do?Id=57

Answer 3

La respuesta corta es, uno se puede topar con algunos objetos candidatos y en realidad tratar de serializarlos usando el mecanismo de tu elección. La prueba aquí es que no se encuentran errores durante el marshalling/unmarshalling, y que el objeto resultante "rehidratado" es igual al original.

Alternativamente, si no tiene ningún objeto candidato, podría implementar una prueba basada en la reflexión que introspeccione los campos (no estáticos, no transitorios) de su clase para asegurarse de que también sean serializables. Hablando desde la experiencia, esto se vuelve sorprendentemente complejo sorprendentemente rápido, pero se puede hacer en una medida razonable.

La desventaja de este último enfoque es que si un campo es, por ejemplo, List<String>, entonces puede fallar la clase por no tener un campo estrictamente serializable, o simplemente asumir que se utilizará una implementación serializable de List. Ninguno de los dos es perfecto.(Tenga en cuenta que el último problema existe también para ejemplos: si cada ejemplo utilizado en la prueba utiliza listas serializables, no hay nada que impida que una versión no serializable sea utilizada por algún otro código en la práctica).

Answer 4

Este código debe hacerlo ... métodos

import java.io.ByteArrayOutputStream; 
import java.io.Externalizable; 
import java.io.IOException; 
import java.io.ObjectOutputStream; 
import java.io.OutputStream; 
import java.io.Serializable; 

public class Main 
{ 
    public static void main(String[] args) 
    { 
     System.out.println(isSerializable("Hello")); 
     System.out.println(isSerializable(new Main())); 
    } 

    public static boolean isSerializable(final Object o) 
    { 
     final boolean retVal; 

     if(implementsInterface(o)) 
     { 
      retVal = attemptToSerialize(o); 
     } 
     else 
     { 
      retVal = false; 
     } 

     return (retVal); 
    } 

    private static boolean implementsInterface(final Object o) 
    { 
     final boolean retVal; 

     retVal = ((o instanceof Serializable) || (o instanceof Externalizable)); 

     return (retVal); 
    } 

    private static boolean attemptToSerialize(final Object o) 
    { 
     final OutputStream sink; 
     ObjectOutputStream stream; 

     stream = null; 

     try 
     { 
      sink = new ByteArrayOutputStream(); 
      stream = new ObjectOutputStream(sink); 
      stream.writeObject(o); 
      // could also re-serilalize at this point too 
     } 
     catch(final IOException ex) 
     { 
      return (false); 
     } 
     finally 
     { 
      if(stream != null) 
      { 
       try 
       { 
        stream.close(); 
       } 
       catch(final IOException ex) 
       { 
        // should not be able to happen 
       } 
      } 
     } 

     return (true); 
    } 
} 

Answer 5

de utilidad basado en la respuesta de skaffman:

private static <T extends Serializable> byte[] pickle(T obj) 
     throws IOException 
{ 
    ByteArrayOutputStream baos = new ByteArrayOutputStream(); 
    ObjectOutputStream oos = new ObjectOutputStream(baos); 
    oos.writeObject(obj); 
    oos.close(); 
    return baos.toByteArray(); 
} 

private static <T extends Serializable> T unpickle(byte[] b, Class<T> cl) 
     throws IOException, ClassNotFoundException 
{ 
    ByteArrayInputStream bais = new ByteArrayInputStream(b); 
    ObjectInputStream ois = new ObjectInputStream(bais); 
    Object o = ois.readObject(); 
    return cl.cast(o); 
} 

Answer 6

Esto sólo funciona para los objetos totalmente ocupadas, si necesita que los objetos compuestos en su objeto de nivel superior también son serializables, entonces no pueden ser nulos para que esta prueba sea válida, ya que la serialización/deserialización omite los objetos nulos