Vorteil der Verwendung von Parcelable anstelle der Serialisierung von Objekten

Wie ich es verstehe, Bundle und Parcelable gehört zu der Art und Weise, wie Android die Serialisierung durchführt. Sie wird beispielsweise zum Übergeben von Daten zwischen Aktivitäten verwendet. Aber ich frage mich, ob es irgendwelche Vorteile bei der Verwendung gibt Parcelable statt klassischer Serialisierung zum Beispiel beim Speichern des Zustands meiner Geschäftsobjekte im internen Speicher? Geht es einfacher oder schneller als der klassische Weg? Wo sollte ich die klassische Serialisierung einsetzen und wo besser Bundles?

Ab “Pro Android 2”

HINWEIS: Parcelable zu sehen, hat möglicherweise die Frage ausgelöst, warum Android nicht den integrierten Java-Serialisierungsmechanismus verwendet. Es stellte sich heraus, dass das Android-Team zu dem Schluss kam, dass die Serialisierung in Java viel zu langsam ist, um die Anforderungen von Android an die Kommunikation zwischen Prozessen zu erfüllen. Also baute das Team die Parcelable-Lösung. Der Parcelable-Ansatz erfordert, dass Sie die Mitglieder Ihrer Klasse explizit serialisieren, aber am Ende erhalten Sie eine viel schnellere Serialisierung Ihrer Objekte.

Beachten Sie auch, dass Android zwei Mechanismen bietet, mit denen Sie Daten an einen anderen Prozess übergeben können. Die erste besteht darin, ein Bundle mithilfe einer Absicht an eine Aktivität zu übergeben, und die zweite besteht darin, ein Parcelable an einen Dienst zu übergeben. Diese beiden Mechanismen sind nicht austauschbar und sollten nicht verwechselt werden. Das Parcelable soll also nicht an eine Aktivität übergeben werden. Wenn Sie eine Aktivität starten und ihr einige Daten übergeben möchten, verwenden Sie ein Bundle. Parcelable soll nur als Teil einer AIDL-Definition verwendet werden.

Serializable ist komisch langsam auf Android. In vielen Fällen sogar grenzwertig nutzlos.

Parcel und Parcelable sind fantastisch schnell, aber es ist Dokumentation sagt, dass Sie es nicht für die Allzweck-Serialisierung zum Speicher verwenden dürfen, da die Implementierung mit verschiedenen Android-Versionen variiert (dh ein Betriebssystem-Update könnte eine App beschädigen, die darauf angewiesen ist).

Die beste Lösung für das Problem, Daten mit angemessener Geschwindigkeit in den Speicher zu serialisieren, besteht darin, Ihre eigene zu erstellen. Ich persönlich verwende eine meiner eigenen Utility-Klassen, die eine ähnliche Schnittstelle zu hat Parcel und die alle Standardtypen sehr effizient serialisieren kann (auf Kosten der Typsicherheit). Hier ist eine gekürzte Version davon:

public interface Packageable {
    public void readFromPackage(PackageInputStream in)  throws IOException ;
    public void writeToPackage(PackageOutputStream out)  throws IOException ; 
}


public final class PackageInputStream {

    private DataInputStream input;

    public PackageInputStream(InputStream in) {
        input = new DataInputStream(new BufferedInputStream(in));
    }

    public void close() throws IOException {
        if (input != null) {
            input.close();
            input = null;
        }       
    }

    // Primitives
    public final int readInt() throws IOException {
        return input.readInt();
    }
    public final long readLong() throws IOException {
        return input.readLong();
    }
    public final long[] readLongArray() throws IOException {
        int c = input.readInt();
        if (c == -1) {
            return null;
        }
        long[] a = new long[c];
        for (int i=0 ; i<c ; i++) {
            a[i] = input.readLong();
        }
        return a;
    }

...

    public final String readString()  throws IOException {
        return input.readUTF();
    }
    public final <T extends Packageable> ArrayList<T> readPackageableList(Class<T> clazz) throws IOException {
        int N = readInt();
        if (N == -1) {
            return null;
        }
        ArrayList<T> list = new ArrayList<T>();
        while (N>0) {
            try {
                T item = (T) clazz.newInstance();
                item.readFromPackage(this);
                list.add(item);
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
            N--;
        }
        return list;
    }

}



public final class PackageOutputStream {

    private DataOutputStream output;

    public PackageOutputStream(OutputStream out) {
        output = new DataOutputStream(new BufferedOutputStream(out));
    }

    public void close() throws IOException {
        if (output != null) {
            output.close();
            output = null;
        }
    }

    // Primitives
    public final void writeInt(int val) throws IOException {
        output.writeInt(val);
    }
    public final void writeLong(long val) throws IOException {
        output.writeLong(val);
    }
    public final void writeLongArray(long[] val) throws IOException {
        if (val == null) {
            writeInt(-1);
            return;
        }
        writeInt(val.length);
        for (int i=0 ; i<val.length ; i++) {
            output.writeLong(val[i]);
        }
    }

    public final void writeFloat(float val) throws IOException {
        output.writeFloat(val);
    }
    public final void writeDouble(double val) throws IOException {
        output.writeDouble(val);
    }
    public final void writeString(String val) throws IOException {
        if (val == null) {
            output.writeUTF("");
            return;
        }
        output.writeUTF(val);
    }

    public final <T extends Packageable> void writePackageableList(ArrayList<T> val) throws IOException {
        if (val == null) {
            writeInt(-1);
            return;
        }
        int N = val.size();
        int i=0;
        writeInt(N);
        while (i < N) {
            Packageable item = val.get(i);
            item.writeToPackage(this);
            i++;
        }
    }

}

Sehen Sie, wie schnell Paketfähig ist als serialisierbar.

von WARUM WIR PAKETBAR LIEBEN

von Paketfähig vs. serialisierbar

Wenn Sie eine Serialisierung z. B. für Speicherzwecke benötigen, aber die Geschwindigkeitseinbußen durch Reflektion vermeiden möchten, die durch die entstehen Serialisierbar Schnittstelle sollten Sie explizit Ihr eigenes Serialisierungsprotokoll mit der erstellen Externalisierbar Schnittstelle.

Bei richtiger Implementierung entspricht dies der Geschwindigkeit von Parcelable und trägt auch zur Kompatibilität zwischen verschiedenen Versionen von Android und/oder der Java-Plattform bei.

Auch dieser Artikel könnte Klarheit schaffen:

Was ist der Unterschied zwischen Serialisierbar und Externalisierbar in Java?

Nebenbei bemerkt ist es auch die schnellste Serialisierungstechnik in vielen Benchmarks und schlägt Kryo, Avro, Protocol Buffers und Jackson (json):

http://code.google.com/p/thrift-protobuf-compare/wiki/Benchmarking

Es scheint, dass der Unterschied heutzutage nicht mehr so ​​​​bemerkbar ist, zumindest nicht, wenn Sie es zwischen Ihren eigenen Aktivitäten ausführen.

Gemäß Tests auf gezeigt Diese Internetseite Parcelable ist auf den neuesten Geräten (wie Nexus 10) etwa 10-mal schneller und auf alten Geräten (wie Desire Z) etwa 17-mal schneller.

ob es sich lohnt, musst du also selbst entscheiden.

Vielleicht ist Serializable für relativ kleine und einfache Klassen in Ordnung, und für den Rest sollten Sie Parcelable verwenden

Parcelable bezieht sich hauptsächlich auf IPC unter Verwendung von Bindemittel Infrastruktur, wo Daten weitergegeben werden Pakete.

Da Android für die meisten, wenn nicht alle IPC-Aufgaben stark auf Binder angewiesen ist, ist es an den meisten Stellen sinnvoll, Parcelable zu implementieren, insbesondere im Framework, da es die Übergabe eines Objekts an einen anderen Prozess ermöglicht, wenn Sie dies benötigen. Es macht Gegenstände „transportierbar“.

Aber wenn Sie eine nicht Android-spezifische Business-Schicht haben, die serialisierbare Objekte ausgiebig zum Speichern von Objektzuständen verwendet und sie nur im Dateisystem speichern muss, dann denke ich, dass serialisierbar ist. Es ermöglicht, den Boilerplate-Code Parcelable zu vermeiden.

Basierend auf diesem Artikel http://www.mooproductions.org/node/6?page=5
Paketfähig sollte schneller sein.

Nicht erwähnt in dem Artikel ist, dass ich nicht glaube, dass serialisierbare Objekte in AIDL für Remote-Dienste funktionieren werden.