מבוא ל- RxKotlin

1. סקירה כללית

במדריך זה, אנו נסקור את השימוש ב- הרחבות תגובתיות (Rx) בקוטלין האידיומטית באמצעות ספריית RxKotlin.

RxKotlin אינו יישום של הרחבות תגובתיות, כשלעצמן. במקום זאת, זה בעיקר אוסף של שיטות הרחבה. כלומר, RxKotlin מגדיל את ה- RxJava ספרייה עם ממשק API שתוכנן עם מחשבה Kotlin.

לכן נשתמש במושגים מהמאמר שלנו, מבוא ל- RxJava, כמו גם במושג זרימות הצגנו במאמר ייעודי.

2. התקנת RxKotlin

כדי להשתמש ב- RxKotlin בפרויקט Maven שלנו, נצטרך להוסיף את ה- rxkotlin תלות שלנו pom.xml:

 io.reactivex.rxjava2 rxkotlin 2.3.0 

או, עבור פרויקט Gradle, שלנו build.gradle:

יישום 'io.reactivex.rxjava2: rxkotlin: 2.3.0'

כאן אנו משתמשים ב- RxKotlin 2.x, המכוון ל- RxJava 2. פרויקטים המשתמשים ב- RxJava 1 צריכים להשתמש ב- RxKotlin 1.x. אותם מושגים חלים על שתי הגרסאות.

שים לב ש- RxKotlin תלוי ב- RxJava, אך הם אינם מעדכנים את התלות לעיתים קרובות למהדורה האחרונה. לכן, אנו ממליצים לכלול במפורש את גרסת ה- RxJava הספציפית עליה אנו תלויים, כמפורט במאמר RxJava שלנו.

3. יצירה נצפהב- RxKotlin

RxKotlin כולל מספר שיטות הרחבה ליצירה נצפה ו זורם חפצים מאוספים.

באופן מיוחד, לכל סוג מערך יש toObservable () שיטה ו toFlowable () שיטה:

val נצפה = listOf (1, 1, 2, 3). toObservable () נצפה.טסט (). assertValues ​​(1, 1, 2, 3)
val flowable = listOf (1, 1, 2, 3). toFlowable () flowable.buffer (2) .test (). assertValues ​​(listOf (1, 1), listOf (2, 3))

3.1. הושלםס

RxKotlin מספק גם כמה שיטות ליצור הושלם מקרים. באופן מיוחד, אנחנו יכולים להמיר פעולהs, ניתן להתקשרs, עתידs, ופונקציות אפס-טבעיות ל- הושלם בשיטת ההרחבה toCompletable:

value var = 0 val completeable = {value = 3} .toCompletable () assertFalse (completeable.test (). isCancelled ()) assertEquals (3, value)

4. נצפה ו זורם ל מַפָּה ו מולטימפה

כשיש לנו נצפה אוֹ זורם שמייצר זוג אנו יכולים להפוך אותם לא יחיד נצפה שמייצר א מַפָּה:

val list = listOf (Pair ("a", 1), Pair ("b", 2), Pair ("c", 3), Pair ("a", 4)) val observable = list.toObservable () val map = observable.toMap () assertEquals (mapOf (Pair ("a", 4), Pair ("b", 2), Pair ("c", 3)), map.blockingGet ())

כפי שניתן לראות בדוגמה הקודמת, למפות מחליף ערכים שנפלטו קודם לכן עם ערכים מאוחרים יותר אם יש להם אותו מפתח.

אם אנו רוצים לצבור את כל הערכים המשויכים למפתח לאוסף, אנו משתמשים toMultimap במקום:

val list = listOf (Pair ("a", 1), Pair ("b", 2), Pair ("c", 3), Pair ("a", 4)) val observable = list.toObservable () val מפה = תצפית.למולטימפ () assertEquals (mapOf (Pair ("a", listOf (1, 4)), Pair ("b", listOf (2)), Pair ("c", listOf (3))), map.blockingGet ())

5. שילוב נצפהs ו- זורםס

אחת מנקודות המכירה של Rx היא האפשרות לשלב נצפהs ו- זורםs בדרכים שונות. ואכן, RxJava מספק מספר מפעילים מחוץ לקופסה.

בנוסף לכך, RxKotlin כוללת עוד כמה שיטות הרחבה לשילוב נצפהs וכדומה.

5.1. שילוב פליטות נצפות

כשיש לנו נצפה שפולט אחר נצפהs, אנו יכולים להשתמש באחת משיטות ההרחבה ב- RxKotlin כדי לשלב בין הערכים הנפלטים.

באופן מיוחד, מיזוג הכל משלב את הנצפים עם flatMap:

נושא val = PublishSubject.create() val ניתן לצפייה = subject.mergeAll ()

זהה לזה של:

ניתן לצפייה על val = subject.flatMap {it}

כתוצאה מכך נצפה יפלוט את כל ערכי המקור נצפהבסדר לא מוגדר.

בדומה לכך, concatAll שימושים concatMap (הערכים נפלטים באותו סדר כמו המקורות), בזמן switchLatest שימושים switchMap (הערכים נפלטים מהפליטה האחרונה נצפה).

כפי שראינו עד כה, כל השיטות הנ"ל נקבעות זורם גם מקורות, עם אותה סמנטיקה.

5.2. שילוב הושלםס,אוליs, ו יחידס

כשיש לנו נצפה שפולט מקרים של הושלם, אולי, או יחיד, נוכל לשלב את אלה עם המתאים mergeAllXs שיטה כמו, למשל, mergeAllMaybes:

נושא val = PublishSubject.create() val נצפה = subject.mergeAllMaybes () subject.onNext (אולי.רק (1)) subject.onNext (אולי.סתם (2)) subject.onNext (אולי. מוחה ()) subject.onNext (אולי.שגיאה ( Exception ("error"))) subject.onNext (Maybe.just (3)) observable.test (). AssertValues ​​(1, 2) .assertError (Exception :: class.java)

5.3. שילוב ניתן לנידוןכך F נצפהס

לאוספים של נצפה אוֹ זורם במקום זאת, ל- RxKotlin יש כמה מפעילים אחרים, לְמַזֵג ו mergeDelayError. לשניהם יש השפעה של המשלב את כל ה - נצפהs או זורםs לאחד שיפלוט את כל הערכים ברצף:

val observables = mutableListOf (Observable.just ("first", "second")) val observable = observables.merge () observables.add (Observable.just ("השלישי", "הרביעי")) observable.test (). assertValues ("ראשון, שני, שלישי, רביעי")

ההבדל בין שני האופרטורים - שמקורם ישירות מאותם אופרטורים בשם RxJava - הוא שלהם טיפול בשגיאות.

ה לְמַזֵג השיטה פולטת שגיאות ברגע שהם נפלטים על ידי המקור:

// ... תצפיות.תוסף (Observable.error (Exception ("e"))) תצפיות.add (Observable.just ("חמישית")) // ... observable.test (). assertValues ​​("first" , "שני", "שלישי", "רביעי")

ואילו mergeDelayError פולט אותם בסוף הזרם:

// ... תצפיות.תוסף (Observable.error (Exception ("e"))) תצפיות.add (Observable.just ("חמישית")) // ... observable.test (). assertValues ​​("first" , "שני", "שלישי", "רביעי", "חמישי")

6. טיפול בערכים מסוגים שונים

בואו נסתכל כעת על שיטות ההרחבה ב- RxKotlin להתמודדות עם ערכים מסוגים שונים.

אלה גרסאות של שיטות RxJava, המשתמשות בגנריות המאוחדות של קוטלין. בפרט נוכל:

  • הטיל ערכים שנפלטו מסוג אחד למשנהו, או
  • לסנן ערכים שאינם מסוג מסוים

אז, למשל, נוכל ללהק נצפה שֶׁל מספרs לאחד מ Ints:

val observable = Observable.just (1, 1, 2, 3) observable.cast (). test (). assertValues ​​(1, 1, 2, 3)

כאן הצוות מיותר. עם זאת, כשמשלבים תצפיות שונות ביחד, אולי נצטרך את זה.

עם ofType, במקום זאת, נוכל לסנן ערכים שאינם מהסוג לו אנו מצפים:

val observable = Observable.just (1, "and", 2, "and") observable.ofType (). test (). assertValues ​​(1, 2)

כמו תמיד, ללהק ו ofType חלים על שניהם נצפהs ו- זורםס.

יתר על כן, אולי תומך גם בשיטות אלה. ה יחיד בכיתה, במקום זאת, רק תומך ללהק.

7. שיטות עוזרות אחרות

לבסוף, RxKotlin כולל מספר שיטות עוזר. בואו נסתכל במהירות.

אנחנו יכולים להשתמש מנוי מאת במקום הירשם כמנוי - זה מאפשר פרמטרים בשם:

Observable.just (1) .subscribeBy (onNext = {println (it)})

באופן דומה, לחסימת מנויים אנו יכולים להשתמש blockingSubscribeBy.

בנוסף, RxKotlin כולל כמה שיטות המחקות את אלה ב- RxJava, אך עוברות מגבלה של הסקת הסוג של Kotlin.

לדוגמא, בעת השימוש # Zip נצפה, המפרט את ריץ רץ לא נראה כל כך נהדר:

Observable.zip (Observable.just (1), Observable.just (2), BiFunction {a, b -> a + b})

כך, RxKotlin מוסיף נצפים # zip לשימוש אידיומטי יותר:

Observables.zip (Observable.just (1), Observable.just (2)) {a, b -> a + b}

שימו לב לסופי "s" ב נצפים. באופן דומה, יש לנו Flowables, Singles, ו מייבס.

8. מסקנות

במאמר זה סקרנו לעומק את ספריית RxKotlin, המגדילה את RxJava כך שה- API שלה ייראה יותר כמו קוטלין אידיומטי.

למידע נוסף, עיין בעמוד RxKotlin GitHub. לדוגמאות נוספות אנו ממליצים על בדיקות RxKotlin.

ניתן למצוא את היישום של כל הדוגמאות וקטעי הקוד בפרויקט GitHub כפרויקט Maven ו- Gradle, כך שיהיה קל לייבא ולהפעיל אותו כמות שהוא.


$config[zx-auto] not found$config[zx-overlay] not found