Mengapa Android menyediakan 2 antarmuka untuk objek bersambung? Apakah objek Serializable berinteraksi dengan Binderfile Android dan AIDL?

Di Android kita tidak bisa hanya meneruskan objek ke aktivitas. Untuk melakukan ini objek harus mengimplementasikan Serializableatau Parcelableantarmuka.

Serializable

Serializableadalah antarmuka Java standar. Anda bisa mengimplementasikan Serializableantarmuka dan menambahkan metode override. Masalah dengan pendekatan ini adalah refleksi digunakan dan prosesnya lambat. Metode ini menciptakan banyak objek sementara dan menyebabkan pengumpulan sampah yang cukup banyak. Namun, Serializableantarmuka lebih mudah diterapkan.

Lihat contoh di bawah ini (Serializable):

// MyObjects Serializable class

import java.io.Serializable;
import java.util.ArrayList;
import java.util.TreeMap;

import android.os.Parcel;
import android.os.Parcelable;

public class MyObjects implements Serializable {

    private String name;
    private int age;
    public ArrayList<String> address;

    public MyObjects(String name, int age, ArrayList<String> address) {
        super();
        this.name = name;
        this.age = age;
        this.address = address;
    }

    public ArrayList<String> getAddress() {
        if (!(address == null))
            return address;
        else
            return new ArrayList<String>();
    }

    public String getName() {
        return name;
    }

    public String getAge() {
        return age;
    }
}

// MyObjects instance
MyObjects mObjects = new MyObjects("name", "age", "Address array here");

// Passing MyObjects instance via intent
Intent mIntent = new Intent(FromActivity.this, ToActivity.class);
mIntent.putExtra("UniqueKey", mObjects);
startActivity(mIntent);

// Getting MyObjects instance
Intent mIntent = getIntent();
MyObjects workorder = (MyObjects)    mIntent.getSerializableExtra("UniqueKey");

Paket

Parcelableprosesnya jauh lebih cepat daripada Serializable. Salah satu alasan untuk ini adalah bahwa kita lebih eksplisit tentang proses serialisasi daripada menggunakan refleksi untuk menyimpulkannya. Ini juga masuk akal bahwa kode telah sangat dioptimalkan untuk keperluan ini.

Lihat contoh di bawah ini (Parcelable):

// MyObjects Parcelable class

import java.util.ArrayList;

import android.os.Parcel;
import android.os.Parcelable;

public class MyObjects implements Parcelable {

    private int age;
    private String name;
    private ArrayList<String> address;

    public MyObjects(String name, int age, ArrayList<String> address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    public MyObjects(Parcel source) {
        age = source.readInt();
        name = source.readString();
        address = source.createStringArrayList();
    }

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeInt(age);
        dest.writeString(name);
        dest.writeStringList(address);
    }

    public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }

    public ArrayList<String> getAddress() {
        if (!(address == null))
            return address;
        else
            return new ArrayList<String>();
    }

    public static final Creator<MyObjects> CREATOR = new Creator<MyObjects>() {
        @Override
        public MyObjects[] newArray(int size) {
            return new MyObjects[size];
        }

        @Override
        public MyObjects createFromParcel(Parcel source) {
            return new MyObjects(source);
        }
    };
}

// MyObjects instance
MyObjects mObjects = new MyObjects("name", "age", "Address array here");

// Passing MyOjects instance
Intent mIntent = new Intent(FromActivity.this, ToActivity.class);
mIntent.putExtra("UniqueKey", mObjects);
startActivity(mIntent);

// Getting MyObjects instance
Intent mIntent = getIntent();
MyObjects workorder = (MyObjects) mIntent.getParcelableExtra("UniqueKey");

Anda dapat melewati ArrayListobjek Parcelable seperti di bawah ini:

// Array of MyObjects
ArrayList<MyObjects> mUsers;

// Passing MyOjects instance
Intent mIntent = new Intent(FromActivity.this, ToActivity.class);
mIntent.putParcelableArrayListExtra("UniqueKey", mUsers);
startActivity(mIntent);

// Getting MyObjects instance
Intent mIntent = getIntent();
ArrayList<MyObjects> mUsers = mIntent.getParcelableArrayList("UniqueKey");

Kesimpulan

1. Parcelablelebih cepat dari Serializableantarmuka
2. Parcelableantarmuka membutuhkan waktu lebih lama untuk diimplementasikan dibandingkan dengan Serializableantarmuka
3. Serializable antarmuka lebih mudah diimplementasikan
4. Serializable antarmuka menciptakan banyak objek sementara dan menyebabkan sedikit pengumpulan sampah
5. Parcelable Array dapat dikirimkan melalui Intent di android

Serializable adalah antarmuka Java standar. Anda cukup menandai kelas Serializable dengan mengimplementasikan antarmuka, dan Java akan membuat serial secara otomatis dalam situasi tertentu.

Parcelable adalah antarmuka khusus Android tempat Anda mengimplementasikan sendiri serialisasi itu. Itu dibuat untuk menjadi jauh lebih efisien daripada Serializable, dan untuk mengatasi beberapa masalah dengan skema serialisasi Java default.

Saya percaya bahwa Binder dan AIDL berfungsi dengan objek Parcelable.

Namun, Anda bisa menggunakan objek Serializable di Intents.

Parcelable vs Serializable Saya merujuk keduanya.

Untuk Jawa dan Kotlin

1) Jawa

Serializable, Kesederhanaan

Apa itu Serializable?

Serializable adalah antarmuka Java standar. Ini bukan bagian dari SDK Android. Kesederhanaannya adalah keindahannya. Hanya dengan mengimplementasikan antarmuka ini, POJO Anda akan siap untuk beralih dari satu Kegiatan ke Kegiatan lainnya.

public class TestModel implements Serializable {

String name;

public TestModel(String name) {
    this.name = name;
}

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}
}

• Keindahan serializable adalah Anda hanya perlu mengimplementasikan antarmuka Serializable pada kelas dan anak-anaknya. Ini adalah antarmuka penanda, yang berarti bahwa tidak ada metode untuk diterapkan, Java hanya akan melakukan upaya terbaik untuk membuat serialisasi secara efisien.

• Masalah dengan pendekatan ini adalah refleksi digunakan dan prosesnya lambat. Mekanisme ini juga cenderung menciptakan banyak objek sementara dan menyebabkan pengumpulan sampah yang cukup banyak.

Parcelable, The Speed

Apa itu Parcelable?

Parcelable adalah antarmuka lain. Meskipun saingannya (Serializable jika Anda lupa), itu adalah bagian dari SDK Android. Sekarang, Parcelable dirancang khusus sedemikian rupa sehingga tidak ada refleksi saat menggunakannya. Itu karena kami benar-benar eksplisit untuk proses serialisasi.

public class TestModel implements Parcelable {


String name;

public TestModel(String name, String id) {
    this.name = name;
}

protected TestModel(Parcel in) {
    this.name = in.readString();


}

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

@Override
public int describeContents() {
    return 0;
}

@Override
public void writeToParcel(Parcel dest, int flags) {
    dest.writeString(this.name);

}

public static final Parcelable.Creator<TestModel> CREATOR = new Parcelable.Creator<TestModel>() {
    @Override
    public TestModel createFromParcel(Parcel source) {
        return new TestModel(source);
    }

    @Override
    public TestModel[] newArray(int size) {
        return new TestModel[size];
    }
};
}

Sekarang, pemenangnya adalah

Hasil tes yang dilakukan oleh Philippe Breault menunjukkan bahwa Parcelable lebih dari 10x lebih cepat daripada Serializable. Beberapa insinyur Google lainnya juga mendukung pernyataan ini.

Menurut mereka, pendekatan Serializable default lebih lambat dari Parcelable. Dan di sini kita memiliki perjanjian antara kedua pihak! TETAPI tidak adil membandingkan keduanya! Karena dengan Parcelable kita sebenarnya menulis kode khusus. Kode khusus dibuat untuk POJO yang satu itu. Dengan demikian, tidak ada sampah yang dibuat dan hasilnya lebih baik. Tetapi dengan pendekatan Serializable default, kami mengandalkan proses serialisasi otomatis Java. Prosesnya rupanya tidak adat sama sekali dan menciptakan banyak sampah! Dengan demikian, hasilnya semakin buruk.

Stop Stop !!!!, Sebelum membuat keputusan

Sekarang, ada pendekatan lain . Seluruh proses otomatis di belakang Serializable dapat diganti dengan kode khusus yang menggunakan metode writeObject () & readObject (). Metode-metode ini spesifik. Jika kita ingin mengandalkan pendekatan Serializable dalam kombinasi dengan perilaku serialisasi khusus, maka kita harus menyertakan dua metode ini dengan tanda tangan yang sama persis dengan yang di bawah ini:

 private void writeObject(java.io.ObjectOutputStream out)
 throws IOException;

 private void readObject(java.io.ObjectInputStream in)
     throws IOException, ClassNotFoundException;

 private void readObjectNoData()
     throws ObjectStreamException;

Dan sekarang perbandingan antara Parcelable dan custom Serializable tampak adil! Hasilnya mungkin mengejutkan! Pendekatan kustom Serializable lebih dari 3x lebih cepat untuk menulis dan 1,6x lebih cepat untuk membaca daripada Parcelable.

Diedit: -----

2) Serialisasi Serialisasi

Perpustakaan Serialisasi Kotlinx

For Kotlin serialization need to add below dependency and plugin

implementation "org.jetbrains.kotlinx:kotlinx-serialization-runtime:0.9.1"

apply plugin: 'kotlinx-serialization'

build.gradleFile Anda

apply plugin: 'com.android.application'

apply plugin: 'kotlin-android'

apply plugin: 'kotlin-android-extensions'
apply plugin: 'kotlinx-serialization'

android {
    compileSdkVersion 28
    defaultConfig {
        applicationId "com.example.smile.kotlinxretrosample"
        minSdkVersion 16
        targetSdkVersion 28
        versionCode 1
        versionName "1.0"
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
    implementation "org.jetbrains.kotlinx:kotlinx-serialization-runtime:0.9.1"
    implementation 'com.android.support:appcompat-v7:28.0.0'
    implementation 'com.android.support.constraint:constraint-layout:1.1.3'
    implementation 'com.android.support:design:28.0.0'
    implementation 'com.squareup.retrofit2:retrofit:2.5.0'
    implementation 'com.squareup.okhttp3:okhttp:3.12.0'
    testImplementation 'junit:junit:4.12'
    androidTestImplementation 'com.android.support.test:runner:1.0.2'
    androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.0.2'
}

Serialisasi dilakukan dengan cukup mudah, Anda perlu membuat anotasi kelas yang dimaksud dengan @Serializableanotasi seperti di bawah ini

import kotlinx.serialization.Serializable
@Serializable
class Field {
    var count: Int = 0
    var name: String = ""
}

Dua anotasi lagi yang perlu diperhatikan adalah transientdan optional. Menggunakan transient akan membuat serializer mengabaikan bidang itu dan menggunakan opsional akan memungkinkan serializer tidak memecah jika bidang hilang, tetapi pada saat yang sama nilai default perlu disediakan.

@Optional
var isOptional: Boolean = false
@Transient
var isTransient: Boolean = false

Catatan : Ini juga bisa bekerja dengan kelas data.

Sekarang untuk benar-benar menggunakan ini dalam tindakan, mari kita ambil contoh bagaimana mengkonversi JSON menjadi objek dan kembali

 fun toObject(stringValue: String): Field {
        return JSON.parse(Field.serializer(), stringValue)
    }

    fun toJson(field: Field): String {
        //Notice we call a serializer method which is autogenerated from our class 
        //once we have added the annotation to it
        return JSON.stringify(Field.serializer(), field)
    }

Untuk lebih

Jika Anda ingin menjadi warga negara yang baik, luangkan waktu ekstra untuk mengimplementasikan Parcelable karena akan melakukan 10 kali lebih cepat dan menggunakan lebih sedikit sumber daya.

Namun, dalam kebanyakan kasus, kelambatan Serializable tidak akan terlihat. Jangan ragu untuk menggunakannya tetapi ingat bahwa serialisasi adalah operasi yang mahal jadi pertahankan seminimal mungkin.

Jika Anda mencoba untuk melewati daftar dengan ribuan objek serial, ada kemungkinan seluruh proses akan memakan waktu lebih dari satu detik. Ini dapat membuat transisi atau rotasi dari potret ke lanscape terasa sangat lamban.

Sumber ke titik ini: http://www.developerphil.com/parcelable-vs-serializable/

Di Parcelable, pengembang menulis kode khusus untuk marshaling dan unmarshaling sehingga menghasilkan lebih sedikit objek sampah dibandingkan dengan Serialisasi. Kinerja Parcelable over Serialization meningkat secara dramatis (sekitar dua kali lebih cepat), karena implementasi kustom ini.

Serializable adalah antarmuka penanda, yang menyiratkan bahwa pengguna tidak dapat menyusun data sesuai dengan kebutuhan mereka. Dalam Serialisasi, operasi marshaling dilakukan pada Java Virtual Machine (JVM) menggunakan Java reflection API. Ini membantu mengidentifikasi anggota objek Java dan perilaku, tetapi juga akhirnya membuat banyak objek sampah. Karena ini, proses Serialisasi lebih lambat dibandingkan dengan Parcelable.

Sunting: Apa arti dari marshalling dan unmarshalling?

Dalam beberapa kata, "marshalling" mengacu pada proses mengubah data atau objek dalam byte-stream, dan "unmarshalling" adalah proses kebalikan dari konversi byte-stream beack ke data atau objek asli mereka. Konversi dicapai melalui "serialisasi".

http://www.jguru.com/faq/view.jsp?EID=560072

Aku sebenarnya akan menjadi orang yang mengadvokasi Serializable. Perbedaan kecepatan tidak begitu drastis lagi karena perangkat jauh lebih baik daripada beberapa tahun yang lalu dan juga ada perbedaan lain yang lebih halus. Lihat posting blog saya tentang masalah ini untuk info lebih lanjut.

Parcelable adalah semacam standar dalam pengembangan Android. Tetapi bukan karena kecepatan

Parcelable direkomendasikan sebagai pendekatan untuk transfer data. Tetapi jika Anda menggunakan serializable dengan benar seperti yang ditunjukkan dalam repo ini , Anda akan melihat bahwa serializable terkadang lebih cepat daripada parcelable. Atau setidaknya pengaturan waktu dapat dibandingkan.

Apakah Parcelable lebih cepat daripada Serializable?

Serialisasi Java biasa pada perangkat Android rata-rata (jika dilakukan dengan benar *) sekitar 3,6 kali lebih cepat dari Parcelable untuk menulis dan sekitar 1,6 kali lebih cepat untuk dibaca. Juga membuktikan bahwa Java Serialization (jika dilakukan dengan benar) adalah mekanisme penyimpanan cepat yang memberikan hasil yang dapat diterima bahkan dengan grafik objek yang relatif besar dari 11000 objek dengan masing-masing 10 bidang.

* Catatanidennya adalah bahwa biasanya setiap orang yang secara membuta menyatakan bahwa "Parcelable is bub fast" membandingkannya dengan serialisasi otomatis standar, yang menggunakan banyak refleksi di dalamnya. Ini adalah perbandingan yang tidak adil, karena Parcelable menggunakan prosedur menulis data secara manual (dan sangat rumit). Apa yang biasanya tidak disebutkan adalah bahwa standar Java Serializable menurut dokumen juga dapat dilakukan dengan cara manual, menggunakan metode writeObject () dan readObject (). Untuk info lebih lanjut, lihat JavaDocs. Inilah yang harus dilakukan untuk kinerja terbaik.

Jadi, jika serializable lebih cepat dan lebih mudah diimplementasikan, mengapa android memiliki parcelable sama sekali?

Alasannya adalah kode asli. Parcelable dibuat bukan hanya untuk komunikasi antarproses. Ini juga bisa digunakan untuk komunikasi antar kode . Anda dapat mengirim dan menerima objek dari lapisan asli C ++. Itu dia.

Apa yang harus Anda pilih? Keduanya akan bekerja dengan baik. Tapi saya pikir Parcelable adalah pilihan yang lebih baik karena direkomendasikan oleh google dan seperti yang Anda lihat dari utas ini jauh lebih dihargai.

1. Serializable

@lihat http://docs.oracle.com/javase/7/docs/api/java/io/Serializable.html

Antarmuka apa?

• adalah antarmuka Java standar

Mempercepat

• lebih lambat dari Parcelable

2. Parcelable

@lihat http://developer.android.com/reference/android/os/Parcelable.html

Antarmuka apa?

• adalah antarmuka android.os
  • yang berarti Google mengembangkan Parcelable untuk kinerja yang lebih baik di android

Mempercepat

• lebih cepat (karena dioptimalkan untuk penggunaan pada pengembangan android)

> Kesimpulan

Sadarilah bahwa Serializable adalah antarmuka Java standar, dan Parcelable untuk Pengembangan Android

Ada beberapa masalah kinerja yang berkaitan dengan marshaling dan unmarshaling. Parcelable dua kali lebih cepat dari Serializable.

Silakan buka tautan berikut:

http://www.3pillarglobal.com/insights/parcelable-vs-java-serialization-in-android-app-development

Implementasi parcelable bisa lebih cepat jika Anda menggunakan plugin paracelable di android studio. mencari penghasil kode Parcelable Android

Antarmuka Serializable dapat digunakan dengan cara yang sama seperti Parcelable, menghasilkan (tidak banyak) kinerja yang lebih baik. Timpa kedua metode tersebut untuk menangani proses pembuatan dan pengosongan secara manual:

private void writeObject(java.io.ObjectOutputStream out)
    throws IOException
private void readObject(java.io.ObjectInputStream in)
    throws IOException, ClassNotFoundException

Namun, menurut saya ketika mengembangkan Android asli, menggunakan api Android adalah cara yang harus dilakukan.

Lihat :

• https://bitbucket.org/afrishman/androidserializationtest/
• https://docs.oracle.com/javase/7/docs/api/java/io/Serializable.html

Saya terlambat menjawab, tetapi memposting dengan harapan itu akan membantu orang lain.

Dalam hal Kecepatan , Parcelable > Serializable. Tapi, Custom Serializable adalah pengecualian. Ini hampir dalam kisaran Parcelable atau bahkan lebih cepat.

Referensi: https://www.geeksforgeeks.org/customized-serialization-and-deserialization-in-java/

Contoh:

Kelas Khusus untuk serial

class MySerialized implements Serializable { 

    String deviceAddress = "MyAndroid-04"; 

    transient String token = "AABCDS"; // sensitive information which I do not want to serialize

    private void writeObject(ObjectOutputStream oos) throws Exception {
        oos.defaultWriteObject();
        oos.writeObject("111111" + token); // Encrypted token to be serialized
    }

    private void readObject(ObjectInputStream ois) throws Exception {
        ois.defaultReadObject(); 
        token = ((String) ois.readObject()).subString(6);  // Decrypting token
    }

}

Parcelable jauh lebih cepat daripada serializable dengan Binder, karena menggunakan refleksi serializable dan menyebabkan banyak GC. Parcelable adalah desain untuk mengoptimalkan untuk melewatkan objek.

Inilah tautan ke referensi. http://www.developerphil.com/parcelable-vs-serializable/

Anda dapat menggunakan objek serializable dalam maksud tetapi pada saat membuat serialize objek Parcelable dapat memberikan pengecualian serius seperti NotSerializableException. Apakah tidak disarankan menggunakan serializable dengan Parcelable. Jadi lebih baik untuk memperluas Parcelable dengan objek yang ingin Anda gunakan dengan bundel dan maksud. Karena Parcelable ini khusus untuk android sehingga tidak memiliki efek samping. :)

Serializable

Serializable adalah antarmuka yang dapat ditandai atau kita dapat menyebutnya sebagai antarmuka kosong. Itu tidak memiliki metode pra-diterapkan. Serializable akan mengubah objek ke aliran byte. Sehingga pengguna dapat meneruskan data antara satu aktivitas dengan aktivitas lainnya. Keuntungan utama serializable adalah pembuatan dan mengirimkan data sangat mudah tetapi merupakan proses yang lambat dibandingkan dengan parcelable.

Paket

Parcel mampu lebih cepat daripada serializable. Parcel mampu mengubah objek menjadi byte stream dan meneruskan data antara dua aktivitas. Menulis kode parsel sedikit rumit dibandingkan dengan serialisasi. Itu tidak membuat lebih banyak objek temp saat meneruskan data antara dua aktivitas.