Manfaat menggunakan Parcelable daripada membuat serialisasi objek

Seperti yang saya pahami, Bundledan Parcelabletermasuk cara Android melakukan serialisasi masuk Ini digunakan misalnya dalam melewatkan data di antara aktivitas. Tapi saya bertanya-tanya, apakah ada manfaat dalam menggunakan Parcelabledaripada serialisasi klasik dalam kasus menyimpan keadaan objek bisnis saya ke memori internal misalnya? Akankah lebih sederhana atau lebih cepat dari cara klasik? Di mana saya harus menggunakan serialisasi klasik dan di mana lebih baik menggunakan bundel?

Dari "Pro Android 2"

CATATAN: Melihat Parcelable mungkin telah memicu pertanyaan, mengapa Android tidak menggunakan mekanisme serialisasi Java bawaan? Ternyata tim Android sampai pada kesimpulan bahwa serialisasi di Java terlalu lambat untuk memenuhi persyaratan komunikasi antarproses Android. Jadi tim membuat solusi Parcelable. Pendekatan Parcelable mengharuskan Anda secara eksplisit membuat serial anggota kelas Anda, tetapi pada akhirnya, Anda mendapatkan serialisasi objek yang jauh lebih cepat.

Sadarilah juga bahwa Android menyediakan dua mekanisme yang memungkinkan Anda meneruskan data ke proses lain. Yang pertama adalah meneruskan bundel ke aktivitas menggunakan maksud, dan yang kedua adalah meneruskan Parcelable ke layanan. Kedua mekanisme ini tidak dapat dipertukarkan dan tidak boleh disalahartikan. Artinya, Parcelable tidak dimaksudkan untuk diteruskan ke suatu aktivitas. Jika Anda ingin memulai aktivitas dan meneruskan beberapa data, gunakan paket. Parcelable dimaksudkan untuk digunakan hanya sebagai bagian dari definisi AIDL.

Serializablesangat lambat di Android. Pada kenyataannya, garis batas tidak berguna dalam banyak kasus.

Parceldan Parcelablesangat cepat, tetapi dokumentasinya mengatakan Anda tidak boleh menggunakannya untuk serialisasi tujuan umum ke penyimpanan, karena penerapannya bervariasi dengan versi Android yang berbeda (misalnya, pembaruan OS dapat merusak aplikasi yang mengandalkannya).

Solusi terbaik untuk masalah serialisasi data ke penyimpanan dengan kecepatan yang wajar adalah menggulung sendiri. Saya pribadi menggunakan salah satu kelas utilitas saya sendiri yang memiliki antarmuka yang mirip Parceldan yang dapat membuat serialisasi semua tipe standar dengan sangat efisien (dengan mengorbankan keamanan tipe). Berikut adalah versi ringkasannya:

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++;
        }
    }

}

Lihat seberapa cepat Parcelable daripada Serializable.

dari WHY WE LOVE PARCELABLE

dari Parcelable vs Serializable

Jika Anda membutuhkan serialisasi untuk keperluan penyimpanan tetapi ingin menghindari penalti kecepatan refleksi yang disebabkan oleh antarmuka Serializable Anda harus secara eksplisit membuat protokol serialisasi Anda sendiri dengan antarmuka Eksternalizable .

Ketika diterapkan dengan benar, ini cocok dengan kecepatan Parcelable dan juga memperhitungkan kompatibilitas antara berbagai versi Android dan / atau platform Java.

Artikel ini mungkin juga menjelaskan semuanya:

Apa perbedaan antara Serializable dan Externalizable di Java?

Pada catatan samping, ini juga merupakan teknik serialisasi tercepat dalam banyak tolok ukur, mengalahkan Kryo, Avro, Protocol Buffer dan Jackson (json):

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

Tampaknya saat ini perbedaannya tidak begitu mencolok, setidaknya tidak ketika Anda menjalankannya di antara aktivitas Anda sendiri.

Menurut tes yang ditampilkan di situs web ini , Parcelable sekitar 10 kali lebih cepat pada perangkat terbaru (seperti nexus 10), dan 17 lebih cepat pada perangkat lama (seperti keinginan Z)

jadi terserah Anda untuk memutuskan apakah itu sepadan.

mungkin untuk kelas yang relatif kecil dan sederhana, Serializable baik-baik saja, dan selebihnya, Anda harus menggunakan Parcelable

Parcelable terutama terkait dengan IPC menggunakan infrastruktur Binder , di mana data diteruskan sebagai Paket .

Karena Android sangat bergantung pada Binder untuk sebagian besar, jika tidak semua, tugas IPC, masuk akal untuk mengimplementasikan Parcelable di sebagian besar tempat, dan terutama di framework, karena memungkinkan untuk meneruskan objek ke proses lain jika Anda membutuhkannya. Itu membuat objek "bisa diangkut".

Tetapi jika Anda memiliki lapisan bisnis non-Android khusus yang secara ekstensif menggunakan serializable untuk menyimpan status objek, dan hanya perlu menyimpannya ke sistem file, maka saya pikir serializable itu baik-baik saja. Ini memungkinkan untuk menghindari kode pelat boiler Parcelable.

Berdasarkan artikel ini http://www.mooproductions.org/node/6?page=5 Parcelable seharusnya lebih cepat.

Tidak disebutkan dalam artikel, adalah bahwa saya tidak berpikir bahwa objek serializable akan bekerja di AIDL untuk layanan jarak jauh.

Saya hanya menggunakan GSON -> Serialise to JSON String -> Restore Object dari JSON String.

Parcelable juga menawarkan implementasi kustom di mana pengguna mendapat kesempatan untuk membagi setiap objeknya dengan menimpa writeToParcel (), Namun serialisasi tidak menerapkan kustomisasi ini karena caranya meneruskan data melibatkan API refleksi JAVA.