okay, allora questo discorso mi ha permesso di lasciarmi
iniziare a quante persone hanno familiarità con
cosa rx Java è quante persone
attualmente lo uso nella loro app va bene così
Ho intenzione di iniziare con un po ‘ di un po’
introduzione sul perché è reattivo
diventando così una grande cosa su Android e
Ho intenzione di farlo attraverso una specie di
parlando di alcuni concetti del perché noi
ho bisogno di pensare in modo reattivo e poi lo faremo
inizia a muoverti nella nostra X Java e come
in realtà ci aiuta a modellare questi modelli
cose nelle nostre applicazioni in modo particolare mi
in particolare guardare esempi
usando il nostro Java 2, che è venuta fuori in
circa un mese
va bene così perché è reattivo all’improvviso
diventare qualcosa che conosci te
ascolta un sacco di persone che parlano di te
vedo un sacco di persone che iniziano a usare I’m
andando a postulare che a meno che tu non possa
modella il tuo intero sistema della tua app in
un modo sincrono con un singolo
alla fine la sorgente asincrona
rompere il tradizionale stile imperativo
programmatore a cui siamo abituati e basta
non è una rottura nel senso che
smette di funzionare è una rottura nel senso
che spinge molto del
complessità su di te e inizi a perdere
le cose che la programmazione imperativa
in realtà è davvero bravo, quindi diamo un’occhiata
a questo attraverso un esempio di tipo di
capire perché credo che questo sia un tale
il grosso problema inizia con una classe semplice
questo può portarci un oggetto utente
e ha alcuni mutanti su di esso ora se lo siamo
vivere in un mondo sincrono un singolo
mondo filettato possiamo usare questo totalmente
bene e possiamo fare affidamento su di esso per comportarsi
esattamente come ci aspettiamo di creare un’istanza
stampare l’utente modificare alcuni dei suoi
proprietà stampare questo utente
si comporta esattamente come ci si aspetta la
il problema arriva quando dobbiamo iniziare
modellare le cose in modo asincrono
moda quindi diciamo che quando cambiamo
queste proprietà ora dobbiamo riflettere
li sul lato server quindi questi in basso
ora devono diventare due metodi
asincrono quindi come facciamo come faremmo noi
cambia il nostro codice per
come questa, una cosa che potresti fare è
niente che puoi semplicemente assumere
che la chiamata asincrona per aggiornare il
il server avrà successo e tu puoi fare il
cambia a livello locale in modo che venga riflesso
istantaneamente quando stampiamo l’utente
ovviamente questo non è una buona idea
le reti sono instabili potrebbe essere il server
restituire un errore e ora devi
conciliare il rapporto con il tuo stato
localmente potremmo fare cose semplici come
forse fornendo un runnable che ottiene
chiamato ogni volta che questa chiamata asincronica riesce
e ora siamo in realtà tipo di essere
reattivo dove stiamo solo aggiornando il
dati che vengono visualizzati quando ci siamo assicurati
che comunque è stato cambiato con successo
non stiamo modellando alcun problema
potrebbe verificarsi come se la rete finisse
non riuscendo così forse creiamo la nostra
ascoltatore così quando un errore lo fa davvero
capita che potremmo fare qualcosa con quello
potremmo segnalarlo all’utente che potremmo
riprovare automaticamente e cose del genere
funziona ed è ciò che la gente di solito il
Viale gente va giù quando hanno bisogno di
mescolare il codice asincrono con il codice
è un po ‘come correre su un singolo
filo che è tradizionalmente il
Thread principale di Android ma dove
i problemi iniziano a sorgere quando tu
davvero fare di più si deve
supportare più chiamate che si verificano il
gli utenti che ti cambiano conoscono più persone
proprietà nella tua app durante la compilazione
una forma o forse c’è forse c’è
come i flussi di queste chiamate asincrone
dove questo è il successo del primo
deve quindi attivare un altro asincrono
chiamata che può anche riuscire o fallire
Devo anche ricordare che questo è dentro
il contesto di Android e quindi c’è un
molte considerazioni aggiuntive che noi
dobbiamo prendere in considerazione così per esempio
nel nostro callback di successo forse lo siamo
propagare informazioni direttamente in
l’interfaccia utente, ma non ho davvero definito
se o non dispiace o il problema qui
è che le attività su Android sono
effimero potrebbero scomparire in qualsiasi
tempo o si riceve una telefonata e
la tua app scompare forse l’utente
preme a casa o semplicemente loro premono
e così se dicono la chiamata sincrona
ritorna dopo l’interfaccia utente è stato abbattuto
ora incontrerai dei problemi
ci sono modi imperativi per aggirare
questo possiamo sapere controllare qualche stato
prima che finiamo per modificare la vista così
non è così male che abbiamo anche questo
stiamo creando questo tipo anonimo e
quindi questo alla fine porterà a
perdita di memoria a breve termine perché è
intenzione di mantenere un riferimento al nostro
attività e se quell’attività scompare
chiamate asincrone ancora in corso
lo sfondo se vuoi saperne di più
sul perché questo è un così grande affare
sta facendo un discorso più tardi oggi
perdite di memoria che ti incoraggio ad andare
l’ultima cosa è che non l’abbiamo fatto
definiscono quali filettature questi callback sono
correndo forse tornano sul
thread di sfondo e così ora diventa
la nostra responsabilità nei confronti dell’imperativo
scrivere un codice di scrittura del codice che faccia il
filo saltando indietro sul filo principale
e così abbiamo disordinato che abbiamo ingombrato
questa attività con un sacco di cose
che sono davvero estranei all’intento
del codice che è semplicemente quello di iniziare
questo lavoro asincrono e gestire il
risultato asincrono e quindi questo è
solo ambientazione sai chiamare avidamente
questa richiesta asincrona non lo siamo
occuparsi di cose come disabilitare l’utente
gestione degli input conosci i clic dei pulsanti
più campi così quando hai il codice
come questo che si occupa solo del
caso semplice e poi improvvisamente si inizia
per trasformarlo in una vera app tutto questo
i problemi possono battere e tu sei rimasto con
gestione di un gruppo di stato un po ‘di
controlla le tue attività quindi questo è il motivo
dobbiamo pensare in modo reattivo nella nostra app
perché tutto è essenzialmente in esso
in qualche modo asincrono è
asincrono di default abbiamo il nostro
rete a cui inviamo richieste
e le cui risposte stanno tornando dopo
un lungo periodo di tempo
non possiamo bloccare il thread principale per quello
quindi deve essere fatto su uno sfondo
thread abbiamo cose come il file
sistema dove c’è la scrittura di database
archiviazione anche preferenze condivise dove noi
impossibile bloccare il thread principale per questo motivo
dobbiamo farli
thread in background l’utente è anche
un po ‘di una fonte asincrona di
dati che trasmettiamo loro dati nell’interfaccia utente
e poi reagiscono usando i clic sui pulsanti
o forse cambiando gli input nei campi di testo
e quelle cose accadono in modo asincrono
non stiamo cercando in modo sincrono l’utente
dati che stiamo aspettando finché non lo fanno
qualcosa e questo va solo a mostrare
che fondamentalmente l’interfaccia utente è un altro pezzo a
molte persone si girano pensano che tu sappia
puoi scrivere queste app a thread singolo
che di default sul thread principale ma
in realtà l’interfaccia utente è un pezzo di asincrono
fonte quindi anche se non hai il
componente dati o componente di rete
l’utente stesso è un pezzo asincrono
delle informazioni che avete a reagire a
il loro contributo in modi che hanno senso
loro quindi ecco solo un esempio di a
mucchio di dati che scorre attraverso l’app
e non sta succedendo tutto questo
in modo sincrono queste cose si basano
sulle velocità della rete avviene su velocità del disco
succede quando l’ utente fa clic
i pulsanti sono solo i dati che scorre
attraverso l’app in momenti diversi e
l’app deve essere ricettiva e reattiva
a quello in modo che non finisca in a
stato dove è il thread principale
bloccato o qualche pezzo di dati entra
in modo asincrono quando non lo eri
aspettandoselo e l’app no
rifletterlo o semplicemente si blocca e
in definitiva il tuo codice nel mezzo qui
è ciò che è responsabile della gestione
tutto questo è dove la complessità
finisce per mentire, devi averlo
mantenere tutto questo stato nel tuo
Attività frammenti o qualsiasi altra cosa a
conciliare il fatto che questi multipli
fonti asincrone stanno producendo e
consumo di dati potenzialmente diversi
tariffe e che non prende nemmeno in considerazione
account Android stesso Android è un
fondamentalmente asincrona piattaforma noi
avere cose come notifiche push noi
avere trasmissioni su tutto il sistema
anche cose come un cambio di configurazione
quando l’utente ruota il dispositivo può
vieni in qualsiasi momento e se il tuo codice non lo è
aspettandomi di entrare
si incorrerà in si incorrerà in crash
e ti imbatterai in casi in cui l’app
inizia a comportarsi male, perché alcuni
stato ottenuto qualche stato ottenuto a noi a
certa configurazione in cui la tua app
solo completamente ferma smette di reagire così
solo per tornare a questo punto se lo sono
postulare un singolo asincrono
la fonte finisce per rompere l’imperativo
programmazione se Android di default è
qualcosa di asincrono abbiamo la rete
richiede difficile trovare un’app senza
Le richieste di rete sono fondamentalmente
in modo asincrono si ha il disco
database fondamentalmente asincrono
fonte e quindi l’interfaccia utente stessa dovrebbe
alla fine si pensa come un asincrono
fonte quindi per impostazione predefinita in sostanza
tutto in Android è già
asincrono quindi aggrappandosi a più
programmazione imperativa tradizionale e
tecniche di gestione dello stato sei tu
alla fine, danneggiando ciò di cui abbiamo bisogno
fare è prendere questo modello dove il nostro codice
si trova nel mezzo come arbitro di
stato e cercando di coordinare tutti questi
cose asincrone e invece di
avendo quello possiamo rimuovere il nostro
responsabilità agganciando queste cose
direttamente in modo che possiamo cambiare l’interfaccia utente in
iscriviti direttamente al database e
semplicemente reagire quando i dati cambiano possiamo
cambia il database e la chiamata di rete
reagire solo quando si fa clic sul pulsante
invece di doverlo ricevere
fare clic e quindi inviarlo
allo stesso modo arriva la risposta della rete
indietro sarebbe bello se fosse appena aggiornato
i dati e quando sappiamo ora che quando
i dati aggiornano automaticamente l’interfaccia utente
aggiornamenti e così abbiamo rimosso il nostro
la responsabilità di farlo
se Android fa qualcosa in modo asincrono
come inizia a ruotare invia una trasmissione
sarebbe bello se fosse giusto
riflesso automaticamente nell’interfaccia utente o
automaticamente avviata o si ferma un po ‘
lavoro di background e in definitiva questo
rimuove molto del codice che dovevamo
scrivere per mantenere quegli stati
noi stessi stiamo ancora scrivendo il codice
c’è ancora il codice qui, ma tutto quello che siamo
fare ora collega i bit
insieme in un modo che abbia un senso
invece di provare a gestire lo stato di
tutti emettendo e consumando
eventi
quindi in ultima analisi, questo è dove si arriva a
il nostro X Java e questo è diventato il
di fatto della libreria reattiva per Android
principalmente a causa del fatto che era uno
del primo disponibile per Java che era
davvero completo e anche per la nostra X
Java 2 perché mantiene il supporto per
tutte le versioni di Java di cui abbiamo bisogno
Android si riduce a fornire tre
cose importanti è un insieme di tipi per
rappresentare queste fonti di dati e
allora abbiamo un set di tipi per
abbonarsi a quei dati e ascoltare
a quando cambia e poi finalmente il
la parte più potente è un sacco di metodi
che ti permettono di combinare la composizione
trasformare quei dati in modo che possiamo finire
creando quei collegamenti tra il
diverse fonti di dati asincroni
e le cose che vogliono iscriversi
e mostralo iniziamo guardando
a ciò che i primi due cosa i primi due
sembra nell’API quindi una fonte di dati
di solito ciò che accadrà sarà
iniziare o smettere di fare un po ‘di lavoro quando si
inizia ad ascoltarlo a cui puoi pensare
questo come una richiesta di rete che non lo è
andando a sparare finché non inizi ad ascoltare
per una risposta e quando tu se tu
alla fine finiscono per annullare l’iscrizione
quella fonte di dati prima che si completi
potrebbe potenzialmente funzionare dicendo
cancellando le richieste di rete queste possono
essere sia sincrono che asincrono e
così puoi modellare qualcosa come a
richiesta di rete che sta bloccando ma
in esecuzione su una trama di sfondo all’indietro
o può essere asincrono che è
qualcosa come qualcosa come chiamare
su Android e in attesa di un’attività
risultato o anche come clic nell’interfaccia utente o
può essere pensato come sei asincrono
non bloccando in attesa di un clic sei
basta reagire al fatto che un clic
è accaduto
di solito questi possono produrre un singolo oggetto
o forse molti oggetti fino a quando mi piace
la risposta di rete sarebbe un singolo elemento
per una singola richiesta ma un flusso di
i clic del pulsante potrebbero essere potenzialmente
infinito finché l’interfaccia utente è lì
anche se sei solo tu lo sai
sottoscrivendo un singolo pulsante questi
può anche essere vuoto e quindi c’è il
idea di una fonte che solo in realtà
ha successo o fallisce e in realtà non lo è
hai qualche cosa in cui puoi pensare a questo
come scrivere su un database o scrivere a
un file in realtà non ha una risposta
in realtà non ha un oggetto che
puoi sapere di ritornarti davvero?
solo tipo di completamenti o fallimenti e così via
questo aspetto di completamento e fallimento è
in realtà modellato da fonti nel nostro Java
con questi cosiddetti eventi terminali
che è o completa
con successo o errori questo è
simile a te conosce un metodo che può
tornare normalmente o un’eccezione che
inoltre non può mai terminare così da tornare indietro
per l’esempio del clic sul pulsante, se lo fossimo
clic sul pulsante di modellazione come fonte di
dati che non finiranno mai fino a quando il tuo
L’interfaccia utente è lì e quando l’interfaccia utente scompare
probabilmente stai cancellando la sottoscrizione da quello
l’origine dei clic sui pulsanti non è così
in realtà completando davvero questo tutto
equivale solo a un’implementazione del
modello di osservatore tradizionale che abbiamo
qualche cosa che può produrre dati e
allora abbiamo un contratto per quello
i dati sembrano e tutto ciò che stiamo facendo è
voglio solo osservare che vogliamo
aggiungi un ascoltatore e ricevi una notifica
quando le cose accadono i due tipi principali
che rappresenteranno questo nel nostro
java two è osservabile e scorrevole e
questi entrambi finiscono per modellare il
stessi tipi di dati e che possono essere 0 a
n elementi in modo che io possa sapere essere vuoto può
avere un singolo oggetto o potenzialmente molti
e poi terminano entrambi
con successo o terminano con un
errore ma perché abbiamo bisogno di due tipi per
rappresentano la stessa struttura di dati
questo si riduce a qualcosa chiamato
contropressione
Non voglio immergermi troppo
molto che cosa è la contropressione perché è a
argomento complesso ma ho intenzione di provare e
mostraci un esempio che dovrebbe
illustrare la differenza che pressione
è lì per consentire di rallentare a
fonte di dati in cui sai che stiamo vivendo
questi sistemi che hanno
risorse limitate e puoi solo
processo così tanto in un momento contropressione
è un modo per dire semplicemente il
persone che ti inviano dati così da rallentare
che non puoi elaborarlo alla velocità di
loro stanno inviando il nostro Excel che aveva
contropressione ma è stata implementata
abbastanza tardi nel processo API e così via
tutto ciò che ogni tipo di sistema aveva
contropressione invece di rx Java a
dove abbiamo due tipi e dove questo
è diventato uno svantaggio è che mentre tutti
i tipi espongono l’idea della contropressione
l’idea di poterli rallentare
non tutte le fonti lo hanno effettivamente implementato
quindi alla fine avresti un incidente
non era supportato in fase di esecuzione e questo
è perché contropressione come sai
come l’ereditarietà devi davvero
il design per questo deve essere una cosa che tu
conto in anticipo invece di
qualcosa che qualcosa che ottiene
mescolato in seguito e questo è davvero
perché abbiamo due tipi distinti in rx
Java 2 perché ora puoi dettare
il sistema tipo se la contropressione è
supportato o no perché se non lo è
è qualcosa che va bene, ma è così
anche qualcosa che devi esporre
in API modo l’esempio che
mostrerebbe questo è se abbiamo una fonte
dei dati che è dire che gli eventi di tocco le
l’utente mette il dito sullo schermo e
lo trascinano e questo produce a
serie di eventi di tocco ora questo è
qualcosa che non possiamo davvero rallentare
giù non possiamo davvero dire l’utente che si
sai disegnare metà della tua curva e poi
fermati e aspetta mentre raggiungo il disegno
e quindi puoi continuare il resto di
la tua curva li vogliamo noi possiamo
potenzialmente farlo attraverso altri modi
come ad esempio disattivare i pulsanti e
visualizzare altra interfaccia utente per cercare di rallentarli
giù ma la fonte dei dati stessi
non è uno che può essere rallentato se
hanno già disegnato quella curva con a
un sacco di eventi che non possiamo dire al sistema
puoi rallentarli mandandoli via
confrontalo con qualcosa come a
database in cui abbiamo un grande risultato
set e forse vorremmo solo tirare
fuori certe righe a
Potrei dire oh voglio solo il primo
quattro file okay ora dammi altri tre
file okay ora dammi altre cinque righe a
il database può modellarlo davvero bene
il concetto di cursori ma un evento di tocco
un flusso di eventi tattili non può essere modellato
questo perché non c’è modo di farlo
respingi e rallenta il dito dell’utente
e così nel nostro esempio si vedrebbe
entrambi questi tipi implementati come
osservabili e cosa succederebbe a
runtime si potrebbe provare e applicare nuovamente
pressione e alla fine ottieni un
l’eccezione nell’app si blocca in questo modo
il motivo per cui nel nostro java due modelliamo
loro come tipi diversi perché uno
fondamentalmente può supportare la contropressione
e fondamentalmente non può esserci
modi di convertire tra i due quali
fondamentalmente sta solo applicando una strategia di
come funziona la contropressione ma non lo sono
entrerò in quello così perché questi
sono due tipi diversi che devono
esporre questa contropressione in qualche modo
ma perché anche loro modellano lo stesso
tipo di dati che hanno anche a tipo di
appaiono allo stesso modo in termini di come i dati
viene spinto nei tuoi richiami così il
due interfacce per ascoltare gli eventi
da queste fonti sembra abbastanza simile
il primo metodo viene chiamato next e
questo è il metodo in cui gli oggetti stanno andando
da consegnare e così il più a lungo
sono più è più di uno o più
oggetti prodotti dall’osservabile
o scorrevole questo metodo verrà chiamato
per ognuno che ti permette di fare
qualunque cosa faccia qualsiasi elaborazione tu voglia
a che fare con gli articoli anche questo potrebbe essere
infinito giusto ho parlato di infinito
osservabili come i clic sui pulsanti, quindi se
stai ascoltando un pulsante fai clic su questo
sul prossimo metodo sarà sostanzialmente chiamato
ogni volta che l’utente fa clic su un
pulsante per fonti di fonti non infinite
che in realtà finiamo con quei due
eventi terminali che possiamo completare
dove completo indica il successo o loro
può errore dove l’errore lo indica
o elaborando la prossima richiamata
ha generato un’eccezione
o che la fonte di dati dove siamo
ascoltare gli eventi ha avuto un problema
e ha dovuto fornire un errore ed entrambi
incompleto e su errore come si chiama
eventi terminali che significano che non lo farai mai
ricevi un’altra richiamata dopo averla ricevuta
o uno di quelli e così dove loro
differire è in questo ultimo metodo chiamato
iscriviti se lo sei se conosci il nostro
spalare uno questo è qualcosa che è
abbastanza nuovo ed è fondamentalmente l’idea
che quando ti abboni a uno dei due
osservabile o scorrevole sei veramente
creando una risorsa e risorse simili
spesso hai bisogno di ripulire quando hai finito
con loro e quindi questo su abbonamento
il callback sarà immediatamente chiamato come
appena inizi ad ascoltare un
osservabile o scorrevole e lo farà
mano per uno di questi due tipi
osservabile ciò che questo tipo ti permette di
fare è chiamare il metodo di smaltimento che
essenzialmente dice che ho finito con questo
risorsa Non voglio più altre callback
e quindi se abbiamo conosciuto una rete
richiedere ciò potrebbe potenzialmente annullare
la richiesta di rete se stai ascoltando
a quel flusso infinito di clic del pulsante
questo fondamentalmente direbbe che tu no
più voglia di riceverli e basta
disattiverebbe l’ascoltatore sulla vista ora
lo stesso vale per il tipo on
fluida anche se ha un diverso
nome l’uso è lo stesso che ha questo
annulla il metodo che è essenzialmente il
come gli articoli usa e getta smaltiscono il
la differenza qui è che ha un secondo
metodo chiamato richiesta ed è qui
contropressione
si mostra nell’API questa richiesta
il metodo è come dici quello scorrevole
vuoi più oggetti quindi vado a
costruisci un piccolo grafico qui di come
queste cose riguardano l’un l’ altro così noi
possiamo sostanzialmente rappresentare qualcuno di te
sapere che qualsiasi tipo di emissioni potrebbe essere zero
potrebbe essere uno potrebbe essere molti e
potenzialmente potrebbe completare o
potenzialmente errore e l’unico
la differenza tra i due è quella
ha una contropressione e uno non solo
molto rapidamente voglio toccare sul perché
perché il monouso e abbonarsi
i tipi di abbonamento sono nominati così
in modo diverso e perché i loro metodi
uno è disposto e uno è annullato
invece di conoscerti
estendendo l’altro e aggiungendo semplicemente il
il metodo di richiesta è perché
c’è questa cosa chiamata reattiva
specifica flusso era fondamentalmente un
iniziativa dove un gruppo di aziende
si è riunito e ha detto facciamo un
set standard di interfacce per reattivo
librerie in Java e finirono con
piuttosto queste quattro classi per interfacce
e così vedrai l’abbonato
digita e il tipo di abbonamento nel
al centro ci sono in realtà parte di
le specifiche e quindi è per questo che loro
avere un nome così diverso dal
quelli il tipo usa e getta e il
tipo di osservatore sono diversi perché
fanno parte di uno standard e non possiamo
cambia davvero il vantaggio però
è perché è uno standard
anche se questo non succede frequentemente
su Android ma se dovessi usare due
diverse librerie per i flussi se loro
entrambi implementano lo standard che puoi
convertire tra loro senza problemi e così via
Ho intenzione di cambiare la mia colonna di sinistra qui
essere effettivamente i tipi che implementano il
specifica del flusso reattivo e il
i tipi a destra sono ciò che implica
che la contropressione è supportata e il
i tipi sulla destra sono quelli che fanno
non avere indietro la pressione se torniamo a
il nostro user manager prima eravamo una specie di
estraendo gli utenti da questa classe e poi
mostrandoli quando pensavamo che fosse
più appropriato e ora mentre ciò che noi
può fare è modellare questo come invece a
osservabile dall’utente è una fonte di utente
oggetti che ogni volta che l’utente cambia
verrà informato di tale modifica e potrà
reagire al cambiamento mostrandolo
invece di cercare di indovinare di più
il tempo appropriato si basa su altro
eventi che accadono nel sistema c’è a
accoppiare fonti specializzate nel nostro Java
ed è fondamentalmente un sottoinsieme del
osservabile quindi non c’è tre di loro
il primo si chiama single anche questo
ha un singolo oggetto o un errore, quindi è così
meno di meno di un flusso e più giusto
come una fonte potenzialmente asincrona
di un singolo
e inoltre non ha contropressione
il modo di pensare a questo è un po ‘
come uno scalatore, così tu chiami un metodo
ottenere un tipo di ritorno si ottiene un valore di ritorno
o quel metodo genera un’eccezione
single essenzialmente modella lo stesso
concetto ti iscrivi a un singolo tu
o riprendi il tuo oggetto o ottieni un
errore la differenza è che è
reattivo completabile simile a un metodo
questo dichiara un tipo di reso vuoto così
completa senza dati o genera
un’eccezione ha un tipo di errore di pensare
di questo è come una corsa reattiva è
un set di codice che puoi eseguire e mentre
o completare con successo o fallire a
nuovo tipo nel nostro java 2 rispetto al nostro
java uno si chiama forse e questo
ha errori di un articolo o potenzialmente
non ha elementi il modo di pensare a questo è
è un po ‘ come un optional quindi a
metodo che restituisce un valore opzionale
restituirà sempre qualcosa se questo
non lancia un’eccezione, ma quella
facoltativo può o non può avere un valore e
quindi vedremo quando questi stanno per essere
usato in un secondo ma questo è simile a
il concetto opzionale eccetto giusto
reattivo quindi non c’è nessun tipo
in realtà modellano ciò che sono reattivi
flussi conformi nell’archetipo di due
sono modellati solo nell’osservabile
e backpressure free side quindi se il nostro set
il nome e impostare le chiamate per età sono asincrone
o completano o falliscono
davvero restituire i dati e quindi ciò che vogliamo
fare è modellare quelli come completabile sono
andando a passare questo molto rapidamente
solo per mostrare come sono queste fonti
creato e come puoi avvolgere le cose
che stai già utilizzando reattivo
tutte le fonti sono statiche
metodi che ti permettono di crearli
con valori scalari simili puoi anche
crearli da cose come matrici o
tutto ciò che è iterable ma ce ne sono due
che sono veramente utili
Penso che il nostro sarà il più usato
per adattare i metodi e il
azioni che stai già facendo
modo sincrono o asincrono
il primo è chiamato da Kabul da
Kabul stava essenzialmente modellando alcuni
comportamento sincrono che restituisce a
valore singolo in questo caso che sto delegando
ad un metodo ipotetico chiamato get
nome e la cosa bella di Kabul
è che ti è permesso lanciare un
eccezione da un callable che è a
interfaccia Java standard significa questo
possiamo modellare cose che farebbero
potenzialmente non riescono a utilizzare un controllo
eccezione quindi se abbiamo una richiesta HTTP
che vogliamo fare ciò che potrebbe lanciare
un’eccezione I / O ora possiamo metterlo
al suo interno da Colleyville e il
restituito osservabile quando sottoscritto
eseguirà quella richiesta e se questo
richiesta genera un’eccezione otterremo un
on-air, se la richiesta è completa, lo faremo
ottenere la risposta e il prossimo da
palle di chiamata disponibili su tutti e cinque
tipi e così questi sono per la modellazione
fonti sincrone di un singolo pezzo di
dati è quello che useresti un metodo
per in un mondo imperativo un metodo che
restituisce un valore di ritorno nel reattivo
il mondo di Kabul è ciò che usi
modello che ce ne sono anche altri due
metodi su entrambi e forse completabili
e quelli permettono di modellare le cose che
non restituire un valore così come ho detto
fondamentalmente solo un eseguibile tranne che
runnable è ora tutto più reattivo
potente metodo per creare osservabili
è giustamente chiamato creare se si utilizza rx
viaggio uno si potrebbe sapere che creare è
questo metodo orribile che tu davvero
non dovrebbe mai usare un arco pala uno
nel nostro Java due è stato risolto così
che il metodo di creazione è in realtà uno
dei metodi più utili e dovrebbe essere
usato per il wrapping di sorgenti lo creiamo
con una richiamata e quindi questa richiamata
viene chiamato ogni volta che c’è un nuovo
abbonato e ci viene data questa cosa
chiamato un emettitore e l’emettitore è
fondamentalmente solo la persona che è
ascoltando così possiamo prendere giorno
e possiamo inviarlo all’emettitore e in
questo esempio, quello che sto facendo è che sono solo
inviare un pezzo di dati in modo sincrono
e poi sto completando il flusso
perché è stato completato con successo
andando a convertire questo in un lambda in
pulisci un po ‘del boilerplate qui così
Posso inviare più di un pezzo di pezzo
di dati
a differenza del ciottolo, ho la capacità di
chiamare il prossimo più volte
l’altro vantaggio di questo è che noi
ora è in grado di modellare pezzi asincroni di
dati se prendo richieste H TDP e
invece di eseguirlo in modo sincrono
eseguito in modo asincrono posso chiamarlo
il metodo seguente l’emettitore dal
Callback HTTP un altro vantaggio di
questo metodo di creazione ti consente di farlo
cose quando la persona si disiscrive
quindi se qualcuno smette di ascoltare il
Richiesta HTTP non c’è motivo per farlo
continua eseguendo ora possiamo aggiungere un
azione di cancellazione che annulla il
Richiesta HTTP e ripulisce le risorse
questo è anche super utile per Android
perché è il modo in cui modelliamo le interazioni
con l’interfaccia utente quando ti abboni a un
osservabile vogliamo dire iniziare
ascoltando i clic sui pulsanti e poi quando
ti cancelli dall’iscrizione, vogliamo rimuoverlo
ascoltatore quindi non finiamo sai
perdendo un riferimento che perde questo
riferimento alla creazione della vista
osservabili funziona su tutto ciò che sono
creando osservabili con questo emettitore
funziona su tutti e cinque i tipi, facciamo in fretta
guarda le fonti di osservazione così ho mostrato
queste due interfacce precedenti e io
ha mostrato che quel quarto metodo che è
tipo di nuovo ed è un po ‘strano te
in realtà non usare queste interfacce
direttamente quando ti abboni a un
l’ abbonamento osservabile è il metodo
quello che inizia ad ascoltare a causa di
Quel quarto metodo ti viene messo in uno strano
posto dove bene cosa faccio con questo
oggetto e come faccio a sapere?
disiscriversi invece abbiamo un tipo
chiamato osservatore usa e getta e questa volontà
gestisci automaticamente quel quarto
metodo per te e ti permettono di essere solo
preoccupato per le notifiche effettive
dall’osservabile stesso, ma come facciamo noi
smaltire qui se non lo abbiamo più
callback come facciamo come cancelliamo l’iscrizione
come diciamo la risorsa che vogliamo
per andare via una cosa che potresti fare è
aggrappatevi a quell’osservatore in realtà
strumenti usa e getta in modo da poter chiamare
il metodo dispose e provvederà
di inoltrarlo a te
la catena ma c’è un nuovo metodo in
il nostro kravitz che hai chiamato iscriviti
e quindi questo consente di utilizzare in un
modo simile a quello che faresti se lo sei
usando un archivio che è quello che ora
ti restituisce la cosa che puoi allora
Chiamare disporre in archivio uno questo è
chiamato un abbonamento è anche chiamato a
abbonamento nel mondo scorrevole ma
nel mondo osservabile è un
usa e getta per le persone che conoscono
abbonamento composito c’è a
composito monouso e questo fondamentalmente
ti permette di iscriverti a più persone
i flussi prendono quelli appena ritornano
articoli usa e getta e li aggiungo a ciò che è
essenzialmente un elenco di articoli usa e getta e
puoi annullare l’iscrizione a più persone
flussi allo stesso tempo vedrai questo molto in
Android dove hai un singolo
composito usa e getta per te conosci un
attività un frammento o qualunque e il tuo
disiscrivendo nel sai su distruggere
o qualunque sia il callback del ciclo di vita
appropriato in modo da averli su tutti
quattro per non contropressione dove
digita quelli che usano osservatore e
ce n’è davvero una anche globale
sebbene flowable usi l’abbonamento
callback non il non disponibile
il tipo che forniamo nel nostro java a
in realtà ti permette di modellarlo nel
allo stesso modo in modo da ottenere un dorso usa e getta
da tutti e cinque i tipi anche se scorrevoli
è un po ‘ diverso il
il modo di pensare a questo è come faresti tu
pensa a tutto ciò che è una risorsa a
file un cursore su un database che non vorresti
aprire un file senza averne alcun modo
chiudilo non avresti aperto il cursore su a
database senza alla fine chiuderlo
mai sottoscrivere un osservabile senza
gestendo il monouso e in definitiva
annullando l’iscrizione va bene così erano quelli
i tipi sono davvero molto veloci
guarda i metodi che ti permettono di
componi e modifica i dati che chiamiamo
questi operatori e lo fanno fondamentalmente
tre cose manipolano o combinano i dati
cambiano la semantica del threading
oppure possono avviare e fermare le emissioni
stiamo solo andando a guardare il
i primi due e proprio come abbiamo fatto
qualcosa che era imperativo come a
chiamata al metodo sincrono e attivata
gli operatori reattivi fondamentalmente fanno lo stesso
cosa così qui stiamo applicando un
operazione su una stringa e ritorno a
nuova corda nel mondo reattivo noi
avrebbe un osservabile e lo faremmo
applicare tale operazione tramite un operatore in
questa mappa del caso è l’operatore che è
permettendoci di prendere i dati emessi
e applicare alcune operazioni ad esso per creare
un nuovo tipo di dati che sono in realtà
andando a saltare questo così se guardiamo
il nostro oggetto utente lo abbiamo definito
originariamente i richiami stavano arrivando
di nuovo su un thread in background e abbiamo avuto
per passare esplicitamente al thread principale
c’è in realtà un operatore integrato
che ti permette di farlo e permette
per farlo in modo molto più dichiarativo
modo in modo che possiamo dire che voglio osservare
emissioni da questo osservabili su a
thread diversi e così le cose
proveniente dall’utente sarà sul
thread di sfondo ma le cose stanno arrivando
l’utente principale di thread sarà ora attivo
il thread principale osserva di essere il
operatore qui e quindi questo perché siamo
cambiando i fili l’ordine che tu
applicare questi operatori è davvero importante
simile bisogno di osservare su possiamo cambiare
il dove il lavoro dell’osservabile
succede così se stiamo facendo una rete
richiesta che la richiesta di rete sia ancora
andando a fare in modo sincrono ma noi
non voglio che accada sul principale
thread quindi quello che facciamo è che possiamo applicare un
operatore che cambia dove ci iscriviamo
essere osservabili e dove ci iscriviamo
è dove il lavoro alla fine accade così
ora quando ci iscriviamo al nostro background
risposta cambierà in
thread in background che IO è solo un
pool di thread di thread che è possibile utilizzare e
quindi funzionerà su quel pool di thread
e quindi inviare la notifica a
chi sta ascoltando, iscriviti qui
essere l’ operatore per cambiare dove
il lavoro accade
e ciò che è bello è questo perché questi
tutto è tornato, conosci nuovi osservabili e
tutti gli osservabili tutti questi metodi
esistono su osservabili possiamo comporli
e incatenarli insieme così che tu
normalmente vediamo è che non abbiamo
variabili intermedie per questi siamo
basta applicare gli operatori in un certo
ordine in modo che vogliamo una risposta o ci dispiace
vuoi richiedere l’esecuzione su a
filo di fondo vogliamo osservare il
risultato di quella richiesta sul principale
filo e vogliamo dire cambiare il
la risposta in te conosce una stringa che vogliamo
per leggere la stringa eccetto di nuovo ordine
qui conta così perché ho applicato il
l’operatore della mappa dopo aver osservato su quello è
andando a girare sul thread principale di androids e
non vogliamo leggere da HTTP
risposta sul thread principale che vogliamo
stare succedendo prima di passare al
thread principale e quindi la richiesta arriva
e sai che tu non rispondi alla risposta
giù la catena osservabile mappiamo quello
nella stringa dei risultati e poi noi
cambia i thread nel thread principale dove
possiamo infine abbonarci e mostrarlo
nell’interfaccia utente e poi ce ne sono altri
gli operatori ho saltato la mappa piana così semplicemente
tenerlo qui così dove vediamo alcuni di
questi altri tipi, quindi lo noterai
questi erano tutti osservabili c’è dell’altro
operatori che abbiamo effettivamente che in realtà
prendere osservabile e restituirlo in a
tipo diverso e quindi un operatore come
prima sta andando a prendere il primo elemento
viene emesso da un flusso e restituito
a voi nel nostro esempio, siamo tornati
ed osservabile che ne ha emesso solo uno
questo è un po ‘strano perché se
hai una lista di oggetti e chiami
sali su per ottenere il primo oggetto
non recuperare una lista con un solo oggetto
quello che ottieni è uno scalare e noi
sappi che ora abbiamo un tipo
modella uno scalare nel mondo reattivo
così nel nostro java 2 quando lo chiami
primo operatore che è garantito a
restituire solo un elemento che si ottiene a
single se l’osservabile è vuoto questo
genererà effettivamente un errore perché
sappiamo che una singola ha o un oggetto o
errori e quindi ci sono altri operatori
come il primo elemento
in realtà ti restituirà ora a
forse e così quando un forse o quando il
osservabile è vuoto forse può effettivamente
modellare quello completando senza un
errore ce ne sono anche quelli che ritornano
completabile quindi se stai semplicemente ignorando
gli elementi che ti stanno a cuore
completa o fallisce che ora ritorna
completabile che è esattamente ciò che
modelli completabili su cui tutto questo esiste
scorrevoli e quindi hanno tutti il
stessi operatori tutti li restituiscono
stessi tipi specializzati questo è un grafico
questo tipo mostra alcuni degli operatori
e l’ angolo in alto a destra di questo
è fondamentalmente dove i tipi si restringono così
quando chiami qualcosa come vuoi
conta il numero di elementi in un flusso
l’account è sempre un singolo valore così tu
prendi un tipo più ristretto come single e poi
abbiamo anche operatori che fanno il
di fronte al quale si sa prendere un tipo
e trasformarlo in qualcosa di più ampio così
potresti prendere un singolo e trasformarlo in
un ok osservabile al nostro originale
esempio se vogliamo essere reattivi con
possiamo sapere come iscriversi al nostro utente
dire che voglio le notifiche sul principale
filo e poi voglio spingere quello
nell’interfaccia utente visualizzare quell’utente in qualsiasi momento
l’ utente cambia questo codice
automaticamente andando a correre lo farai
vedere automaticamente gli aggiornamenti e noi no
avere più preoccuparsi di gestire questo
noi stessi però dobbiamo ricordare
per gestire il monouso che ottiene
restituito perché siamo dentro o nel
Mondo Android e quando la nostra attività
scompare vogliamo che questo codice si fermi
correndo così a non distruggere ti faremmo
sapere smaltire questo smaltimento del
articoli usa e getta allo stesso modo quando alla fine
fare una richiesta asincrona per cambiare
dati che vogliamo che succedano su a
filo di fondo vogliamo osservare il
risultato sul thread principale indipendentemente dal fatto
succede o fallisce e tu sai nel
callback di successo che potremmo sapere
potenzialmente come riattivare la casella di testo
o qualsiasi altra cosa e ancora perché tu
non aprirebbe un file senza chiuderlo
non ti iscriveresti senza la gestione
il monouso così aggiungiamo questo al nostro
lista usa e getta
In realtà sto per saltare questo
perché sono un po ‘in ritardo ma a
bella cosa della nostra Java – rispetto a
il nostro Java è che c’è un
spostamento di architettura fondamentale e cosa
ciò che è particolarmente adatto su Android
che c’è solo meno intermedio
oggetti creati così quando crei
questi flussi ogni operatore che chiami
deve restituire una nuova osservabile che
implementa quel comportamento quando chiami
mappa ottieni un nuovo osservabile che prende
il vecchio esegue una funzione e tu sai
emette i nuovi dati e così richiede
un mucchio di oggetti oggetti intermedi
essere assegnato per modellarlo
stream rx Java in realtà ha cambiato il modo
questo funziona in un modo che effettivamente otteniamo
meno oggetti intermedi creati oops I
volevo in modo da ottenere meno allocazione a
in realtà creare il flusso che è chiamata
gli operatori ognuno effettivamente risultati
in un oggetto in meno che viene creato c’è
anche meno spese generali quando si sottoscrive a
streaming c’è metodo meno della spedizione che
deve accadere e così alla fine ciò che noi
ottenere è un GC meno veloce che causa meno GC
versione della libreria senza nessuno
compromesso nell’API in modo da viaggiare – è
fondamentalmente questa idea che vogliamo prendere
queste cose che sono fondamentalmente
sia asincrono in Android
la rete Android stesso database anche
l’interfaccia utente è stata modellata come sorgente asincrona
e scrivere il codice che reagisce ai cambiamenti in
queste fonti invece di cercare di far fronte
con cambiamenti e gestire noi stessi
in questo momento è in un’anteprima dello sviluppatore
rilascio quindi stiamo fondamentalmente finalizzando
l’API e tra circa un mese lo farà
avere il suo rilascio finale dove sarà
disponibile voglio dire che è già disponibile
inserire la tua app, ma l’API potrebbe
cambia e la versione finale si solidifica
l’API in modo che cose come le librerie
può iniziare ad usarlo e di esporre questi
digita automaticamente se usi rx
il doppio di uno è in realtà un progetto
che ti permette di convertire tra il
tipi
e così questo ti permetterà di
aggiorna la tua app in modo incrementale, se lo sei
interessato a questo ecco il link e
quindi le tue dipendenze per quella volontà
alla fine assomiglia a questo
e così dove voglio finire è fondamentalmente
il nostro viaggio verso X non è qualcosa di nuovo
la programmazione reattiva non è nuova di
qualsiasi allungamento ma Android stesso per
qualunque ragione sia questa altamente reattiva
mondo che ci è stato insegnato a modellare
moda imperiosa e molto imperativa
prova solo ad affrontare il fatto che noi
devono gestire tutte queste cose
noi stessi e la programmazione reattiva in
il nostro Java in generale ci consente di modellare
è nel modo giusto che è quello che è
asincrono
abbracciare l’ asincronia di questi
fonti e invece di cercare di gestire
tutto lo stato noi stessi li compongono
insieme in modo tale che la nostra app diventi veramente
reattivo e ora davvero tutto ciò che siamo
preoccupato è come costruirli
frecce e non in realtà come gestirle
lo stato dei dati che scorre
attraverso il sistema e quindi questo è tutto me stesso
avere per te grazie a tutti per essere venuti
tu
iniziare a quante persone hanno familiarità con
cosa rx Java è quante persone
attualmente lo uso nella loro app va bene così
Ho intenzione di iniziare con un po ‘ di un po’
introduzione sul perché è reattivo
diventando così una grande cosa su Android e
Ho intenzione di farlo attraverso una specie di
parlando di alcuni concetti del perché noi
ho bisogno di pensare in modo reattivo e poi lo faremo
inizia a muoverti nella nostra X Java e come
in realtà ci aiuta a modellare questi modelli
cose nelle nostre applicazioni in modo particolare mi
in particolare guardare esempi
usando il nostro Java 2, che è venuta fuori in
circa un mese
va bene così perché è reattivo all’improvviso
diventare qualcosa che conosci te
ascolta un sacco di persone che parlano di te
vedo un sacco di persone che iniziano a usare I’m
andando a postulare che a meno che tu non possa
modella il tuo intero sistema della tua app in
un modo sincrono con un singolo
alla fine la sorgente asincrona
rompere il tradizionale stile imperativo
programmatore a cui siamo abituati e basta
non è una rottura nel senso che
smette di funzionare è una rottura nel senso
che spinge molto del
complessità su di te e inizi a perdere
le cose che la programmazione imperativa
in realtà è davvero bravo, quindi diamo un’occhiata
a questo attraverso un esempio di tipo di
capire perché credo che questo sia un tale
il grosso problema inizia con una classe semplice
questo può portarci un oggetto utente
e ha alcuni mutanti su di esso ora se lo siamo
vivere in un mondo sincrono un singolo
mondo filettato possiamo usare questo totalmente
bene e possiamo fare affidamento su di esso per comportarsi
esattamente come ci aspettiamo di creare un’istanza
stampare l’utente modificare alcuni dei suoi
proprietà stampare questo utente
si comporta esattamente come ci si aspetta la
il problema arriva quando dobbiamo iniziare
modellare le cose in modo asincrono
moda quindi diciamo che quando cambiamo
queste proprietà ora dobbiamo riflettere
li sul lato server quindi questi in basso
ora devono diventare due metodi
asincrono quindi come facciamo come faremmo noi
cambia il nostro codice per
come questa, una cosa che potresti fare è
niente che puoi semplicemente assumere
che la chiamata asincrona per aggiornare il
il server avrà successo e tu puoi fare il
cambia a livello locale in modo che venga riflesso
istantaneamente quando stampiamo l’utente
ovviamente questo non è una buona idea
le reti sono instabili potrebbe essere il server
restituire un errore e ora devi
conciliare il rapporto con il tuo stato
localmente potremmo fare cose semplici come
forse fornendo un runnable che ottiene
chiamato ogni volta che questa chiamata asincronica riesce
e ora siamo in realtà tipo di essere
reattivo dove stiamo solo aggiornando il
dati che vengono visualizzati quando ci siamo assicurati
che comunque è stato cambiato con successo
non stiamo modellando alcun problema
potrebbe verificarsi come se la rete finisse
non riuscendo così forse creiamo la nostra
ascoltatore così quando un errore lo fa davvero
capita che potremmo fare qualcosa con quello
potremmo segnalarlo all’utente che potremmo
riprovare automaticamente e cose del genere
funziona ed è ciò che la gente di solito il
Viale gente va giù quando hanno bisogno di
mescolare il codice asincrono con il codice
è un po ‘come correre su un singolo
filo che è tradizionalmente il
Thread principale di Android ma dove
i problemi iniziano a sorgere quando tu
davvero fare di più si deve
supportare più chiamate che si verificano il
gli utenti che ti cambiano conoscono più persone
proprietà nella tua app durante la compilazione
una forma o forse c’è forse c’è
come i flussi di queste chiamate asincrone
dove questo è il successo del primo
deve quindi attivare un altro asincrono
chiamata che può anche riuscire o fallire
Devo anche ricordare che questo è dentro
il contesto di Android e quindi c’è un
molte considerazioni aggiuntive che noi
dobbiamo prendere in considerazione così per esempio
nel nostro callback di successo forse lo siamo
propagare informazioni direttamente in
l’interfaccia utente, ma non ho davvero definito
se o non dispiace o il problema qui
è che le attività su Android sono
effimero potrebbero scomparire in qualsiasi
tempo o si riceve una telefonata e
la tua app scompare forse l’utente
preme a casa o semplicemente loro premono
e così se dicono la chiamata sincrona
ritorna dopo l’interfaccia utente è stato abbattuto
ora incontrerai dei problemi
ci sono modi imperativi per aggirare
questo possiamo sapere controllare qualche stato
prima che finiamo per modificare la vista così
non è così male che abbiamo anche questo
stiamo creando questo tipo anonimo e
quindi questo alla fine porterà a
perdita di memoria a breve termine perché è
intenzione di mantenere un riferimento al nostro
attività e se quell’attività scompare
chiamate asincrone ancora in corso
lo sfondo se vuoi saperne di più
sul perché questo è un così grande affare
sta facendo un discorso più tardi oggi
perdite di memoria che ti incoraggio ad andare
l’ultima cosa è che non l’abbiamo fatto
definiscono quali filettature questi callback sono
correndo forse tornano sul
thread di sfondo e così ora diventa
la nostra responsabilità nei confronti dell’imperativo
scrivere un codice di scrittura del codice che faccia il
filo saltando indietro sul filo principale
e così abbiamo disordinato che abbiamo ingombrato
questa attività con un sacco di cose
che sono davvero estranei all’intento
del codice che è semplicemente quello di iniziare
questo lavoro asincrono e gestire il
risultato asincrono e quindi questo è
solo ambientazione sai chiamare avidamente
questa richiesta asincrona non lo siamo
occuparsi di cose come disabilitare l’utente
gestione degli input conosci i clic dei pulsanti
più campi così quando hai il codice
come questo che si occupa solo del
caso semplice e poi improvvisamente si inizia
per trasformarlo in una vera app tutto questo
i problemi possono battere e tu sei rimasto con
gestione di un gruppo di stato un po ‘di
controlla le tue attività quindi questo è il motivo
dobbiamo pensare in modo reattivo nella nostra app
perché tutto è essenzialmente in esso
in qualche modo asincrono è
asincrono di default abbiamo il nostro
rete a cui inviamo richieste
e le cui risposte stanno tornando dopo
un lungo periodo di tempo
non possiamo bloccare il thread principale per quello
quindi deve essere fatto su uno sfondo
thread abbiamo cose come il file
sistema dove c’è la scrittura di database
archiviazione anche preferenze condivise dove noi
impossibile bloccare il thread principale per questo motivo
dobbiamo farli
thread in background l’utente è anche
un po ‘di una fonte asincrona di
dati che trasmettiamo loro dati nell’interfaccia utente
e poi reagiscono usando i clic sui pulsanti
o forse cambiando gli input nei campi di testo
e quelle cose accadono in modo asincrono
non stiamo cercando in modo sincrono l’utente
dati che stiamo aspettando finché non lo fanno
qualcosa e questo va solo a mostrare
che fondamentalmente l’interfaccia utente è un altro pezzo a
molte persone si girano pensano che tu sappia
puoi scrivere queste app a thread singolo
che di default sul thread principale ma
in realtà l’interfaccia utente è un pezzo di asincrono
fonte quindi anche se non hai il
componente dati o componente di rete
l’utente stesso è un pezzo asincrono
delle informazioni che avete a reagire a
il loro contributo in modi che hanno senso
loro quindi ecco solo un esempio di a
mucchio di dati che scorre attraverso l’app
e non sta succedendo tutto questo
in modo sincrono queste cose si basano
sulle velocità della rete avviene su velocità del disco
succede quando l’ utente fa clic
i pulsanti sono solo i dati che scorre
attraverso l’app in momenti diversi e
l’app deve essere ricettiva e reattiva
a quello in modo che non finisca in a
stato dove è il thread principale
bloccato o qualche pezzo di dati entra
in modo asincrono quando non lo eri
aspettandoselo e l’app no
rifletterlo o semplicemente si blocca e
in definitiva il tuo codice nel mezzo qui
è ciò che è responsabile della gestione
tutto questo è dove la complessità
finisce per mentire, devi averlo
mantenere tutto questo stato nel tuo
Attività frammenti o qualsiasi altra cosa a
conciliare il fatto che questi multipli
fonti asincrone stanno producendo e
consumo di dati potenzialmente diversi
tariffe e che non prende nemmeno in considerazione
account Android stesso Android è un
fondamentalmente asincrona piattaforma noi
avere cose come notifiche push noi
avere trasmissioni su tutto il sistema
anche cose come un cambio di configurazione
quando l’utente ruota il dispositivo può
vieni in qualsiasi momento e se il tuo codice non lo è
aspettandomi di entrare
si incorrerà in si incorrerà in crash
e ti imbatterai in casi in cui l’app
inizia a comportarsi male, perché alcuni
stato ottenuto qualche stato ottenuto a noi a
certa configurazione in cui la tua app
solo completamente ferma smette di reagire così
solo per tornare a questo punto se lo sono
postulare un singolo asincrono
la fonte finisce per rompere l’imperativo
programmazione se Android di default è
qualcosa di asincrono abbiamo la rete
richiede difficile trovare un’app senza
Le richieste di rete sono fondamentalmente
in modo asincrono si ha il disco
database fondamentalmente asincrono
fonte e quindi l’interfaccia utente stessa dovrebbe
alla fine si pensa come un asincrono
fonte quindi per impostazione predefinita in sostanza
tutto in Android è già
asincrono quindi aggrappandosi a più
programmazione imperativa tradizionale e
tecniche di gestione dello stato sei tu
alla fine, danneggiando ciò di cui abbiamo bisogno
fare è prendere questo modello dove il nostro codice
si trova nel mezzo come arbitro di
stato e cercando di coordinare tutti questi
cose asincrone e invece di
avendo quello possiamo rimuovere il nostro
responsabilità agganciando queste cose
direttamente in modo che possiamo cambiare l’interfaccia utente in
iscriviti direttamente al database e
semplicemente reagire quando i dati cambiano possiamo
cambia il database e la chiamata di rete
reagire solo quando si fa clic sul pulsante
invece di doverlo ricevere
fare clic e quindi inviarlo
allo stesso modo arriva la risposta della rete
indietro sarebbe bello se fosse appena aggiornato
i dati e quando sappiamo ora che quando
i dati aggiornano automaticamente l’interfaccia utente
aggiornamenti e così abbiamo rimosso il nostro
la responsabilità di farlo
se Android fa qualcosa in modo asincrono
come inizia a ruotare invia una trasmissione
sarebbe bello se fosse giusto
riflesso automaticamente nell’interfaccia utente o
automaticamente avviata o si ferma un po ‘
lavoro di background e in definitiva questo
rimuove molto del codice che dovevamo
scrivere per mantenere quegli stati
noi stessi stiamo ancora scrivendo il codice
c’è ancora il codice qui, ma tutto quello che siamo
fare ora collega i bit
insieme in un modo che abbia un senso
invece di provare a gestire lo stato di
tutti emettendo e consumando
eventi
quindi in ultima analisi, questo è dove si arriva a
il nostro X Java e questo è diventato il
di fatto della libreria reattiva per Android
principalmente a causa del fatto che era uno
del primo disponibile per Java che era
davvero completo e anche per la nostra X
Java 2 perché mantiene il supporto per
tutte le versioni di Java di cui abbiamo bisogno
Android si riduce a fornire tre
cose importanti è un insieme di tipi per
rappresentare queste fonti di dati e
allora abbiamo un set di tipi per
abbonarsi a quei dati e ascoltare
a quando cambia e poi finalmente il
la parte più potente è un sacco di metodi
che ti permettono di combinare la composizione
trasformare quei dati in modo che possiamo finire
creando quei collegamenti tra il
diverse fonti di dati asincroni
e le cose che vogliono iscriversi
e mostralo iniziamo guardando
a ciò che i primi due cosa i primi due
sembra nell’API quindi una fonte di dati
di solito ciò che accadrà sarà
iniziare o smettere di fare un po ‘di lavoro quando si
inizia ad ascoltarlo a cui puoi pensare
questo come una richiesta di rete che non lo è
andando a sparare finché non inizi ad ascoltare
per una risposta e quando tu se tu
alla fine finiscono per annullare l’iscrizione
quella fonte di dati prima che si completi
potrebbe potenzialmente funzionare dicendo
cancellando le richieste di rete queste possono
essere sia sincrono che asincrono e
così puoi modellare qualcosa come a
richiesta di rete che sta bloccando ma
in esecuzione su una trama di sfondo all’indietro
o può essere asincrono che è
qualcosa come qualcosa come chiamare
su Android e in attesa di un’attività
risultato o anche come clic nell’interfaccia utente o
può essere pensato come sei asincrono
non bloccando in attesa di un clic sei
basta reagire al fatto che un clic
è accaduto
di solito questi possono produrre un singolo oggetto
o forse molti oggetti fino a quando mi piace
la risposta di rete sarebbe un singolo elemento
per una singola richiesta ma un flusso di
i clic del pulsante potrebbero essere potenzialmente
infinito finché l’interfaccia utente è lì
anche se sei solo tu lo sai
sottoscrivendo un singolo pulsante questi
può anche essere vuoto e quindi c’è il
idea di una fonte che solo in realtà
ha successo o fallisce e in realtà non lo è
hai qualche cosa in cui puoi pensare a questo
come scrivere su un database o scrivere a
un file in realtà non ha una risposta
in realtà non ha un oggetto che
puoi sapere di ritornarti davvero?
solo tipo di completamenti o fallimenti e così via
questo aspetto di completamento e fallimento è
in realtà modellato da fonti nel nostro Java
con questi cosiddetti eventi terminali
che è o completa
con successo o errori questo è
simile a te conosce un metodo che può
tornare normalmente o un’eccezione che
inoltre non può mai terminare così da tornare indietro
per l’esempio del clic sul pulsante, se lo fossimo
clic sul pulsante di modellazione come fonte di
dati che non finiranno mai fino a quando il tuo
L’interfaccia utente è lì e quando l’interfaccia utente scompare
probabilmente stai cancellando la sottoscrizione da quello
l’origine dei clic sui pulsanti non è così
in realtà completando davvero questo tutto
equivale solo a un’implementazione del
modello di osservatore tradizionale che abbiamo
qualche cosa che può produrre dati e
allora abbiamo un contratto per quello
i dati sembrano e tutto ciò che stiamo facendo è
voglio solo osservare che vogliamo
aggiungi un ascoltatore e ricevi una notifica
quando le cose accadono i due tipi principali
che rappresenteranno questo nel nostro
java two è osservabile e scorrevole e
questi entrambi finiscono per modellare il
stessi tipi di dati e che possono essere 0 a
n elementi in modo che io possa sapere essere vuoto può
avere un singolo oggetto o potenzialmente molti
e poi terminano entrambi
con successo o terminano con un
errore ma perché abbiamo bisogno di due tipi per
rappresentano la stessa struttura di dati
questo si riduce a qualcosa chiamato
contropressione
Non voglio immergermi troppo
molto che cosa è la contropressione perché è a
argomento complesso ma ho intenzione di provare e
mostraci un esempio che dovrebbe
illustrare la differenza che pressione
è lì per consentire di rallentare a
fonte di dati in cui sai che stiamo vivendo
questi sistemi che hanno
risorse limitate e puoi solo
processo così tanto in un momento contropressione
è un modo per dire semplicemente il
persone che ti inviano dati così da rallentare
che non puoi elaborarlo alla velocità di
loro stanno inviando il nostro Excel che aveva
contropressione ma è stata implementata
abbastanza tardi nel processo API e così via
tutto ciò che ogni tipo di sistema aveva
contropressione invece di rx Java a
dove abbiamo due tipi e dove questo
è diventato uno svantaggio è che mentre tutti
i tipi espongono l’idea della contropressione
l’idea di poterli rallentare
non tutte le fonti lo hanno effettivamente implementato
quindi alla fine avresti un incidente
non era supportato in fase di esecuzione e questo
è perché contropressione come sai
come l’ereditarietà devi davvero
il design per questo deve essere una cosa che tu
conto in anticipo invece di
qualcosa che qualcosa che ottiene
mescolato in seguito e questo è davvero
perché abbiamo due tipi distinti in rx
Java 2 perché ora puoi dettare
il sistema tipo se la contropressione è
supportato o no perché se non lo è
è qualcosa che va bene, ma è così
anche qualcosa che devi esporre
in API modo l’esempio che
mostrerebbe questo è se abbiamo una fonte
dei dati che è dire che gli eventi di tocco le
l’utente mette il dito sullo schermo e
lo trascinano e questo produce a
serie di eventi di tocco ora questo è
qualcosa che non possiamo davvero rallentare
giù non possiamo davvero dire l’utente che si
sai disegnare metà della tua curva e poi
fermati e aspetta mentre raggiungo il disegno
e quindi puoi continuare il resto di
la tua curva li vogliamo noi possiamo
potenzialmente farlo attraverso altri modi
come ad esempio disattivare i pulsanti e
visualizzare altra interfaccia utente per cercare di rallentarli
giù ma la fonte dei dati stessi
non è uno che può essere rallentato se
hanno già disegnato quella curva con a
un sacco di eventi che non possiamo dire al sistema
puoi rallentarli mandandoli via
confrontalo con qualcosa come a
database in cui abbiamo un grande risultato
set e forse vorremmo solo tirare
fuori certe righe a
Potrei dire oh voglio solo il primo
quattro file okay ora dammi altri tre
file okay ora dammi altre cinque righe a
il database può modellarlo davvero bene
il concetto di cursori ma un evento di tocco
un flusso di eventi tattili non può essere modellato
questo perché non c’è modo di farlo
respingi e rallenta il dito dell’utente
e così nel nostro esempio si vedrebbe
entrambi questi tipi implementati come
osservabili e cosa succederebbe a
runtime si potrebbe provare e applicare nuovamente
pressione e alla fine ottieni un
l’eccezione nell’app si blocca in questo modo
il motivo per cui nel nostro java due modelliamo
loro come tipi diversi perché uno
fondamentalmente può supportare la contropressione
e fondamentalmente non può esserci
modi di convertire tra i due quali
fondamentalmente sta solo applicando una strategia di
come funziona la contropressione ma non lo sono
entrerò in quello così perché questi
sono due tipi diversi che devono
esporre questa contropressione in qualche modo
ma perché anche loro modellano lo stesso
tipo di dati che hanno anche a tipo di
appaiono allo stesso modo in termini di come i dati
viene spinto nei tuoi richiami così il
due interfacce per ascoltare gli eventi
da queste fonti sembra abbastanza simile
il primo metodo viene chiamato next e
questo è il metodo in cui gli oggetti stanno andando
da consegnare e così il più a lungo
sono più è più di uno o più
oggetti prodotti dall’osservabile
o scorrevole questo metodo verrà chiamato
per ognuno che ti permette di fare
qualunque cosa faccia qualsiasi elaborazione tu voglia
a che fare con gli articoli anche questo potrebbe essere
infinito giusto ho parlato di infinito
osservabili come i clic sui pulsanti, quindi se
stai ascoltando un pulsante fai clic su questo
sul prossimo metodo sarà sostanzialmente chiamato
ogni volta che l’utente fa clic su un
pulsante per fonti di fonti non infinite
che in realtà finiamo con quei due
eventi terminali che possiamo completare
dove completo indica il successo o loro
può errore dove l’errore lo indica
o elaborando la prossima richiamata
ha generato un’eccezione
o che la fonte di dati dove siamo
ascoltare gli eventi ha avuto un problema
e ha dovuto fornire un errore ed entrambi
incompleto e su errore come si chiama
eventi terminali che significano che non lo farai mai
ricevi un’altra richiamata dopo averla ricevuta
o uno di quelli e così dove loro
differire è in questo ultimo metodo chiamato
iscriviti se lo sei se conosci il nostro
spalare uno questo è qualcosa che è
abbastanza nuovo ed è fondamentalmente l’idea
che quando ti abboni a uno dei due
osservabile o scorrevole sei veramente
creando una risorsa e risorse simili
spesso hai bisogno di ripulire quando hai finito
con loro e quindi questo su abbonamento
il callback sarà immediatamente chiamato come
appena inizi ad ascoltare un
osservabile o scorrevole e lo farà
mano per uno di questi due tipi
osservabile ciò che questo tipo ti permette di
fare è chiamare il metodo di smaltimento che
essenzialmente dice che ho finito con questo
risorsa Non voglio più altre callback
e quindi se abbiamo conosciuto una rete
richiedere ciò potrebbe potenzialmente annullare
la richiesta di rete se stai ascoltando
a quel flusso infinito di clic del pulsante
questo fondamentalmente direbbe che tu no
più voglia di riceverli e basta
disattiverebbe l’ascoltatore sulla vista ora
lo stesso vale per il tipo on
fluida anche se ha un diverso
nome l’uso è lo stesso che ha questo
annulla il metodo che è essenzialmente il
come gli articoli usa e getta smaltiscono il
la differenza qui è che ha un secondo
metodo chiamato richiesta ed è qui
contropressione
si mostra nell’API questa richiesta
il metodo è come dici quello scorrevole
vuoi più oggetti quindi vado a
costruisci un piccolo grafico qui di come
queste cose riguardano l’un l’ altro così noi
possiamo sostanzialmente rappresentare qualcuno di te
sapere che qualsiasi tipo di emissioni potrebbe essere zero
potrebbe essere uno potrebbe essere molti e
potenzialmente potrebbe completare o
potenzialmente errore e l’unico
la differenza tra i due è quella
ha una contropressione e uno non solo
molto rapidamente voglio toccare sul perché
perché il monouso e abbonarsi
i tipi di abbonamento sono nominati così
in modo diverso e perché i loro metodi
uno è disposto e uno è annullato
invece di conoscerti
estendendo l’altro e aggiungendo semplicemente il
il metodo di richiesta è perché
c’è questa cosa chiamata reattiva
specifica flusso era fondamentalmente un
iniziativa dove un gruppo di aziende
si è riunito e ha detto facciamo un
set standard di interfacce per reattivo
librerie in Java e finirono con
piuttosto queste quattro classi per interfacce
e così vedrai l’abbonato
digita e il tipo di abbonamento nel
al centro ci sono in realtà parte di
le specifiche e quindi è per questo che loro
avere un nome così diverso dal
quelli il tipo usa e getta e il
tipo di osservatore sono diversi perché
fanno parte di uno standard e non possiamo
cambia davvero il vantaggio però
è perché è uno standard
anche se questo non succede frequentemente
su Android ma se dovessi usare due
diverse librerie per i flussi se loro
entrambi implementano lo standard che puoi
convertire tra loro senza problemi e così via
Ho intenzione di cambiare la mia colonna di sinistra qui
essere effettivamente i tipi che implementano il
specifica del flusso reattivo e il
i tipi a destra sono ciò che implica
che la contropressione è supportata e il
i tipi sulla destra sono quelli che fanno
non avere indietro la pressione se torniamo a
il nostro user manager prima eravamo una specie di
estraendo gli utenti da questa classe e poi
mostrandoli quando pensavamo che fosse
più appropriato e ora mentre ciò che noi
può fare è modellare questo come invece a
osservabile dall’utente è una fonte di utente
oggetti che ogni volta che l’utente cambia
verrà informato di tale modifica e potrà
reagire al cambiamento mostrandolo
invece di cercare di indovinare di più
il tempo appropriato si basa su altro
eventi che accadono nel sistema c’è a
accoppiare fonti specializzate nel nostro Java
ed è fondamentalmente un sottoinsieme del
osservabile quindi non c’è tre di loro
il primo si chiama single anche questo
ha un singolo oggetto o un errore, quindi è così
meno di meno di un flusso e più giusto
come una fonte potenzialmente asincrona
di un singolo
e inoltre non ha contropressione
il modo di pensare a questo è un po ‘
come uno scalatore, così tu chiami un metodo
ottenere un tipo di ritorno si ottiene un valore di ritorno
o quel metodo genera un’eccezione
single essenzialmente modella lo stesso
concetto ti iscrivi a un singolo tu
o riprendi il tuo oggetto o ottieni un
errore la differenza è che è
reattivo completabile simile a un metodo
questo dichiara un tipo di reso vuoto così
completa senza dati o genera
un’eccezione ha un tipo di errore di pensare
di questo è come una corsa reattiva è
un set di codice che puoi eseguire e mentre
o completare con successo o fallire a
nuovo tipo nel nostro java 2 rispetto al nostro
java uno si chiama forse e questo
ha errori di un articolo o potenzialmente
non ha elementi il modo di pensare a questo è
è un po ‘ come un optional quindi a
metodo che restituisce un valore opzionale
restituirà sempre qualcosa se questo
non lancia un’eccezione, ma quella
facoltativo può o non può avere un valore e
quindi vedremo quando questi stanno per essere
usato in un secondo ma questo è simile a
il concetto opzionale eccetto giusto
reattivo quindi non c’è nessun tipo
in realtà modellano ciò che sono reattivi
flussi conformi nell’archetipo di due
sono modellati solo nell’osservabile
e backpressure free side quindi se il nostro set
il nome e impostare le chiamate per età sono asincrone
o completano o falliscono
davvero restituire i dati e quindi ciò che vogliamo
fare è modellare quelli come completabile sono
andando a passare questo molto rapidamente
solo per mostrare come sono queste fonti
creato e come puoi avvolgere le cose
che stai già utilizzando reattivo
tutte le fonti sono statiche
metodi che ti permettono di crearli
con valori scalari simili puoi anche
crearli da cose come matrici o
tutto ciò che è iterable ma ce ne sono due
che sono veramente utili
Penso che il nostro sarà il più usato
per adattare i metodi e il
azioni che stai già facendo
modo sincrono o asincrono
il primo è chiamato da Kabul da
Kabul stava essenzialmente modellando alcuni
comportamento sincrono che restituisce a
valore singolo in questo caso che sto delegando
ad un metodo ipotetico chiamato get
nome e la cosa bella di Kabul
è che ti è permesso lanciare un
eccezione da un callable che è a
interfaccia Java standard significa questo
possiamo modellare cose che farebbero
potenzialmente non riescono a utilizzare un controllo
eccezione quindi se abbiamo una richiesta HTTP
che vogliamo fare ciò che potrebbe lanciare
un’eccezione I / O ora possiamo metterlo
al suo interno da Colleyville e il
restituito osservabile quando sottoscritto
eseguirà quella richiesta e se questo
richiesta genera un’eccezione otterremo un
on-air, se la richiesta è completa, lo faremo
ottenere la risposta e il prossimo da
palle di chiamata disponibili su tutti e cinque
tipi e così questi sono per la modellazione
fonti sincrone di un singolo pezzo di
dati è quello che useresti un metodo
per in un mondo imperativo un metodo che
restituisce un valore di ritorno nel reattivo
il mondo di Kabul è ciò che usi
modello che ce ne sono anche altri due
metodi su entrambi e forse completabili
e quelli permettono di modellare le cose che
non restituire un valore così come ho detto
fondamentalmente solo un eseguibile tranne che
runnable è ora tutto più reattivo
potente metodo per creare osservabili
è giustamente chiamato creare se si utilizza rx
viaggio uno si potrebbe sapere che creare è
questo metodo orribile che tu davvero
non dovrebbe mai usare un arco pala uno
nel nostro Java due è stato risolto così
che il metodo di creazione è in realtà uno
dei metodi più utili e dovrebbe essere
usato per il wrapping di sorgenti lo creiamo
con una richiamata e quindi questa richiamata
viene chiamato ogni volta che c’è un nuovo
abbonato e ci viene data questa cosa
chiamato un emettitore e l’emettitore è
fondamentalmente solo la persona che è
ascoltando così possiamo prendere giorno
e possiamo inviarlo all’emettitore e in
questo esempio, quello che sto facendo è che sono solo
inviare un pezzo di dati in modo sincrono
e poi sto completando il flusso
perché è stato completato con successo
andando a convertire questo in un lambda in
pulisci un po ‘del boilerplate qui così
Posso inviare più di un pezzo di pezzo
di dati
a differenza del ciottolo, ho la capacità di
chiamare il prossimo più volte
l’altro vantaggio di questo è che noi
ora è in grado di modellare pezzi asincroni di
dati se prendo richieste H TDP e
invece di eseguirlo in modo sincrono
eseguito in modo asincrono posso chiamarlo
il metodo seguente l’emettitore dal
Callback HTTP un altro vantaggio di
questo metodo di creazione ti consente di farlo
cose quando la persona si disiscrive
quindi se qualcuno smette di ascoltare il
Richiesta HTTP non c’è motivo per farlo
continua eseguendo ora possiamo aggiungere un
azione di cancellazione che annulla il
Richiesta HTTP e ripulisce le risorse
questo è anche super utile per Android
perché è il modo in cui modelliamo le interazioni
con l’interfaccia utente quando ti abboni a un
osservabile vogliamo dire iniziare
ascoltando i clic sui pulsanti e poi quando
ti cancelli dall’iscrizione, vogliamo rimuoverlo
ascoltatore quindi non finiamo sai
perdendo un riferimento che perde questo
riferimento alla creazione della vista
osservabili funziona su tutto ciò che sono
creando osservabili con questo emettitore
funziona su tutti e cinque i tipi, facciamo in fretta
guarda le fonti di osservazione così ho mostrato
queste due interfacce precedenti e io
ha mostrato che quel quarto metodo che è
tipo di nuovo ed è un po ‘strano te
in realtà non usare queste interfacce
direttamente quando ti abboni a un
l’ abbonamento osservabile è il metodo
quello che inizia ad ascoltare a causa di
Quel quarto metodo ti viene messo in uno strano
posto dove bene cosa faccio con questo
oggetto e come faccio a sapere?
disiscriversi invece abbiamo un tipo
chiamato osservatore usa e getta e questa volontà
gestisci automaticamente quel quarto
metodo per te e ti permettono di essere solo
preoccupato per le notifiche effettive
dall’osservabile stesso, ma come facciamo noi
smaltire qui se non lo abbiamo più
callback come facciamo come cancelliamo l’iscrizione
come diciamo la risorsa che vogliamo
per andare via una cosa che potresti fare è
aggrappatevi a quell’osservatore in realtà
strumenti usa e getta in modo da poter chiamare
il metodo dispose e provvederà
di inoltrarlo a te
la catena ma c’è un nuovo metodo in
il nostro kravitz che hai chiamato iscriviti
e quindi questo consente di utilizzare in un
modo simile a quello che faresti se lo sei
usando un archivio che è quello che ora
ti restituisce la cosa che puoi allora
Chiamare disporre in archivio uno questo è
chiamato un abbonamento è anche chiamato a
abbonamento nel mondo scorrevole ma
nel mondo osservabile è un
usa e getta per le persone che conoscono
abbonamento composito c’è a
composito monouso e questo fondamentalmente
ti permette di iscriverti a più persone
i flussi prendono quelli appena ritornano
articoli usa e getta e li aggiungo a ciò che è
essenzialmente un elenco di articoli usa e getta e
puoi annullare l’iscrizione a più persone
flussi allo stesso tempo vedrai questo molto in
Android dove hai un singolo
composito usa e getta per te conosci un
attività un frammento o qualunque e il tuo
disiscrivendo nel sai su distruggere
o qualunque sia il callback del ciclo di vita
appropriato in modo da averli su tutti
quattro per non contropressione dove
digita quelli che usano osservatore e
ce n’è davvero una anche globale
sebbene flowable usi l’abbonamento
callback non il non disponibile
il tipo che forniamo nel nostro java a
in realtà ti permette di modellarlo nel
allo stesso modo in modo da ottenere un dorso usa e getta
da tutti e cinque i tipi anche se scorrevoli
è un po ‘ diverso il
il modo di pensare a questo è come faresti tu
pensa a tutto ciò che è una risorsa a
file un cursore su un database che non vorresti
aprire un file senza averne alcun modo
chiudilo non avresti aperto il cursore su a
database senza alla fine chiuderlo
mai sottoscrivere un osservabile senza
gestendo il monouso e in definitiva
annullando l’iscrizione va bene così erano quelli
i tipi sono davvero molto veloci
guarda i metodi che ti permettono di
componi e modifica i dati che chiamiamo
questi operatori e lo fanno fondamentalmente
tre cose manipolano o combinano i dati
cambiano la semantica del threading
oppure possono avviare e fermare le emissioni
stiamo solo andando a guardare il
i primi due e proprio come abbiamo fatto
qualcosa che era imperativo come a
chiamata al metodo sincrono e attivata
gli operatori reattivi fondamentalmente fanno lo stesso
cosa così qui stiamo applicando un
operazione su una stringa e ritorno a
nuova corda nel mondo reattivo noi
avrebbe un osservabile e lo faremmo
applicare tale operazione tramite un operatore in
questa mappa del caso è l’operatore che è
permettendoci di prendere i dati emessi
e applicare alcune operazioni ad esso per creare
un nuovo tipo di dati che sono in realtà
andando a saltare questo così se guardiamo
il nostro oggetto utente lo abbiamo definito
originariamente i richiami stavano arrivando
di nuovo su un thread in background e abbiamo avuto
per passare esplicitamente al thread principale
c’è in realtà un operatore integrato
che ti permette di farlo e permette
per farlo in modo molto più dichiarativo
modo in modo che possiamo dire che voglio osservare
emissioni da questo osservabili su a
thread diversi e così le cose
proveniente dall’utente sarà sul
thread di sfondo ma le cose stanno arrivando
l’utente principale di thread sarà ora attivo
il thread principale osserva di essere il
operatore qui e quindi questo perché siamo
cambiando i fili l’ordine che tu
applicare questi operatori è davvero importante
simile bisogno di osservare su possiamo cambiare
il dove il lavoro dell’osservabile
succede così se stiamo facendo una rete
richiesta che la richiesta di rete sia ancora
andando a fare in modo sincrono ma noi
non voglio che accada sul principale
thread quindi quello che facciamo è che possiamo applicare un
operatore che cambia dove ci iscriviamo
essere osservabili e dove ci iscriviamo
è dove il lavoro alla fine accade così
ora quando ci iscriviamo al nostro background
risposta cambierà in
thread in background che IO è solo un
pool di thread di thread che è possibile utilizzare e
quindi funzionerà su quel pool di thread
e quindi inviare la notifica a
chi sta ascoltando, iscriviti qui
essere l’ operatore per cambiare dove
il lavoro accade
e ciò che è bello è questo perché questi
tutto è tornato, conosci nuovi osservabili e
tutti gli osservabili tutti questi metodi
esistono su osservabili possiamo comporli
e incatenarli insieme così che tu
normalmente vediamo è che non abbiamo
variabili intermedie per questi siamo
basta applicare gli operatori in un certo
ordine in modo che vogliamo una risposta o ci dispiace
vuoi richiedere l’esecuzione su a
filo di fondo vogliamo osservare il
risultato di quella richiesta sul principale
filo e vogliamo dire cambiare il
la risposta in te conosce una stringa che vogliamo
per leggere la stringa eccetto di nuovo ordine
qui conta così perché ho applicato il
l’operatore della mappa dopo aver osservato su quello è
andando a girare sul thread principale di androids e
non vogliamo leggere da HTTP
risposta sul thread principale che vogliamo
stare succedendo prima di passare al
thread principale e quindi la richiesta arriva
e sai che tu non rispondi alla risposta
giù la catena osservabile mappiamo quello
nella stringa dei risultati e poi noi
cambia i thread nel thread principale dove
possiamo infine abbonarci e mostrarlo
nell’interfaccia utente e poi ce ne sono altri
gli operatori ho saltato la mappa piana così semplicemente
tenerlo qui così dove vediamo alcuni di
questi altri tipi, quindi lo noterai
questi erano tutti osservabili c’è dell’altro
operatori che abbiamo effettivamente che in realtà
prendere osservabile e restituirlo in a
tipo diverso e quindi un operatore come
prima sta andando a prendere il primo elemento
viene emesso da un flusso e restituito
a voi nel nostro esempio, siamo tornati
ed osservabile che ne ha emesso solo uno
questo è un po ‘strano perché se
hai una lista di oggetti e chiami
sali su per ottenere il primo oggetto
non recuperare una lista con un solo oggetto
quello che ottieni è uno scalare e noi
sappi che ora abbiamo un tipo
modella uno scalare nel mondo reattivo
così nel nostro java 2 quando lo chiami
primo operatore che è garantito a
restituire solo un elemento che si ottiene a
single se l’osservabile è vuoto questo
genererà effettivamente un errore perché
sappiamo che una singola ha o un oggetto o
errori e quindi ci sono altri operatori
come il primo elemento
in realtà ti restituirà ora a
forse e così quando un forse o quando il
osservabile è vuoto forse può effettivamente
modellare quello completando senza un
errore ce ne sono anche quelli che ritornano
completabile quindi se stai semplicemente ignorando
gli elementi che ti stanno a cuore
completa o fallisce che ora ritorna
completabile che è esattamente ciò che
modelli completabili su cui tutto questo esiste
scorrevoli e quindi hanno tutti il
stessi operatori tutti li restituiscono
stessi tipi specializzati questo è un grafico
questo tipo mostra alcuni degli operatori
e l’ angolo in alto a destra di questo
è fondamentalmente dove i tipi si restringono così
quando chiami qualcosa come vuoi
conta il numero di elementi in un flusso
l’account è sempre un singolo valore così tu
prendi un tipo più ristretto come single e poi
abbiamo anche operatori che fanno il
di fronte al quale si sa prendere un tipo
e trasformarlo in qualcosa di più ampio così
potresti prendere un singolo e trasformarlo in
un ok osservabile al nostro originale
esempio se vogliamo essere reattivi con
possiamo sapere come iscriversi al nostro utente
dire che voglio le notifiche sul principale
filo e poi voglio spingere quello
nell’interfaccia utente visualizzare quell’utente in qualsiasi momento
l’ utente cambia questo codice
automaticamente andando a correre lo farai
vedere automaticamente gli aggiornamenti e noi no
avere più preoccuparsi di gestire questo
noi stessi però dobbiamo ricordare
per gestire il monouso che ottiene
restituito perché siamo dentro o nel
Mondo Android e quando la nostra attività
scompare vogliamo che questo codice si fermi
correndo così a non distruggere ti faremmo
sapere smaltire questo smaltimento del
articoli usa e getta allo stesso modo quando alla fine
fare una richiesta asincrona per cambiare
dati che vogliamo che succedano su a
filo di fondo vogliamo osservare il
risultato sul thread principale indipendentemente dal fatto
succede o fallisce e tu sai nel
callback di successo che potremmo sapere
potenzialmente come riattivare la casella di testo
o qualsiasi altra cosa e ancora perché tu
non aprirebbe un file senza chiuderlo
non ti iscriveresti senza la gestione
il monouso così aggiungiamo questo al nostro
lista usa e getta
In realtà sto per saltare questo
perché sono un po ‘in ritardo ma a
bella cosa della nostra Java – rispetto a
il nostro Java è che c’è un
spostamento di architettura fondamentale e cosa
ciò che è particolarmente adatto su Android
che c’è solo meno intermedio
oggetti creati così quando crei
questi flussi ogni operatore che chiami
deve restituire una nuova osservabile che
implementa quel comportamento quando chiami
mappa ottieni un nuovo osservabile che prende
il vecchio esegue una funzione e tu sai
emette i nuovi dati e così richiede
un mucchio di oggetti oggetti intermedi
essere assegnato per modellarlo
stream rx Java in realtà ha cambiato il modo
questo funziona in un modo che effettivamente otteniamo
meno oggetti intermedi creati oops I
volevo in modo da ottenere meno allocazione a
in realtà creare il flusso che è chiamata
gli operatori ognuno effettivamente risultati
in un oggetto in meno che viene creato c’è
anche meno spese generali quando si sottoscrive a
streaming c’è metodo meno della spedizione che
deve accadere e così alla fine ciò che noi
ottenere è un GC meno veloce che causa meno GC
versione della libreria senza nessuno
compromesso nell’API in modo da viaggiare – è
fondamentalmente questa idea che vogliamo prendere
queste cose che sono fondamentalmente
sia asincrono in Android
la rete Android stesso database anche
l’interfaccia utente è stata modellata come sorgente asincrona
e scrivere il codice che reagisce ai cambiamenti in
queste fonti invece di cercare di far fronte
con cambiamenti e gestire noi stessi
in questo momento è in un’anteprima dello sviluppatore
rilascio quindi stiamo fondamentalmente finalizzando
l’API e tra circa un mese lo farà
avere il suo rilascio finale dove sarà
disponibile voglio dire che è già disponibile
inserire la tua app, ma l’API potrebbe
cambia e la versione finale si solidifica
l’API in modo che cose come le librerie
può iniziare ad usarlo e di esporre questi
digita automaticamente se usi rx
il doppio di uno è in realtà un progetto
che ti permette di convertire tra il
tipi
e così questo ti permetterà di
aggiorna la tua app in modo incrementale, se lo sei
interessato a questo ecco il link e
quindi le tue dipendenze per quella volontà
alla fine assomiglia a questo
e così dove voglio finire è fondamentalmente
il nostro viaggio verso X non è qualcosa di nuovo
la programmazione reattiva non è nuova di
qualsiasi allungamento ma Android stesso per
qualunque ragione sia questa altamente reattiva
mondo che ci è stato insegnato a modellare
moda imperiosa e molto imperativa
prova solo ad affrontare il fatto che noi
devono gestire tutte queste cose
noi stessi e la programmazione reattiva in
il nostro Java in generale ci consente di modellare
è nel modo giusto che è quello che è
asincrono
abbracciare l’ asincronia di questi
fonti e invece di cercare di gestire
tutto lo stato noi stessi li compongono
insieme in modo tale che la nostra app diventi veramente
reattivo e ora davvero tutto ciò che siamo
preoccupato è come costruirli
frecce e non in realtà come gestirle
lo stato dei dati che scorre
attraverso il sistema e quindi questo è tutto me stesso
avere per te grazie a tutti per essere venuti
tu
Please follow and like us: