เมื่อใดจึงควรใช้ RxJava ใน Android และเมื่อใดควรใช้ LiveData จากส่วนประกอบทางสถาปัตยกรรมของ Android

ฉันไม่ได้รับเหตุผลในการใช้ RxJava ใน Android และ LiveData จากส่วนประกอบทางสถาปัตยกรรมของ Android มันจะมีประโยชน์มากหากการอธิบายและการใช้ความแตกต่างระหว่างทั้งสองพร้อมกับตัวอย่างตัวอย่างในรูปแบบของรหัสซึ่งอธิบายความแตกต่างระหว่างทั้งสอง

Android LiveData เป็นตัวแปรของรูปแบบผู้สังเกตการณ์ดั้งเดิมด้วยการเพิ่มช่วงการเปลี่ยนภาพที่ใช้งาน / ไม่ทำงาน เช่นนี้มันมีขอบเขต จำกัด มาก

ใช้ตัวอย่างที่อธิบายในAndroid LiveDataคลาสจะถูกสร้างขึ้นเพื่อตรวจสอบข้อมูลตำแหน่งและลงทะเบียนและยกเลิกการลงทะเบียนตามสถานะแอปพลิเคชัน

RxJava ให้บริการตัวดำเนินการที่มีการวางนัยทั่วไปมากขึ้น สมมติว่าสิ่งที่สังเกตได้นี้จะให้ข้อมูลตำแหน่ง:

Observable<LocationData> locationObservable;

การใช้งานของสิ่งที่สังเกตได้สามารถสร้างขึ้นโดยใช้Observable.create()เพื่อแมปการดำเนินการโทรกลับ เมื่อมีการติดตามการสมัครสมาชิกการโทรกลับจะถูกลงทะเบียนและเมื่อยกเลิกการลงทะเบียนแล้วการโทรกลับจะไม่ถูกลงทะเบียน การใช้งานมีลักษณะคล้ายกับรหัสที่ให้ไว้ในตัวอย่าง

สมมติว่าคุณมีสิ่งที่สังเกตได้ซึ่งส่งเสียงจริงเมื่อแอปพลิเคชันทำงาน:

Observable<Boolean> isActive;

จากนั้นคุณสามารถจัดหาฟังก์ชั่นทั้งหมดของ LiveData ได้ดังต่อไปนี้

Observable<LocationData> liveLocation =
  isActive
    .switchMap( active -> active ? locationObservable : Observable.never() );

switchMap()ดำเนินการอย่างใดอย่างหนึ่งจะให้สถานที่ปัจจุบันเป็นกระแสหรืออะไรถ้าสมัครไม่ได้ใช้งาน เมื่อคุณมีสิ่งที่liveLocationสังเกตได้มีหลายสิ่งที่คุณสามารถทำได้โดยใช้ตัวดำเนินการ RxJava ตัวอย่างที่ฉันชอบคือ:

liveLocation.distinctUntilChanged()
  .filter( location -> isLocationInAreaOfInterest( location ) )
  .subscribe( location -> doSomethingWithNewLocation( location ) );

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

ประเด็นของ RxJava คือการรวมการควบคุมและการกำหนดเวลาเข้ากับเอกภพเดียวโดยใช้การดำเนินการที่ได้รับจากห้องสมุดหรือแม้แต่การดำเนินการที่กำหนดเองที่คุณให้ไว้

ที่อยู่ LiveData เพียงส่วนหนึ่งเล็ก ๆ liveLocationของจักรวาลที่เทียบเท่าของอาคาร

สำหรับคำถามเดิมทั้ง RxJava และ LiveData ช่วยเติมเต็มซึ่งกันและกันได้เป็นอย่างดี

LiveDataส่องสว่างอยู่บนชั้น ViewModel ด้วยการผนวกกับวงจรชีวิต Android ViewModelและ RxJavaมอบความสามารถเพิ่มเติมในการแปลงสภาพ (ดังที่ได้รับการกล่าวถึงโดย @Bob Dalgleish)

ขณะนี้เรากำลังใช้RxJavaในแหล่งข้อมูลและเลเยอร์พื้นที่เก็บข้อมูลและมันถูกแปลงเป็นLiveData(โดยใช้LiveDataReactiveStreams) ใน ViewModels (ก่อนเปิดเผยข้อมูลเป็นกิจกรรม / ชิ้นส่วน) - ค่อนข้างมีความสุขกับวิธีนี้

มีความแตกต่างมากมายระหว่าง LiveData และ RxJava:

1. LiveData ไม่ได้เป็นกระแสในขณะ RxJava ทุกอย่าง (ทุกอย่างแท้จริง) เป็นSTREAM
2. LiveData เป็นคลาสของตัวยึดข้อมูลที่สังเกตได้ ซึ่งแตกต่างจากที่สังเกตได้ปกติ LiveData คือวงจรชีวิตตระหนักถึงความหมายมันเคารพวงจรชีวิตของส่วนประกอบแอปอื่น ๆ เช่นกิจกรรมชิ้นส่วนหรือบริการ การรับรู้นี้ทำให้มั่นใจได้ว่า LiveData จะอัปเดตเฉพาะผู้สังเกตการณ์ส่วนประกอบแอปที่อยู่ในสถานะวงจรชีวิต
3. LiveData เป็นแบบซิงโครนัสดังนั้นคุณจึงไม่สามารถเรียกใช้โค้ดขนาดใหญ่ (การโทรผ่านเครือข่ายการจัดการฐานข้อมูล ฯลฯ ) แบบอะซิงโครนัสโดยใช้เพียง LiveData เช่นเดียวกับที่คุณทำกับ RxJava
4. สิ่งที่ดีที่สุดที่คุณสามารถทำได้เพื่อใช้ประโยชน์จากคู่นี้มากที่สุดคือการใช้ RxJava สำหรับตรรกะทางธุรกิจของคุณ (การโทรเครือข่ายการจัดการข้อมูล ฯลฯ สิ่งที่เกิดขึ้นในและนอกพื้นที่เก็บข้อมูล ) และใช้ LiveData สำหรับชั้นนำเสนอของคุณ โดยสิ่งนี้คุณจะได้รับการแปลงและความสามารถในการสตรีมสำหรับตรรกะทางธุรกิจของคุณและการดำเนินงานที่ตระหนักถึงวงจรชีวิตสำหรับ UI ของคุณ
5. LiveData และ RxJava ชมเชยถ้าใช้ร่วมกัน สิ่งที่ฉันหมายถึงคือทำทุกอย่างด้วย RxJava และในตอนท้ายเมื่อคุณต้องการอัปเดต UI ทำบางอย่างเช่นรหัสที่ระบุด้านล่างเพื่อเปลี่ยน Observable ของคุณเป็น LiveData ดังนั้นมุมมอง (UI) ของคุณจะสังเกตเห็น LiveData ใน ViewModel โดยที่ LiveData ของคุณไม่ได้เป็นอะไรนอกจาก MutableLiveData ที่ไม่สามารถเปลี่ยนแปลงได้ (หรือ MutableLiveData คือ LiveData ที่ไม่แน่นอน)
6. ดังนั้นคำถามที่นี่คือทำไมคุณควรใช้ LiveData ตั้งแต่แรก? ดังที่คุณเห็นด้านล่างในรหัสคุณเก็บการตอบสนองของคุณจาก RxJava ไปยัง MutableLiveData (หรือ LiveData) และ LiveData ของคุณทราบวงจรชีวิตดังนั้นในทางข้อมูลของคุณจึงตระหนักถึงวงจรชีวิต ทีนี้ลองจินตนาการถึงความเป็นไปได้ที่ข้อมูลของคุณจะทราบว่าจะปรับปรุง UI เมื่อใดและเมื่อใด
7. LiveData ไม่มีประวัติ (เฉพาะสถานะปัจจุบัน) ดังนั้นคุณไม่ควรใช้ LiveData สำหรับแอปพลิเคชันการแชท
8. เมื่อคุณใช้ LiveData กับ RxJava คุณไม่จำเป็นต้องใช้อะไรเช่นMediatorLiveData , SwitchMapเป็นต้นเครื่องมือเหล่านี้เป็นเครื่องมือควบคุมกระแสข้อมูลและ RxJava ดีกว่าในหลาย ๆ ครั้ง
9. ดู LiveData เป็นสิ่งที่ผู้ถือครองข้อมูลและไม่มีอะไรอื่น นอกจากนี้เรายังสามารถพูดได้ว่า LiveData เป็นผู้บริโภคที่ตระหนักถึงวงจรชีวิต

    public class RegistrationViewModel extends ViewModel {
        Disposable disposable;

        private RegistrationRepo registrationRepo;
        private MutableLiveData<RegistrationResponse> modelMutableLiveData =
                new MutableLiveData<>();

        public RegistrationViewModel() {
        }

        public RegistrationViewModel(RegistrationRepo registrationRepo) {
            this.registrationRepo = registrationRepo;
        }

        public void init(RegistrationModel registrationModel) {
            disposable = registrationRepo.loginForUser(registrationModel)
                    .subscribeOn(Schedulers.io())
                    .observeOn(AndroidSchedulers.mainThread())
                    .subscribe(new Consumer<Response<RegistrationResponse>>() {
                        @Override
                        public void accept(Response<RegistrationResponse>
                                                   registrationModelResponse) throws Exception {

                            modelMutableLiveData.setValue(registrationModelResponse.body());
                        }
                    });
        }

        public LiveData<RegistrationResponse> getModelLiveData() {
            return modelMutableLiveData;
        }

       @Override
       protected void onCleared() {
                super.onCleared();
            disposable.dispose();
         }
    }

ในความเป็นจริงLiveData ไม่ได้เป็นเครื่องมือที่แตกต่างกันเป็นหลักRxJavaดังนั้นทำไมมันถูกนำมาใช้เป็นส่วนประกอบสถาปัตยกรรมเมื่อRxJavaจะมีการจัดการวงจรการใช้งานได้อย่างง่ายดายโดยการจัดเก็บการสมัครทั้งหมดเพื่อ observables ใน CompositeDispoable วัตถุแล้วทิ้งพวกเขาในonDestroy() ของActivity หรือonDestroyView() ของFragment ใช้เพียงหนึ่ง สายของรหัส?

ผมได้ตอบคำถามนี้อย่างเต็มที่โดยการสร้างแอพพลิเคค้นหาภาพยนตร์ครั้งเดียวโดยใช้ RxJava แล้วใช้ LiveData ที่นี่

แต่โดยสังเขปใช่แล้วทำได้ แต่ต้องมีวิธีการที่สำคัญกว่าวิธีการวงจรชีวิตที่เกี่ยวข้องนอกเหนือจากการมีความรู้วงจรชีวิตขั้นพื้นฐาน สิ่งนี้อาจไม่เหมาะสมสำหรับบางคน แต่ความจริงก็คือตามช่วงเวลาหนึ่งของJetpack ใน Google I / O 2018นักพัฒนาหลายคนพบว่าวงจรการจัดการวงจรชีวิตที่ซับซ้อน ข้อผิดพลาดจากการขัดข้องที่เกิดจากการไม่จัดการวงจรชีวิตอาจเป็นสัญญาณอีกอย่างหนึ่งที่นักพัฒนาบางคนถึงแม้ว่าจะรู้รอบการใช้งานแล้วก็ตามอย่าลืมดูแลมันในทุกกิจกรรม / ชิ้นส่วนที่พวกเขาใช้ในแอพ ในแอพขนาดใหญ่สิ่งนี้อาจกลายเป็นปัญหาได้แม้ว่าจะมีผลกระทบด้านลบต่อประสิทธิภาพการทำงาน

บรรทัดล่างคือการแนะนำLiveDataผู้พัฒนาจำนวนมากขึ้นคาดว่าจะนำ MVVM มาใช้โดยไม่ต้องเข้าใจการจัดการวงจรชีวิตการรั่วไหลของหน่วยความจำและความผิดพลาด แม้ว่าฉันจะไม่สงสัยเลยว่าLiveDataไม่สามารถเทียบเคียงได้RxJavaในแง่ของความสามารถและพลังที่มอบให้กับนักพัฒนาการเขียนโปรแกรมเชิงโต้ตอบและRxJavaเป็นแนวคิดและเครื่องมือที่เข้าใจยากสำหรับคนจำนวนมาก ในอีกด้านหนึ่งฉันไม่คิดว่าLiveDataมันจะเป็นสิ่งทดแทนสำหรับRxJava- มันไม่สามารถทำได้ - แต่เป็นเครื่องมือที่ง่ายมากสำหรับการจัดการกับปัญหาที่เป็นที่ถกเถียงกันอย่างแพร่หลายที่นักพัฒนาหลายคนใช้

** อัพเดท ** ฉันได้เพิ่มบทความใหม่ที่นี่ซึ่งฉันได้อธิบายว่าการใช้ LiveData ในทางที่ผิดสามารถนำไปสู่ผลลัพธ์ที่ไม่คาดคิดได้อย่างไร RxJava สามารถมาช่วยเหลือในสถานการณ์เหล่านี้ได้

ดังที่คุณอาจทราบว่าในระบบนิเวศที่เกิดปฏิกิริยาเรามีObservableที่ปล่อยข้อมูลและObserverที่สมัคร (รับการแจ้งเตือน) ของ Observable emission นี้ไม่มีอะไรแปลกเลยที่เรียกว่า Observer Pattern "ตะโกน" ที่สังเกตได้บางอย่างผู้สังเกตการณ์จะได้รับแจ้งว่าสังเกตได้ตะโกนอะไรบางอย่างในช่วงเวลาที่กำหนด

คิดว่าLiveDataเป็น Observable ที่ให้คุณจัดการ Observers ที่อยู่ในactiveสถานะ กล่าวอีกนัยLiveDataหนึ่งคือการสังเกตง่าย ๆแต่ก็ดูแลวงจรชีวิต

แต่เรามาดูกรณีรหัสสองกรณีที่คุณขอ:

A) ข้อมูลสด

B) RXJava

A) นี่เป็นการใช้งานพื้นฐานของ LiveData

1) คุณมักจะยกตัวอย่าง LiveData ใน ViewModel เพื่อรักษาการเปลี่ยนแปลงการวางแนว (คุณสามารถมี LiveData ที่เป็นแบบอ่านอย่างเดียวหรือ MutableLiveData ที่สามารถเขียนได้ดังนั้นคุณมักจะเปิดเผยนอกคลาส LiveData)

2) ในOnCreateวิธีการของกิจกรรมหลัก (ไม่ใช่ ViewModel) คุณ "สมัคร" วัตถุสังเกตการณ์ (มักจะเป็นวิธีการ onChanged)

3) คุณเปิดวิธีการสังเกตเพื่อสร้างการเชื่อมโยง

ก่อนอื่นViewModel(เจ้าของตรรกะทางธุรกิจ)

class ViewModel : ViewModel() { //Point 1

    var liveData: MutableLiveData<Int> = MutableLiveData()

}

และนี่คือMainActivity(เป็นใบ้ที่สุด)

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val ViewModelProvider= ViewModelProviders.of(this).get(ViewModel::class.java)

        ViewModelProvider.observe(this, Observer {//Points 2 and 3
            //what you want to observe
        })


        }
    }
}

B) นี่คือการใช้งานพื้นฐานของ RXJava

1) คุณประกาศสิ่งที่สังเกตได้

2) คุณประกาศผู้สังเกตการณ์

3) คุณสมัครสมาชิก Observable ด้วย Observer

Observable.just(1, 2, 3, 4, 5, 6) // Point 1

   .subscribe(new Subscriber() {    //Points 2 & 3
       @Override
       public void onCompleted() {
           System.out.println("Complete!");
       }

       @Override
       public void onError(Throwable e) {
       }

       @Override
       public void onNext(Double value) {
           System.out.println("onNext: " + value);
       }
    });

โดยเฉพาะอย่างยิ่งLiveDataจะใช้กับLifecycleและมักจะมีViewModelส่วนประกอบสถาปัตยกรรม (ตามที่เราเห็น) ในความเป็นจริงเมื่อLiveDataรวมกับ ViewModel ช่วยให้คุณสามารถปรับปรุงในเวลาจริงทุกการเปลี่ยนแปลงใน Observerเพื่อให้เหตุการณ์มีการจัดการในเวลาจริงที่จำเป็น หากต้องการใช้LiveDataขอแนะนำให้รู้จักแนวคิดของวงจรชีวิตและวัตถุที่เกี่ยวข้องLifeCycleOwner / LifeCycleฉันขอแนะนำให้คุณดูการแปลงหากคุณต้องการนำไปใช้LiveDataในสถานการณ์ชีวิตจริง นี่คุณจะพบกรณีการใช้งานบางส่วนจากดีcommonsware

การสรุปโดยทั่วไปLiveDataเป็นวิธีที่ง่ายRXJavaวิธีการสังเกตการเปลี่ยนแปลงในหลาย ๆ องค์ประกอบโดยไม่ต้องสร้างกฎที่ชัดเจนที่เรียกว่ากฎการพึ่งพาระหว่างส่วนประกอบเพื่อให้คุณสามารถทดสอบรหัสได้ง่ายขึ้นและทำให้อ่านง่ายขึ้น RXJava ช่วยให้คุณสามารถทำสิ่งต่าง ๆ ของ LiveData และอีกมากมาย เนื่องจากฟังก์ชั่นเสริมของ RXJava คุณสามารถใช้ LiveData สำหรับกรณีง่าย ๆ หรือใช้ประโยชน์จากพลังทั้งหมดของ RXJava โดยใช้ส่วนประกอบ Android Architecture เป็น ViewModelซึ่งหมายความว่ามันRXJavaซับซ้อนกว่านี้เพียงคิดว่ามีตัวดำเนินการหลายร้อยคนแทน ของ SwitchMap และแผนที่ของ LiveData (ในขณะนี้)

RXJava เวอร์ชัน 2 เป็นไลบรารีที่ปฏิวัติกระบวนทัศน์ Object Oriented เพิ่มวิธีการทำงานที่เรียกว่าเพื่อจัดการการไหลของโปรแกรม

LiveData เป็นส่วนย่อยของส่วนประกอบสถาปัตยกรรม Android ซึ่งพัฒนาโดยทีมงาน android

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

หากคุณต้องการใช้ในการพัฒนาแอพ Android ให้ไปที่ส่วนประกอบสถาปัตยกรรม Android มิฉะนั้นถ้าคุณต้องการใช้แอป Java อื่น ๆ เช่นเว็บแอปเดสก์ท็อป ฯลฯ ให้ใช้ RxJava

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

Rx เป็นเครื่องมือที่ทรงพลังที่ช่วยแก้ปัญหาในรูปแบบการประกาศที่สง่างาม มันจัดการตัวเลือกด้านธุรกิจหรือการดำเนินการบริการ API

การเปรียบเทียบ LiveData กับ RxJava กำลังเปรียบเทียบแอปเปิ้ลกับสลัดผลไม้

เปรียบเทียบ LiveData กับ ContentObserver และคุณกำลังเปรียบเทียบแอปเปิ้ลกับแอปเปิ้ล LiveData อย่างมีประสิทธิภาพเป็นการทดแทนวงจรการรับรู้สำหรับ ContentObserver

การเปรียบเทียบ RxJava กับ AsyncTask หรือเครื่องมือทำเกลียวอื่น ๆ คือการเปรียบเทียบสลัดผลไม้กับส้มเพราะ RxJava ช่วยได้มากกว่าการทำเกลียว

• LiveData บางส่วนเท่ากับ Rx Subject หรือ SharedRxObservable

• LiveData จัดการวงจรชีวิตของการสมัครสมาชิก แต่การสมัครสมาชิก Rx Subject ควรสร้างและกำจัดด้วยตนเอง

• LiveData ไม่มีสถานะการเลิกจ้าง แต่ Rx Subject มี OnError และ OnCompleted