ทั้งหมดที่คุณต้องรู้เกี่ยวกับส่วนประกอบสถาปัตยกรรม Android

ส่วนประกอบสถาปัตยกรรม

สถาปัตยกรรมเป็นแผนงานที่มั่นคงซึ่งต้องทำก่อนเริ่มกระบวนการพัฒนา ส่วนประกอบสถาปัตยกรรมช่วยจัดระเบียบแอปพลิเคชัน เชื่อมโยงองค์ประกอบทั้งหมดเข้าด้วยกัน และจัดเตรียมคอลเลกชันของไลบรารีที่ช่วยให้คุณออกแบบแอปพลิเคชันที่แข็งแกร่ง ตรวจสอบได้ และบำรุงรักษาได้ สถาปัตยกรรมใหม่ของ Android นำเสนอหลักการสำคัญบางประการในการสร้างแอปพลิเคชันในอุดมคติที่มีการรักษาความปลอดภัยและหลีกเลี่ยงคลาสที่บวมซึ่งยากต่อการบำรุงรักษาและทดสอบ

การก่อสร้างตึก

ตัวอย่างพื้นฐานสำหรับการสร้างบล็อค ได้แก่ กิจกรรม ดู เจตนา บริการ ชิ้นส่วน ไฟล์มานิเฟสต์ AVD (อุปกรณ์เสมือน Android) บล็อกเหล่านี้เป็นตัวแทนของสถาปัตยกรรมคอมโพเนนต์ของแอปพลิเคชันที่มีเหตุผลและเป็นเครื่องหมายของจุดบอดของนักพัฒนา

ชุดแรกช่วยคุณได้

• จัดการกิจกรรมและวงจรชีวิตของแฟรกเมนต์ของคุณโดยอัตโนมัติเพื่อหลีกเลี่ยงการรั่วไหลของหน่วยความจำและทรัพยากร
• คงวัตถุข้อมูล Java ไปยังฐานข้อมูล SQLite

ส่วนประกอบ:

1. ส่วนประกอบวงจรชีวิต

องค์ประกอบนี้ใช้เพื่อเพิ่มการรับรู้วงจรชีวิต ส่วนประกอบของวงจรชีวิตประกอบด้วย Lifecycle, LifecycleOwner และ LifecycleObserver

วงจรชีวิต

จนถึงตอนนี้ lifecycle เป็นคลาสนามธรรมที่จัดการโดยระบบเอง แต่ในสถานการณ์ปัจจุบัน Lifecycle จะระบุสถานะของส่วนประกอบและพฤติกรรม & สิ้นสุดงานตามเวลาที่เหมาะสม

เจ้าของวงจรชีวิต

LifecycleOwner เป็นอินเทอร์เฟซที่สามารถนำไปใช้เพื่อรับวัตถุวงจรชีวิตจากเมธอด getLifecycle() ProcessLifecycleOwner มีประโยชน์เมื่อคุณต้องการจัดการวงจรชีวิตของกระบวนการทั้งหมด

LifecycleObserver

LifecycleObserver สังเกตส่วนประกอบ LifecycleOwner เช่น กิจกรรมและชิ้นส่วน ได้รับ LifecycleOwner.Event และตอบสนองต่อพวกเขาผ่านวิธีการใส่คำอธิบายประกอบ

การนำทั้งหมดนี้มาใช้ร่วมกัน เราสามารถสร้างแอปพลิเคชันที่รับรู้วงจรชีวิตได้

• การนำผู้สังเกตการณ์วงจรชีวิตไปใช้

 TestObserver คลาสสาธารณะใช้ LifecycleObserver {

MyObserver สาธารณะ (วงจรชีวิต) {

// เริ่มการสังเกตวงจรชีวิต

lifecycle.addObserver(นี้);

...

}

// เมธอดที่มีคำอธิบายประกอบจะเรียกเมื่อวงจรชีวิตที่เกี่ยวข้องผ่านเหตุการณ์เหล่านี้

@OnLifecycleEvent(วงจรชีวิต.เหตุการณ์.ON_RESUME)

โมฆะสาธารณะ onResume() {

}

@OnLifecycleEvent(วงจรชีวิต.เหตุการณ์.ON_PAUSE)

โมฆะสาธารณะ onPause() {

}

}

ตอนนี้ เราสามารถใช้ผู้สังเกตการณ์นี้ในองค์ประกอบแอปของเรา โดยใช้การใช้งานต่อไปนี้ TestObserver observer = new TestObserver(aLifecycleOwner.getLifecycle());

2. LiveData

องค์ประกอบ LiveData เป็นผู้ถือข้อมูลที่มีค่าที่สามารถสังเกตได้ ด้วยข้อมูลสดทุกครั้งที่มีการอัปเดตกิจกรรมหรือส่วน เราจะได้รับการแจ้งเตือน ดังนั้น UI ของคุณจะได้รับการอัปเดตเสมอ เป็นเครื่องห่อหุ้มรอบโมเดลทั่วไปของคุณซึ่งจะแจ้งให้ผู้สังเกตทราบเมื่อมีบางอย่างเปลี่ยนแปลงในโมเดลนั้น ข้อได้เปรียบหลักของ livedata คือไม่มีหน่วยความจำรั่วไหลอีกต่อไป และ NullPointerExceptions เนื่องจากมุมมองที่ไม่มีอยู่

• สร้างวัตถุ LiveData

 MyViewModel คลาสสาธารณะขยาย ViewModel {
// สร้าง LiveData ด้วยสตริง
MutableLiveData<String> ส่วนตัว mData;
MutableLiveData สาธารณะ <String> getData () {
ถ้า ( mData == null) {
mData = ใหม่ MutableLiveData<String>();
}
ส่งคืน mData;
}
}

• สังเกตวัตถุ LiveData

 รหัสต่อไปนี้แสดงวิธีการสังเกตวัตถุ LiveData:
MyActivity คลาสสาธารณะขยาย AppCompatActivity {
โมฆะสาธารณะ onCreate (Bundle saveInstanceState) {
super.onCreate(savedInstanceState);
โมเดล MyViewModel = ViewModelProviders.of (นี้).get(MyViewModel .class);
model.getData (). สังเกต (นี่ ข้อมูล -> {
// อัปเดต UI
});
}
}

3. ดูรุ่น

ViewModel มีประโยชน์ในการจัดเตรียมและบำรุงรักษาข้อมูลสำหรับส่วนประกอบ UI ของคุณ (กิจกรรมหรือส่วนย่อย) ในลักษณะที่คำนึงถึงวงจรชีวิต มันสามารถอยู่รอดผ่านการเปลี่ยนแปลงการกำหนดค่า ดังนั้นหากคุณทำลายกิจกรรมหรือเปลี่ยนการวางแนวโทรศัพท์ของคุณ คุณจะไม่สูญเสีย ViewModel และข้อมูล เนื่องจากอินสแตนซ์ LiveData ที่อยู่ภายใต้คลาส ViewModel อินพุตจากจุดสิ้นสุดของเราจึงไม่จำเป็น

คุณไม่จำเป็นต้องกังวลเกี่ยวกับวงจรชีวิต UI ของข้อมูลผู้ถือใน UI ViewModel จะถูกสร้างโดยอัตโนมัติผ่านโรงงาน และคุณไม่จำเป็นต้องจัดการกับการสร้างและรื้อถอนด้วยตัวเอง

• ใช้งาน ViewModel

 มันแสดงให้เห็นโดยโค้ดตัวอย่างต่อไปนี้:
MyViewModel คลาสสาธารณะขยาย ViewModel {
MutableLiveData ส่วนตัว<List<Students>> นักเรียน;
LiveData สาธารณะ <List <Students>> getStudents () {
ถ้า ( นักเรียน == null) {
นักเรียน = ใหม่ MutableLiveData<List<Students>>();
โหลดนักเรียน ();
}
ส่งคืนนักเรียน;
}
โมฆะส่วนตัว loadStudents () {
// ทำการดำเนินการแบบอะซิงโครนัสเพื่อเรียกนักเรียน
}
}

คุณสามารถเข้าถึงรายการนี้ได้จากกิจกรรมดังต่อไปนี้:

 MyActivity คลาสสาธารณะขยาย AppCompatActivity {
โมฆะสาธารณะ onCreate (Bundle saveInstanceState) {
// สร้าง ViewModel ในครั้งแรกที่ระบบเรียกใช้เมธอด onCreate() ของกิจกรรม
// กิจกรรมที่สร้างใหม่จะได้รับอินสแตนซ์ MyViewModel เดียวกันกับที่สร้างโดยกิจกรรมแรก
โมเดล MyViewModel = ViewModelProviders.of (นี้).get(MyViewModel.class);
model.getStudents (). สังเกต (นี่ นักเรียน -> {
// อัปเดต UI
});
}
}

4. ห้อง

Room เป็นไลบรารีฐานข้อมูลและเป็นทางเลือกที่ดีสำหรับฐานข้อมูล SQLite ในการใช้ฐานข้อมูล SQLite จำเป็นต้องเขียนต้นแบบจำนวนมากเสมอ เราสามารถกำหนดฐานข้อมูลโดยการเพิ่มคำอธิบายประกอบในคลาส Model ไลบรารีช่วยสร้างแคชข้อมูลของแอปบนอุปกรณ์ มันคล้ายกับ OrmLite มาก

มี 3 องค์ประกอบหลักในห้อง:

ก. ฐานข้อมูล

เนื่องจากแอปของคุณยังคงอยู่ ข้อมูลเชิงสัมพันธ์และมีเจ้าของฐานข้อมูล จึงทำหน้าที่เป็นจุดเชื่อมต่อหลักสำหรับการเชื่อมต่อพื้นฐานกับคลาสที่มีคำอธิบายประกอบด้วย @Database ควรเป็นไปตามเงื่อนไขต่อไปนี้:

เป็นคลาสนามธรรมที่ขยาย RoomDatabase

รวมรายการเอนทิตีที่เชื่อมต่อกับฐานข้อมูลที่มีคำอธิบายประกอบ

ส่งคืนคลาสที่มีคำอธิบายประกอบด้วย @Dao และมีวิธีนามธรรมที่มี 0 อาร์กิวเมนต์

ในขณะที่รันไทม์ คุณสามารถรับอินสแตนซ์ของฐานข้อมูลผ่านการเรียก Room.inMemoryDatabaseBuilder() หรืออย่างอื่น Room.databaseBuilder()

ข. นิติบุคคล

แสดงตารางภายในฐานข้อมูล

ค. ดาว

ประกอบด้วยเมธอดที่ใช้ในการเข้าถึงฐานข้อมูล

• กำลังสร้างเอนทิตี

 @เอนทิตี
ผู้ใช้คลาสสาธารณะ {
@PrimaryKey
uid int ส่วนตัว;
@ColumnInfo (ชื่อ = "ชื่อจริง")
ชื่อสตริงส่วนตัว;
@ColumnInfo (ชื่อ = "last_name")
นามสกุลสตริงส่วนตัว;

// Getters และ setters จะถูกละเว้นเพื่อความกระชับ
// แต่พวกมันจำเป็นสำหรับรูมที่จะทำงาน
}

• สร้างฐานข้อมูล

 @ฐานข้อมูล (เอนทิตี = {User.class} รุ่น = 1)
AppDatabase คลาสนามธรรมสาธารณะขยาย RoomDatabase {
อินสแตนซ์ AppDatabase แบบคงที่ส่วนตัว;
AppDatabase สาธารณะแบบคงที่ getDatabase (บริบทบริบท) {
ถ้า (INSTANCE == null) {
INSTANCE = Room.databaseBuilder(context.getApplicationContext(), AppDatabase.class, "my_db").build();
}
ส่งคืนอินสแตนซ์;
}
}

คลาสนี้ใช้เพื่อสร้างฐานข้อมูลและรับอินสแตนซ์ของฐานข้อมูล เราสร้างฐานข้อมูลโดยใช้รหัสต่อไปนี้

Room.databaseBuilder(context.getApplicationContext(), AppDatabase.class, “my_db”).build();

• สร้างวัตถุการเข้าถึงข้อมูล

ใส่คำอธิบายประกอบในชั้นเรียนด้วยคำอธิบายประกอบ @Dao การใช้งานคลาสจะถูกสร้างขึ้นโดย Room ที่ใช้วิธีการที่กำหนดไว้ในอินเทอร์เฟซ (คล้ายกับวิธีการทำงานของ Retrofit)

 @ดาว
อินเทอร์เฟซสาธารณะ UserDao {
@Query("เลือก * จากผู้ใช้")
รายการ <ผู้ใช้> getAll();
@Query("เลือก * จากผู้ใช้ WHERE uid IN (:userIds)")
รายการ <ผู้ใช้> loadAllByIds(int[] userIds);

@Query("เลือก * จากผู้ใช้ WHERE first_name LIKE:first AND"
+ "last_name LIKE :last LIMIT 1")
ผู้ใช้ findByName(สตริงแรก สตริงสุดท้าย);

@แทรก
ถือเป็นโมฆะ insertAll(ผู้ใช้... ผู้ใช้);

@ลบ
ลบเป็นโมฆะ (ผู้ใช้ผู้ใช้);
}

บทสรุป

บทความนี้ให้ความรู้พื้นฐานเกี่ยวกับส่วนประกอบสถาปัตยกรรม Android เราได้พยายามรวมหัวข้อทั้งหมดที่เกี่ยวข้องกับสถาปัตยกรรม Android ที่เสนอใหม่ ซึ่งแก้ปัญหาที่เกี่ยวข้องทั้งหมดที่นักพัฒนาซอฟต์แวร์เผชิญอยู่ขณะพัฒนาแอปพลิเคชัน อย่างไรก็ตาม หากคุณพบปัญหาใดๆ ให้พิจารณา จ้าง Android Developer ของ Elsner Technology