Nutzen Sie die Verwendung von Parcelable anstelle der Serialisierung von Objekten

Soweit ich weiß, gehört es zur Art Bundleund ParcelableWeise, wie Android die Serialisierung durchführt. Es wird beispielsweise zum Übertragen von Daten zwischen Aktivitäten verwendet. Ich frage mich jedoch, ob die Verwendung Parcelableanstelle der klassischen Serialisierung Vorteile bietet, wenn beispielsweise der Status meiner Geschäftsobjekte im internen Speicher gespeichert wird. Wird es einfacher oder schneller sein als der klassische Weg? Wo soll ich klassische Serialisierung verwenden und wo besser Bundles verwenden?

Von "Pro Android 2"

HINWEIS: Das Anzeigen von Parcelable hat möglicherweise die Frage ausgelöst, warum Android den integrierten Java-Serialisierungsmechanismus nicht verwendet. Es stellt sich heraus, dass das Android-Team zu dem Schluss gekommen ist, dass die Serialisierung in Java viel zu langsam ist, um die Interprozess-Kommunikationsanforderungen von Android zu erfüllen. Also baute das Team die Paketlösung. Der Parcelable-Ansatz erfordert, dass Sie die Mitglieder Ihrer Klasse explizit serialisieren. Am Ende erhalten Sie jedoch 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 Bündel mit einer Absicht an eine Aktivität zu übergeben, und die zweite darin, ein Paket an einen Dienst zu übergeben. Diese beiden Mechanismen sind nicht austauschbar und sollten nicht verwechselt werden. Das heißt, das Paket soll nicht an eine Aktivität weitergegeben werden. Wenn Sie eine Aktivität starten und einige Daten übergeben möchten, verwenden Sie ein Bundle. Parcelable darf nur als Teil einer AIDL-Definition verwendet werden.

Serializableist komisch langsam auf Android. Borderline in vielen Fällen sogar nutzlos.

Parcelund Parcelablesind fantastisch schnell, aber seine Dokumentation besagt, dass Sie es nicht für die allgemeine Serialisierung zum Speicher verwenden dürfen, da die Implementierung je nach Android-Version unterschiedlich ist (dh ein Betriebssystem-Update kann eine App beschädigen, die darauf angewiesen ist).

Die beste Lösung für das Problem, Daten mit einer angemessenen Geschwindigkeit in den Speicher zu serialisieren, besteht darin, Ihre eigenen Daten zu rollen. Ich persönlich verwende eine meiner eigenen Utility-Klassen, die eine ähnliche Schnittstelle hat Parcelund alle Standardtypen sehr effizient serialisieren kann (auf Kosten der Typensicherheit). 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 Parcelable als Serializable ist.

von WARUM WIR PAKETBAR LIEBEN

von Parcelable vs Serializable

Wenn Sie eine Serialisierung für Speicherzwecke benötigen, aber den Geschwindigkeitsverlust der Reflexion durch die serialisierbare Schnittstelle vermeiden möchten, sollten Sie explizit Ihr eigenes Serialisierungsprotokoll mit der externisierbaren Schnittstelle erstellen.

Bei ordnungsgemäßer Implementierung entspricht dies der Geschwindigkeit von Parcelable und berücksichtigt auch die Kompatibilität zwischen verschiedenen Versionen von Android und / oder der Java-Plattform.

Dieser Artikel könnte auch Dinge klären:

Was ist der Unterschied zwischen Serializable und Externalizable in Java?

Nebenbei bemerkt, es ist 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 heutzutage der Unterschied nicht so auffällig ist, zumindest nicht, wenn Sie ihn zwischen Ihren eigenen Aktivitäten ausführen.

Laut den auf dieser Website gezeigten Tests ist Parcelable auf den neuesten Geräten (wie Nexus 10) etwa 10-mal schneller und auf alten Geräten (wie Wunsch Z) etwa 17-mal schneller.

Es liegt also an Ihnen, zu entscheiden, ob es sich lohnt.

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 der Binder- Infrastruktur, bei der Daten als Pakete übergeben werden .

Da Android für die meisten, wenn nicht alle IPC-Aufgaben stark auf Binder angewiesen ist, ist es sinnvoll, Parcelable an den meisten Stellen und insbesondere im Framework zu implementieren, da Sie bei Bedarf ein Objekt an einen anderen Prozess übergeben können. Es macht Objekte "transportabel".

Wenn Sie jedoch eine nicht Android-spezifische Geschäftsschicht haben, die häufig serialisierbare Dateien zum Speichern von Objektzuständen verwendet und diese nur im Dateisystem speichern muss, ist die serialisierbare Funktion meiner Meinung nach in Ordnung. Dadurch kann der Code für die Paketkesselplatte vermieden werden.

Basierend auf diesem Artikel http://www.mooproductions.org/node/6?page=5 Parcelable schneller sein.

In diesem Artikel wird nicht erwähnt, dass ich nicht denke, dass serialisierbare Objekte in AIDL für Remotedienste funktionieren.

Ich verwende nur GSON -> Serialisieren in JSON-Zeichenfolge -> Objekt aus JSON-Zeichenfolge wiederherstellen.

Parcelable bietet auch eine benutzerdefinierte Implementierung, bei der der Benutzer die Möglichkeit erhält, jedes seiner Objekte durch Überschreiben von writeToParcel () zu parzellieren. Bei der Serialisierung wird diese benutzerdefinierte Implementierung jedoch nicht verwendet, da die Datenübergabe eine JAVA-Reflektions-API umfasst.