Mengapa Android menyediakan 2 antarmuka untuk objek bersambung? Apakah objek Serializable berinteraksi dengan Binder
file Android dan AIDL?
sumber
Mengapa Android menyediakan 2 antarmuka untuk objek bersambung? Apakah objek Serializable berinteraksi dengan Binder
file Android dan AIDL?
Di Android kita tidak bisa hanya meneruskan objek ke aktivitas. Untuk melakukan ini objek harus mengimplementasikan Serializable
atau Parcelable
antarmuka.
Serializable
Serializable
adalah antarmuka Java standar. Anda bisa mengimplementasikan Serializable
antarmuka 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, Serializable
antarmuka 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
Parcelable
prosesnya 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 ArrayList
objek 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
Parcelable
lebih cepat dari Serializable
antarmukaParcelable
antarmuka membutuhkan waktu lebih lama untuk diimplementasikan dibandingkan dengan Serializable
antarmukaSerializable
antarmuka lebih mudah diimplementasikan Serializable
antarmuka menciptakan banyak objek sementara dan menyebabkan sedikit pengumpulan sampahParcelable
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.
sumber
Parcelable vs Serializable Saya merujuk keduanya.
Untuk Jawa dan Kotlin
1) Jawa
Serializable, Kesederhanaan
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
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.
Stop Stop !!!!, Sebelum membuat keputusan
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
build.gradle
File AndaSerialisasi dilakukan dengan cukup mudah, Anda perlu membuat anotasi kelas yang dimaksud dengan
@Serializable
anotasi seperti di bawah iniDua anotasi lagi yang perlu diperhatikan adalah
transient
danoptional
. 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.Catatan : Ini juga bisa bekerja dengan kelas data.
Untuk lebih
sumber
Serialization
, Silahkan lihat.Sumber ke titik ini: http://www.developerphil.com/parcelable-vs-serializable/
sumber
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
sumber
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.
sumber
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?
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.
sumber
1. Serializable
@lihat http://docs.oracle.com/javase/7/docs/api/java/io/Serializable.html
Antarmuka apa?
Mempercepat
2. Parcelable
@lihat http://developer.android.com/reference/android/os/Parcelable.html
Antarmuka apa?
Mempercepat
> Kesimpulan
Sadarilah bahwa Serializable adalah antarmuka Java standar, dan Parcelable untuk Pengembangan Android
sumber
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
sumber
Implementasi parcelable bisa lebih cepat jika Anda menggunakan plugin paracelable di android studio. mencari penghasil kode Parcelable Android
sumber
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:
Namun, menurut saya ketika mengembangkan Android asli, menggunakan api Android adalah cara yang harus dilakukan.
Lihat :
sumber
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
sumber
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/
sumber
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. :)
sumber
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.
sumber