Nesneyi serileştirmek yerine Parcelable kullanmanın faydası

Anladığım kadarıyla Bundleve ParcelableAndroid'in serileştirmeyi gerçekleştirme şekline aittir. Örneğin aktiviteler arasında veri geçişinde kullanılır. Ama merak ediyorum, Parcelablemesela iş nesnelerimin durumunu dahili belleğe kaydetme durumunda klasik serileştirme yerine kullanmanın bir faydası var mı? Klasik yoldan daha basit mi yoksa daha hızlı mı olacak? Klasik serileştirmeyi nerede ve paketleri daha iyi nerede kullanmalıyım?

"Pro Android 2" den

NOT: Parcelable'ı görmek soruyu tetiklemiş olabilir, Android neden yerleşik Java serileştirme mekanizmasını kullanmıyor? Android ekibinin, Java'daki serileştirmenin Android'in işlemler arası iletişim gereksinimlerini karşılamak için çok yavaş olduğu sonucuna vardıkları ortaya çıktı. Böylece ekip Parcelable çözümünü geliştirdi. Parcelable yaklaşımı, sınıfınızın üyelerini açıkça serileştirmenizi gerektirir, ancak sonunda, nesnelerinizin çok daha hızlı serileştirilmesini elde edersiniz.

Ayrıca, Android'in verileri başka bir işleme aktarmanıza izin veren iki mekanizma sağladığını da unutmayın. Birincisi, bir amaç kullanarak bir aktiviteye bir paket geçirmek, ikincisi ise bir Parselable'ı bir hizmete geçirmektir. Bu iki mekanizma birbirinin yerine kullanılamaz ve karıştırılmamalıdır. Yani Parselable'ın bir aktiviteye aktarılması amaçlanmamıştır. Bir aktivite başlatmak ve bazı verileri aktarmak istiyorsanız, bir paket kullanın. Parcelable, yalnızca AIDL tanımının bir parçası olarak kullanılmak içindir.

SerializableAndroid'de komik bir şekilde yavaş. Aslında çoğu durumda sınırda işe yaramaz.

Parcelve Parcelablefevkalade hızlıdır, ancak dokümantasyonu , Android'in farklı sürümlerine göre uygulama değişiklik gösterdiğinden depolamaya genel amaçlı serileştirme için kullanmamanız gerektiğini söylüyor (yani bir işletim sistemi güncellemesi, ona güvenen bir uygulamayı bozabilir).

Verileri makul bir hızda depolamaya serileştirme sorunu için en iyi çözüm, kendi çözümünüzü almaktır. Ben şahsen, benzer bir arayüze sahip olan Parcelve tüm standart türleri çok verimli bir şekilde seri hale getirebilen (tip güvenliği pahasına) kendi yardımcı sınıflarımdan birini kullanıyorum . İşte bunun kısaltılmış bir versiyonu:

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

}

Parcelable'ın Serileştirilebilir'den ne kadar hızlı olduğunu görün .

dan NEDEN BİZ AŞK PARCELABLE

dan Parcelable Serializable'için vs

Eğer yani depolama amaçlı seri gerek ama uğradıkları yansıma hızı düşüşünden kaçınmak istiyorsanız Serializable'için açıkça kendi seri hale protokolünü oluşturmalısınız arayüzü Externalizable arayüzüne.

Düzgün uygulandığında, bu Parcelable'ın hızıyla eşleşir ve ayrıca Android ve / veya Java platformunun farklı sürümleri arasındaki uyumluluğu hesaba katar.

Bu makale de işleri netleştirebilir:

Java'da Serializable ve Externalizable arasındaki fark nedir?

Bir yandan da, birçok kıyaslamada en hızlı serileştirme tekniğidir, Kryo, Avro, Protocol Buffers ve Jackson'ı (json) yener:

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

Görünüşe göre bugünlerde fark o kadar da anlaşılmaz değil, en azından kendi faaliyetleriniz arasında çalıştırdığınızda.

Bu web sitesinde gösterilen testlere göre , Parcelable, en yeni cihazlarda (nexus 10 gibi) yaklaşık 10 kat daha hızlı ve eskilerde (arzu Z gibi) yaklaşık 17 kat daha hızlı.

bu yüzden buna değip değmeyeceğine karar vermek size kalmış.

belki nispeten küçük ve basit sınıflar için, Serializable iyidir ve geri kalanı için Parcelable'ı kullanmalısınız

Parcelable, verilerin Parseller olarak aktarıldığı Binder altyapısını kullanan IPC ile ilgilidir .

Android, IPC görevlerinin tümü olmasa da çoğu için Binder'a çok güvendiğinden, çoğu yerde ve özellikle çerçevede Parcelable'ı uygulamak mantıklıdır, çünkü buna ihtiyacınız olursa bir nesneyi başka bir işleme aktarmanıza izin verir. Nesneleri "taşınabilir" hale getirir.

Ancak, nesne durumlarını kaydetmek için yaygın olarak serileştirilebilirleri kullanan ve yalnızca dosya sisteminde depolamanız gereken, Android'e özgü olmayan bir iş katmanınız varsa, o zaman serileştirilebilirliğin iyi olduğunu düşünüyorum. Parcelable kazan plakası kodundan kaçınmaya izin verir.

Bu makaleye göre http://www.mooproductions.org/node/6?page=5 Parcelable daha hızlı olmalıdır.

Makalede bahsedilmeyen, serileştirilebilir nesnelerin uzak servisler için AIDL'de çalışacağını düşünmüyorum.

Sadece GSON -> JSON Dizgesine Seri Oluştur -> Nesneyi JSON Dizesinden Geri Yükle'yi kullanıyorum.

Ayrıca Parcelable, kullanıcının writeToParcel () 'i geçersiz kılarak nesnelerinin her birini paketleyebilme şansı elde ettiği özel bir uygulama sunar. Ancak, veri iletme yolu JAVA yansıma API'sini içerdiğinden serileştirme bu özel uygulamayı yapmaz.