sérialisation tout objet

Question

J'ai essayé de faire ceci:

ByteArrayOutputStream b = new ByteArrayOutputStream(); 
ObjectOutputStream o = new ObjectOutputStream(b); 
o.writeObject(obj); 

Où obj est une classe simple j'ai fait:

class Car { 
    int id; 
    String color; 
    //... 
} 

Cependant, je reçois java.io.NotSerializableException

Est-il possible de sérialisation à peu près tout sorte de java.lang.Object en byte array? Est-ce le cas, comment?

Mise à jour:

La classe qui sera "sérialisé" ne met pas en œuvre une interface Serializable; l'idée derrière ce que je suis en train de faire est que je suis en train d'avoir un Databse adossés à des créances java.util.Map où des objets put sur la carte sont stockées directement dans la base de données, donc toute sorte de Object

J'ai aussi vu quelques-uns cadre de sérialisation, où contourner cette « limitation » sérialisation objet arbitraire, il y a une inscription de classe comme:

kryo.register(SomeClass.class, 0); 

Je ne sais pas à ce sujet.

Mais ce que je suis tout à fait sûr que je dois faire:

• Réflexion lire les champs et les méthodes d'un objet

Answer 1

Votre Car classe a besoin d'implémenter l'interface Serializable pour vous pour être en mesure de Serialize votre objet.

class Car implements Serializable { 

Answer 2

vient ici ObjectSerializer générique pour linéariser/désérialiser (adapté de libs Apache):

public class ObjectSerializer { 

    private static final String TAG = "ObjectSerializer"; 

    public static String serialize(Serializable obj) {// throws IOException { 
     if (obj == null) return ""; 
     try { 
      ByteArrayOutputStream serialObj = new ByteArrayOutputStream(); 
      ObjectOutputStream objStream = new ObjectOutputStream(serialObj); 
      objStream.writeObject(obj); 
      objStream.close(); 
      return encodeBytes(serialObj.toByteArray()); 
     } catch (Exception e) { 
      //throw WrappedIOException.wrap("Serialization error: " + e.getMessage(), e); 
      Log.e(TAG, "Serialization error: " + e.getMessage()); 
      return null; 
     } 
    } 

    public static Object deserialize(String str) {// throws IOException { 
     if (str == null || str.length() == 0) return null; 
     try { 
      ByteArrayInputStream serialObj = new ByteArrayInputStream(decodeBytes(str)); 
      ObjectInputStream objStream = new ObjectInputStream(serialObj); 
      return objStream.readObject(); 
     } catch (Exception e) { 
      //throw WrappedIOException.wrap("Deserialization error: " + e.getMessage(), e); 
      Log.e(TAG, "Deserialization error: " + e.getMessage()); 
      return null; 
     } 
    } 

    public static String encodeBytes(byte[] bytes) { 
     StringBuffer strBuf = new StringBuffer(); 

     for (int i = 0; i < bytes.length; i++) { 
      strBuf.append((char) (((bytes[i] >> 4) & 0xF) + ((int) 'a'))); 
      strBuf.append((char) (((bytes[i]) & 0xF) + ((int) 'a'))); 
     } 

     return strBuf.toString(); 
    } 

    public static byte[] decodeBytes(String str) { 
     byte[] bytes = new byte[str.length()/2]; 
     for (int i = 0; i < str.length(); i+=2) { 
      char c = str.charAt(i); 
      bytes[i/2] = (byte) ((c - 'a') << 4); 
      c = str.charAt(i+1); 
      bytes[i/2] += (c - 'a'); 
     } 
     return bytes; 
    } 

} 

Answer 3

Il est impossible d'utiliser un java.io.ObjectOutputStream pour sérialiser chaque Object.

De la javadoc de ObjectOutputStream

Seuls les objets qui prennent en charge l'interface java.io.Serializable peut être écrit aux cours d'eau.

Si vous avez absolument besoin d'objets Java, vous pouvez essayer la sérialisation kryo. Par défaut, il vous suffit de faire:

Kryo kryo = new Kryo(); 
// ... 
Output output = new Output(new FileOutputStream("file.bin")); 
SomeClass someObject = ... 
kryo.writeObject(output, someObject); 
output.close(); 

Kryo ne nécessite pas vos cours pour mettre en œuvre Serializable et vous pouvez fournir Serializer séparé pour vos classes pour contrôler la forme de sérialisation. Mais est facultatif.

Le code kryo.register(SomeClass.class, 0); est optionnel aussi, il optimise le processus de sérialisation.