Benefício de usar Parcelable em vez de serializar o objeto

Pelo que entendi, Bundlee Parcelablepertence à forma como o Android realiza a serialização. É usado, por exemplo, na passagem de dados entre atividades. Mas eu me pergunto, se há algum benefício em usar em Parcelablevez da serialização clássica no caso de salvar o estado dos meus objetos de negócios na memória interna, por exemplo? Será mais simples ou mais rápido do que a forma clássica? Onde devo usar a serialização clássica e onde melhor usar bundles?

De "Pro Android 2"

NOTA: Ver Parcelable pode ter gerado a pergunta, por que o Android não está usando o mecanismo de serialização Java integrado? Acontece que a equipe do Android chegou à conclusão de que a serialização em Java é muito lenta para satisfazer os requisitos de comunicação entre processos do Android. Portanto, a equipe construiu a solução Parcelable. A abordagem Parcelable requer que você serialize explicitamente os membros de sua classe, mas, no final, você obtém uma serialização muito mais rápida de seus objetos.

Perceba também que o Android fornece dois mecanismos que permitem que você passe dados para outro processo. O primeiro é passar um pacote para uma atividade usando um intent, e o segundo é passar um Parcelable para um serviço. Esses dois mecanismos não são intercambiáveis ​​e não devem ser confundidos. Ou seja, o Parcelable não se destina a ser passado para uma atividade. Se você deseja iniciar uma atividade e passar alguns dados, use um pacote. Parcelable deve ser usado apenas como parte de uma definição AIDL.

Serializableé comicamente lento no Android. Limite inútil em muitos casos, na verdade.

Parcele Parcelablesão fantasticamente rápidos, mas sua documentação diz que você não deve usá-lo para serialização de propósito geral para armazenamento, uma vez que a implementação varia com diferentes versões do Android (ou seja, uma atualização de sistema operacional pode quebrar um aplicativo que dependia dele).

A melhor solução para o problema de serialização de dados para armazenamento em uma velocidade razoável é rolar o seu próprio. Eu pessoalmente uso uma de minhas próprias classes de utilitário que tem uma interface semelhante Parcele que pode serializar todos os tipos padrão de forma muito eficiente (às custas da segurança de tipo). Aqui está uma versão resumida disso:

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

}

Ver o quão rápido Parcelable é que Serializable.

de POR QUE AMAMOS PARCELÁVEL

de Parcelable vs Serializable

Se você precisa de serialização para fins de armazenamento, por exemplo, mas deseja evitar a penalidade de velocidade de reflexão incorrida pela interface serializável , você deve criar explicitamente seu próprio protocolo de serialização com a interface externalizável .

Quando implementado corretamente, ele corresponde à velocidade do Parcelable e também leva em conta a compatibilidade entre as diferentes versões do Android e / ou da plataforma Java.

Este artigo também pode esclarecer as coisas:

Qual é a diferença entre Serializable e Externalizable em Java?

Em uma nota lateral, também é a técnica de serialização mais rápida em muitos benchmarks, vencendo Kryo, Avro, Protocol Buffers e Jackson (json):

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

Parece que hoje em dia a diferença não é tão perceptível, pelo menos não quando você o executa entre suas próprias atividades.

De acordo com os testes mostrados neste site , o Parcelable é cerca de 10 vezes mais rápido nos dispositivos mais novos (como o Nexus 10) e cerca de 17 vezes mais rápido nos antigos (como o wish Z)

então cabe a você decidir se vale a pena.

talvez para classes relativamente pequenas e simples, Serializable é bom, e para o resto, você deve usar Parcelable

Parcelable está principalmente relacionado ao IPC usando a infraestrutura Binder , onde os dados são passados ​​como Parcels .

Como o Android depende muito do Binder para a maioria, senão todas, as tarefas IPC, faz sentido implementar Parcelable na maioria dos lugares, e especialmente na estrutura, porque permite passar um objeto para outro processo, se necessário. Torna os objetos "transportáveis".

Mas se você tiver uma camada de negócios não específica do Android que usa extensivamente serializáveis ​​para salvar estados de objeto e só precisa armazená-los no sistema de arquivos, então acho que serializável está bem. Permite evitar o código Parcelable Boiler-plate.

Com base neste artigo http://www.mooproductions.org/node/6?page=5 Parcelable deve ser mais rápido.

O que não foi mencionado no artigo é que não acho que objetos serializáveis ​​funcionarão em AIDL para serviços remotos.

Eu apenas uso GSON -> Serializar para String JSON -> Restaurar Objeto da String JSON.

Além disso, Parcelable oferece implementação customizada em que o usuário tem a chance de particionar cada um de seus objetos substituindo writeToParcel (). No entanto, a serialização não faz essa implementação customizada, pois sua maneira de passar dados envolve a API de reflexão JAVA.