Penso di ricordarmi di venire a James Ward
non ero preso come sei settimane fa
a forza lavoro che lavora su alcuni
i progetti là più recentemente ne hanno fatti
ovunque applicazione intera così questo
questa presentazione sarà circa
costruire lavori reattivi quindi prima di tutto
iniziamo un po ‘di setup
quindi la ragione per cui le persone reattive sono
parlare di persone o di costruire è
perché ciò che gli utenti vogliono è cambiato ma
ora abbiamo alcuni strumenti che aiutano
noi per soddisfare le esigenze degli utenti che sono state
in giro per molto tempo quindi alcuni di questi
le esigenze degli utenti sono sincronizzate in tempo reale
collaborazione feedback immediato non a
Aspetti queste sono cose che abbiamo sempre
voluto ma per costruire questi tipi di
le applicazioni in passato non l’abbiamo fatto
davvero gli strumenti sono facilmente accessibili
quindi la cosa su reattivo è questo
è in qualche modo solo prendendo un sacco di
queste idee che sono state in giro per a
molto tempo e li rende generalmente
accessibile a noi come sviluppatori così
c’è qualcosa chiamato reattivo
manifesto che puoi scoprire reattivo
Manifesto org e e l’idea del
manifesto del reattore è quello di mettere insieme
queste idee in alcuni modi di alto livello per
descrivi come consegniamo queste cose
che gli utenti vogliono e quindi me ne andrò
attraverso di loro è molto veloce ma puoi farlo
controlla il manifesto del reattore sul tuo
proprio e puoi firmarlo se sei d’accordo
con esso così a prima che gli utenti vogliono
applicazioni che sono reattive e
reattivo comprende un sacco di
cose diverse latenza e non andare
giù e tutto quel genere di cose da fare
che dobbiamo costruire su una base
quello è scalabile e resiliente così quelli
sono i due tipi di tratti centrali di
reattivo e quindi per fare tutto
questo abbiamo bisogno di una fondazione che sia
guidato dagli eventi è proprio ciò che consente
noi per essere scalabili e resistenti al
stesso tempo e consegnare reattivo
interfacce per i nostri utenti così questo è il tuo
breve piccola sinossi su ciò che è reattivo
è su di te puoi leggere molto di più
su reagire a manifest org il manifesto
è intenzionalmente tecnologia agnostica così
non importa quale sia la tecnologia
stai usando l’idea dovrebbe dovrebbe
applica in modo che vedrai queste idee in un certo modo
intrecciato ma voglio concentrarmi
più oggi sul reale come come facciamo noi
effettivamente costruire applicazioni reattive e
quindi ho intenzione di passare attraverso un po ‘di
tre diversi modi in cui lo facciamo così
prima parla di web reattivo e
parlando di attori reattivi e poi
parlando di flussi reattivi, quindi quelli
sono i tre argomenti principali, quindi tratteremo
e probabilmente passerò la maggior parte del tempo
sul web le cose hanno un po ‘ di
tempo la fine per attori e flussi così
per prima cosa parliamo del
web reattivo così web reattivo è tutto
su un sink e non-blocking
probabilmente la terminologia che hai
sentito più in giro reattivo è un lavandino e
non bloccante è un po ‘su un lavandino
e non bloccante per dire davvero un lavandino
e il non-blocco è un po ‘strano
perché non possiamo essere realmente
non bloccante senza essere un lavandino, così noi
potrei dire solo non bloccante ma per alcuni
motivo diciamo un sink e non-blocking
ma se sei solo un lavandino, c’è davvero
è davvero un negativo che non vuoi
basta essere un lavandino per il gusto di essere un
affondare c’è non c’è davvero alcun motivo per
fallo complicare la tua programmazione
modello assicurati che il tuo codice sia più difficile
fare il debug così veramente la ragione per cui siamo
andare avanti è perché vogliamo essere
non bloccante quindi ne coprirò quattro
diversi modi in cui possiamo essere un sink e
non bloccare le richieste reattive reattive
spinta reattiva composizione e a
reattivo quindi in poche parole un lavandino e
non-bloccante in termini di web è
per prima cosa dobbiamo contrastare questo con il nostro
tipico modello servlet tipico servlet
il modello ottiene un nuovo post e questo è pari
vero per servlet 30 e 31 il
percorso tradizionale attraverso una rete
la richiesta sta bloccando e cosa significa
è quello quando quella connessione è giusta
seduto lì tipo di attesa per il
dall’altra parte per rispondere aspettando il
dall’altra parte per generarne qualcuna di più
dati in realtà lo terremo
gira intorno in modo che manterremo il
filo attivo voi
quando la connessione non è attiva
essere usato è il modello tradizionale
è così che abbiamo costruito
applicazioni per lungo tempo così nel
modello asincrono e non bloccante cosa noi
voglio fare è vogliamo essere in grado di prendere
quel thread e quando vinci quella connessione
è inattivo, vogliamo essere in grado di prenderlo
risorsa che filtra e da ‘ a
qualcun altro e questo ci permette di avere
migliore resilienza di scalabilità parleremo
circa un po ‘più tardi, quindi questo il
ragione per cui questo ci permette di avere di meglio
la scalabilità è una coppia quindi prima possiamo
fare molte più cose in parallelo quando noi
usa questo modello dove non stiamo bloccando
tutti questi fili idealmente vogliamo il nostro
i numeri dei thread devono essere ridotti a circa il
numero di core che abbiamo sul nostro
sistema che è davvero il numero ottimale
di thread all’interno della JVM di solito
avere un sacco di discussioni in testa e quello
tipo di cose quindi è difficile in realtà
ottenere esattamente lì ma ma questo è il
ideale è quello che vogliamo puntare
ci sono alcuni motivi per cui vogliamo mirare
per quella CPU le cache rimangono meglio memorizzate nella cache
quando non stai facendo il contesto
commutazione di thread inoltre c’è un
overhead piuttosto significativo per thread così
la dimensione dello stack predefinita su GBM I
penso sia un megabyte e quindi questo significa
che ogni thread sul tuo sistema richiede un
megabyte solo per lo stack e così via
non possiamo semplicemente allocare migliaia di
discussioni anche se abbiamo performant a
modo performante per passare da quelli
discussioni stiamo ancora assegnando molto
memoria e ci piacerebbe pensare che noi
can e 64-bit jbm è solo avere come
molta memoria che vogliamo usare tanto
memoria come vogliamo una singola JVM che sia
davvero non è vero, c’è GC più grande e
pause GC più grandi almeno nella maggior parte delle JVM
più grande è il tuo mucchio e così tu
non voglio solo assegnare migliaia di
discussioni perché poi stai andando
ho un sacco di memoria che è quello
questo sta prendendo più tempo nel tuo GCS
così così fa questo è uno degli altri
effetti collaterali e perché vorrebbe andare
asincrono un non-blocco è quando non lo sei
usare i thread perché li hanno assegnati
non stiamo usando una vera connessione perché
averlo assegnato così l’altra parte di
questo e ‘quello
ora dobbiamo essere in grado di gestire molto
più connessioni ai nostri server perché
abbiamo tempo reale perché forse abbiamo
Dispositivi Internet of Things e milioni
di dispositivi tutti collegati al nostro servizio
quindi essere in grado di gestirne così tanti
connessioni che iniziamo a fare in realtà
colpire limita i limiti fisici sull’hardware
se abbiamo bisogno di essere in grado di gestire facciamo
diciamo un milione di connessioni simultanee noi
non hanno affondano e non bloccano
quindi allora l’ultima ragione per cui lo farò
coprire intorno async asincrono e non
il blocco è per ismo parallelo è spesso
ora nelle nostre applicazioni abbiamo un
chiedi , entra e poi stiamo andando
per soddisfare un maggior numero di richieste e
vogliamo provare a fare come molti di quelli in
il più parallelo possibile e veramente uno di
i nostri fattori di gating per quanto possiamo
fare in parallelo è quanti fili abbiamo
può allocare e quindi quindi se siamo a
affondare e non bloccare quindi quelli smazzati
le richieste saranno in grado di
operare in modo molto più efficiente in
parallelo perché non avremo
il sovraccarico delle richieste per connessione
o un thread tenuto per tutto l’idolo
connessioni in modo che è la nostra rapida panoramica
su un lavandino e senza bloccare voglio
immergersi in qualche codice per mostrare effettivamente come
faremmo questo puoi prenderne un po ‘
queste idee un po ‘meglio, ma voglio
fai un sondaggio del pubblico a cui arrivi
selezionare codice Java 8 o codice Scala
ok ok, java 8 ok, penso che succederà
essere un codice Scala di un’ora era vicino ma
Penso che Java 8 1 sia così ok, così siamo
Ci tufferemo e costruiremo un
piccola app per mostrare come fare un lavandino e
sblocco con Java 8 così ho intenzione di
usa qualcosa chiamato attivatore typesafe
è un modo per costruire gioco e akka e
Applicazioni Scala e Java 8
applicazioni così ho intenzione di chiamare
attivatore e dire non creare nuovi sono
andando a creare una nuova applicazione ho appena
attivatore scaricato è un file zip e
l’ho estratto e l’ho aggiunto al mio percorso così
poi selezionerò il gioco java
esempio e ci andiamo quindi lasciami andare
in quel gioco Java questo è ora il mio nuovo
progetto che ho appena creato e che sono
andando a correre così vado a
attivatore finché non corrono e mentre è così
Iniziando fammi entrare in IntelliJ qui
e aprire questo progetto così ho voluto
inizia da zero in modo da poter ottenere un
idea per quello che sembra per te
quando inizi da zero così sarà
prenditi un secondo per ottenere tutto e
in esecuzione in IntelliJ e ottenere il
progetto tutto pronto quindi andiamo a prendere un
guarda prima il layout di questo
progetto quindi se guardo in questo progetto
whoa ignoriamo la directory di destinazione
lì quindi se guardo in questo progetto
ci sono alcune cose diverse che sto andando
per essere passato così per primo in una commedia
questo è un gioco di applicazione di gioco
quadro è un sink e non bloccante
della scatola non usa il servlet
api usa Neddie per un lavandino e non
bloccare così giocare nel modo in cui siamo fuori
è il modo in cui gestiamo le richieste
attraverso un controller daremo un’occhiata a
che in un secondo e poi ho opinioni
quali sono i miei template lato server che posso
ovviamente uso angolare e lato client
le tecnologie ci sono compilatori di risorse
che potremmo vedere un po ‘se noi
avere tempo c’è un file di rotte dove io
definire in modo dichiarativo il routing di
richieste per la mia domanda e poi a
pochi altri file per build build simile
informazioni e quel genere di cose così
questa è la mia struttura di progetto di base
sembra che sia attivo e funzionante su IntelliJ
prima che io vada là, andiamo a tirare questo
cosa nel browser così dovrebbe essere
su e in esecuzione su localhost 9000 lì
noi andiamo c’è la nostra piccola giocata
applicazione Va bene così andiamo ad aprire
quel file di rotte e ho intenzione di andare
crea un nuovo percorso in modo che il percorso sia solo un
mappatura tra un verbo HTTP e un percorso
metterà / cibo per il percorso e poi
un metodo di controllo per chiamare e quindi sono
andrò nel mio controller qui e
vedrai che c’è già un controller
Ne aggiungerò uno nuovo, così farai
vedi che sto usando statico qui con il gioco
possiamo iniziare con metodi statici
e quindi possiamo passare dalla statica
metodi per l’iniezione di dipendenza, se noi
voglio ma i metodi statici sono i più semplici
modo per la demo, quindi lo useremo oggi
quindi un controllore in gioco quello che fa è
è ci vuole una richiesta e ritorna
una risposta quindi in questo caso la risposta
l’oggetto è chiamato il risultato così ora io
ho solo bisogno di restituire un nuovo risultato, quindi sono
andando a restituire un risultato del codice di stato 200
con un corpo stringa che contiene solo
Asda è il mio controller di base
e suona proviamo e facciamo
certo che funziona così ci andiamo c’è
il mio controller è ok, quindi è la mia base
il controller sotto le cover suona
facendo ciò sincronizzato non bloccando ma
quello che hai visto finora è il mio codice
non era un lavandino esplicitamente così sotto
le coperture questo è un lavandino e non
bloccando ma dal mio punto di vista il
codice I Britain è sincrono quindi andiamo
fai un altro passo avanti e facciamolo ora
asincrono quindi invece di restituire a
risultato ho bisogno di restituire qualcosa che
promette di restituire il risultato nel
futuro, quindi userò il f’d up
prometto che questo è davvero solo un involucro
intorno al futuro della Scala, quindi gioca
è costruito internamente con Scala, quindi questo
è un’API che è una bella interfaccia Java
in cima a questa questa futura API in Scala
quindi un po ‘di futures e
promette che la terminologia è una specie di
usato mescolato di solito il
terminologia almeno nello studioso
mondo penso nel mondo JavaScript come
bene è che il futuro è il lato che
Posso leggere un risultato futuro da e
quindi la promessa è quella giusta
posso scriverlo così è la maniglia
entrambi sono maniglie, la promessa è la
gestire che posso scrivere il risultato in
il futuro è il lato che posso leggere
il risultato fuori da così in Java API I
pensa di essere coerente con altri Java
api per qualche motivo siamo crollati
il futuro e i concetti promessi in a
un singolo oggetto chiamato promessa non del tutto
certo perché l’abbiamo fatto, ma lo vedrai
Ora ho un errore di compilazione perché lo sono
restituendo non una promessa di un risultato ma
Sto ancora restituendo un risultato così
quello che devo fare è creare qualcosa
quello che in futuro produrrà il
risultato e
allora saremo un sink esplicitamente
asincrono quindi creerò a
nuova promessa qui e userò
il metodo promessa punto promessa e il
promesso metodo promettente se guardiamo
se guardiamo la firma vedremo
che prende una funzione così perché II
non voglio realmente chiamare questo codice
quando la richiesta entra nel modo giusto se io
sinistra come questo allora sarebbe
provando a chiamare questo ok e produrre
il risultato immediatamente invece ho bisogno
qualcosa che posso chiamare più tardi
produrre quel risultato per soddisfare il
prometti ed essere in grado di ottenere il risultato
fuori dal futuro, quindi non posso tornare
non posso semplicemente chiamare questa cosa e
restituire il risultato che devo invece dare
è una funzione che poi può giocare
internamente quindi chiama quella funzione in seguito
per ottenere il risultato da così ora sono
andando a usare la sintassi Java 8 nu lambda
e ho intenzione di definire un po ‘
funzione in linea qui molto più bello
rispetto alla vecchia sintassi Java per farlo
ma ora quella è una funzione che ho
appena definito che non richiede parametri
questo è il parametro lambda lì
non ci sono parametri e quindi la funzione
il corpo restituisce il risultato così ora
giocare internamente ora ha una maniglia così quando
la richiesta entra in questo metodo di gioco
ora ha una maniglia per qualcosa che lo farà
in futuro produrre il risultato e così via
allora quando il gioco è pronto per essere in grado di
ottenere quel risultato che sta per invocare
questa funzione e quella funzione lo faranno
produrre il risultato quindi proviamo
e andiamo a cambiare quella stringa così noi
può verificare che funzioni effettivamente così colpito
aggiornare e compilare e quindi dovremmo
vedi ooh azione non trovata che è un io sono
usando il gioco due tre e quello è un bug
devo amare il nuovo software tutto a posto
Ho sicuramente un percorso
proviamo di nuovo, hai sempre pulito
oh uomo sono in cattivo stato qui
andiamo lì andiamo bene quindi non usare
punto zero software giusto questo è il gioco 2
30 aspetta fino a 231 ok ma vedremo
che ha funzionato vuole capire il compilatore
fuori cosa fare così ci andiamo ora ho
ho il mio controller che è quello che è ora
esplicitamente asincrono, quindi va bene
Sono esplicitamente asincrono ma lo sono
ancora non proprio non bloccante per non essere
bloccando devi avere qualcosa da fare
non bloccare su e in questo momento non lo faccio
ho davvero qualcosa da non bloccare su così
buoni esempi di cose da non bloccare
la nostra rete i / o è qualcosa che non possiamo
blocco e poi timeout o qualcosa del genere
non possiamo bloccare i messaggi degli attori
ci sono un sacco di cose là fuori
che stanno diventando più comuni a
non bloccare, ma quindi abbiamo bisogno di uno di quelli
cose così solo come esempio un modo per
il blocco non è con un timeout ritardato
fondamentalmente qualcosa che dice chiama questo
funzione in una certa quantità di tempo così
invece della promessa promessa, vado
fare un ritardo di promessa vedrà che c’è un
pochi altri parametri qui così il secondo
parametro è la quantità di ritardo e
allora dirò di farlo per tempo
unità di secondi quindi 45 secondi, quindi sta andando
per ora aspetta per cinque secondi e così
aspetta probabilmente il modo sbagliato di usarlo
cinque secondi invocheranno questo
funzione che soddisferà questa promessa
e quindi restituire il risultato, quindi facciamolo
proviamoci con speranza, il
compilatore collabora questa volta sto andando
per aprire la finestra di ispezione perché noi
dovrebbe essere in grado di una volta che viene compilato
dovremmo essere in grado di vederlo davvero
il ritardo di cinque secondi accade così ci siamo
sembra che abbia funzionato, lo vedrai
c’era un secondo e mezzo di compilazione
tempo e poi e poi i cinque secondi
ritardo quindi torniamo al codice così
ora ho qualcosa che è un lavandino e
non bloccante quindi sono esplicitamente asincrono ma
ora ho qualcosa su cui non posso bloccare
è un po ‘di inganno qui
perché
è lì per avere qualcosa
è su un timer che si attiva ad un certo punto
in futuro ci deve essere un
infilare lì, quindi c’è un filo che
viene utilizzato per tutti questi tipi di
timeout all’interno della JVM quindi non c’è
un thread ma potrei avere un milione
le richieste entrano in questo controller e
tutti loro per quei cinque secondi
semplicemente andando a sedermi lì senza usare nessuno
discussioni Avrò solo quel timer
thread che gestisce tutti i timeout
quindi questo è ora un sink e
non bloccante quindi torniamo qui e
colpiamolo di nuovo così ce n’è un cinque
secondi in cui il mio browser è solo
girando quindi ho una richiesta HTTP aperta
per il mio server questo è solo uno standard
Richiesta HTTP non c’è nulla di speciale
il browser non ha conoscenze speciali
su questo ciò che è in realtà essere
accade sul server per rendere questo a
affondare e non bloccare così per quel cinque
secondi la ruota del browser è giusta
girare è come hey non ho
ricevuto qualcosa ancora non ho ricevuto
tutto ancora così, ma dal lato server
la richiesta è arrivata in quel controller
il metodo ha restituito la promessa del risultato
e quindi il thread per quella connessione
andò via andò da qualcun altro e così
poi cinque secondi dopo il ritardo
sta andando a calci sta andando a correre
quella funzione allora avremo un
infiliamo indietro e poi abbiamo intenzione di essere
in grado di inviare tali dati in modo che per
che la maggior parte di quei cinque secondi ci sono stati
in realtà nessun thread allocato sul
lato server da gestire in questa richiesta
sì, dal lato del cliente, penso che
Chrome probabilmente sta facendo anche un sink e
non bloccante ma questo dipende dal
cliente reale per decidere come gestisce
il vero networking così tutto questo è
basata su Java Java niño niño fornisce
noi un modo asincrono di fare rete Io oh così
Nettie è l’implementazione che gioca
usi di Java niño e quindi questo è davvero
ciò che ci dà la possibilità di essere sincronizzati
non bloccante quindi tutti i controller fuori
la scatola o un non-blocco sincronizzato ma noi
può essere esplicitamente un sink e non
bloccando se abbiamo qualcosa da non fare
blocco su ok voglio fermarmi per un secondo
e vedere se ci sono domande
prima di ottenere di più
complicato e più utile, sì vai
avanti è totalmente a voi quello che fai
questo è il tuo futuro e le tue promesse
solo un esempio molto banale ma puoi farlo
creare una promessa e quindi si può avere
qualunque cosa tu voglia adempiere a quella promessa
quindi diciamo che parli al tuo livello dao
tu passi quella promessa nel tuo dao
strato e quindi il tuo livello dao potrebbe quindi
adempiere quella promessa giusto così questo è uno
come potresti farlo probabilmente a
il modo migliore per farlo è che avresti effettivamente
un metodo chiama al tuo dao il loro ritorno a
promessa di alcuni dati e poi tu
allora saresti in grado di ascoltare
all’interno del controller impostare una maniglia
su quel completamento e poi trasformalo
nel risultato attuale e questo è
molto simile a quello che vedremo
in un secondo streaming sì, c’è così
quindi lo streaming è molto diverso
modi per fare streaming se cercherò di mostrare
uno di loro in un po ‘che è
entrambe le prese web o servizio ed eventi
ma puoi anche fare commenti o scusami non
commento puoi anche fare pezzi
le risposte e puoi renderle a pezzi
risponde a un sink e non blocca come
bene, quindi non ho intenzione di mostrare un chunked
uno ma ce n’è uno buono nel gioco
documentazione che mostra come fare
risposta Chunked un sink e sblocco
risposte Chunked okay, andiamo
rendi questo più utile quindi l’ho fatto
questo ritardo non è molto utile facciamolo
qualcosa di più utile che è una rete
chiamata di servizio quindi vado a vincere il
la richiesta arriva al server che sto andando
per poi fare un’altra richiesta dal mio
il server su un altro server ottiene alcuni dati
e quindi restituire quei dati indietro così facciamo
scrivi il codice per primo, quindi cosa
Ho intenzione di tornare sarà una F
punto prometto di risposta AWS e lo faremo
chiama questo jwf e poi per fare questo lo sono
andando a utilizzare il servizio web di gioco
la biblioteca dovrebbe essere così per essere sicuro di averlo
quello giusto ha importato, okay allora lo sono
andando a impostare l’URL di James Ward calmo
e poi farò una richiesta di ottenere
quindi se guardiamo a cosa succede
effettivamente facendo una richiesta di ottenere guardiamo
ciò che ritorna è una promessa di AWS
risposta quindi questo non è il reale
risposta è una promessa a qualcosa
che in futuro mi darebbe
la risposta e quindi non posso non posso usare
questa risposta ancora quello che voglio davvero
fare è solo prendere la risposta che ottengo
da James Ward calmo e rimandalo indietro
alla persona che sta chiamando questo
metodo del controller per fare ciò di cui abbiamo bisogno
per essere un po ‘funzionale qui così
che avrà un impatto su tutti
programmazione java 8 che avremo
per imparare alcuni concetti funzionali così così
ecco il tuo primo, quindi quello che ho è
una promessa di risposta AWS di cui ho bisogno
converti che non voglio semplicemente bloccare
su questa risposta da James Ward calmo
è un lavandino e non lo blocco voglio
fanculo così, invece, quello che voglio
fare è voglio trasformare la cosa
all’interno della risposta c’è la cosa
dentro la promessa che voglio
trasforma quella cosa dentro in questo caso
la risposta WS in un risultato va bene, ma io
voglio farlo senza bloccare così il
il modo in cui lo facciamo è con la mappa così
quello che farò è che lo farò
il mio jwf e poi ho intenzione di fare una mappa
mappa ciò che la mappa fa si trasforma
le cose dentro le scatole è tutto
la mappa fa e così in questo caso sto andando
per trasformare la risposta di ws in a
risultato così il modo in cui lo faccio
una funzione in modo che la mappa abbia una funzione
farò la trasformazione così in questo
caso che la trasformazione avverrà
quando avrò la risposta di James
Ward calmo e poi gestirà questo
funzione di mappa su quella cosa e poi fare
la trasformazione quindi sto davvero andando
avere due promesse qui, giusto
la promessa per cui ho dato il gioco
questa effettiva richiesta al controller
richiesta e quindi hanno la promessa
per James Ward è calmo e quello esteriore
prometti quello che sta gestendo l’utente
connessione che non si sarà
soddisfatto fino a quando non lo adempia basato su
la richiesta di James Ward è una promessa calmo
essere soddisfatti così nella nostra funzione mappa
useremo di nuovo un lambda e
Ho intenzione di dire tutto adesso ho il mio
e quindi questo è il mio parametro e poi il mio
il corpo sarà per tornare okay e
allora userò quella risposta e
Vado a prendere il corpo di James
Ward calmo e poi ho solo bisogno di tornare
così che fuori il tipo di questa mappa
funziona ciò che effettivamente riesco a ottenere
vedremo se IntelliJ mi dice un po ‘
un po ‘strano, ma l’output di
quella funzione mappa è una promessa di a
risultato così mi sono trasformato da a
promessa di risposta a una promessa di a
risultato non chiedermi perché abbiamo un
risposta e un risultato obiettano perché lì
sono cose diverse in realtà lo so
che risposta è il risultato del lato di lettura
è il lato giusto quindi probabilmente lo sono
potrebbe essere un api unificato per leggere e
scrivi ma questo è il lato che leggiamo
i valori fuori e poi il risultato
che sto tornando è il lato che scriviamo
i valori vanno bene così è così
perché sono lì okay, andiamo a provare
questo qui spero che il compilatore
collabora e ci andiamo così solo
ho visto James Ward calmo in forma di testo
non ha impostato il tipo di contenuto così vediamo
james ward nel testo ok quindi ora era così
ciò che chiamiamo composizione reattiva così
Ho una richiesta che viene a casa mia
erver quindi una richiesta da parte mia
a James Ward com ho due richieste
e c’è un momento preciso in cui sono
sto solo aspettando calma il reparto di James
rispondere è wordpress PHP in modo che potesse
essere secondi e quindi sto aspettando quelli
pochi secondi perché PHP risponda e così via
c’è un po ‘ di tempo in cui ho
ottenuto queste due connessioni che normalmente
prenderebbe due fili e invece io
voglio prendere entrambi questi thread mentre
Sto solo aspettando che li dia
qualcun altro e poi quando la risposta
Torna da James Ward calmo quindi sono
andando a recuperare i thread e inviare
la risposta torna al browser così
è esattamente quello che sta succedendo qui
quando facciamo quella richiesta ok così c’è
c’è di nuovo il codice quindi domande
riguardo a quel tentativo speculativo così
gli attori sarebbero il modo giusto per farlo
fare un tentativo speculativo così quando noi
parlare degli attori otterrà di più
questo genere di cose
così i futures sono un modo per fare questo
gli attori di roba asincrona concorrenza sono
un altro modo di cui parleremo in a
pochi minuti quindi parliamo di
composizione anche se così così molti di questi
richieste e uno dei grandi motivi per
reattivo è ciò che voglio essere in grado di fare
cose in parallelo, quindi entriamo in
questa richiesta fa una seconda richiesta
in questo caso a Twitter com chiameremo
questo twf e ora quello che devo fare
è quello che voglio fare è creare un risultato
che prende sia la risposta di Twitter
corpo e il corpo di risposta di James Ward
e li compone insieme in a
unico risultato e ovviamente voglio il
tutta la faccenda è un lavandino e
non bloccante quindi per fare questo andiamo
per diventare un po ‘ più funzionale
così quello che ho intenzione di fare è che ho intenzione di
prendi il mio futuro su Twitter e lo farò
fai una mappa su questo e poi dentro di esso
faremo una funzione in questo modo
sarà il mio Twitter il parametro lì
è la mia risposta su Twitter e poi dentro
di questo il corpo di risposta quindi voglio
prendi il mio futuro JW e voglio fare una mappa
su quello e poi ho intenzione di essere
capace alla fine di tutto dentro
queste funzioni annidate sto andando
per poter chiamare questo JW sono
andando a essere in grado di fare il mio Twitter più
il mio JW che usa le stringhe è probabilmente un
esempio orribile ma come probabilmente
ho realizzato nel caso d’uso del mondo reale
useremmo dati JSON o altri
dati strutturati e tutto questo
insieme, okay, andiamo così così
non andando a compilare come è ed è
andando a prendere un po ‘per spiegare
perché così è una specie di modo normale
che pensiamo che va bene
Ho intenzione di fare una mappa sul mio Twitter 1
ho intenzione di fare una mappa sul mio JW e
quindi puoi essere in grado di ottenere entrambi
IntelliJ è un po ‘confuso riguardo al
aria dice che interferisce ciclicamente
Interferenza interessante forse è così
preciso non so cosa significhi
ma il problema qui è che l’output
di JW f mappare l’output di questo questo
funzione qui
spostiamoli giù così noi
vedere le cose un po ‘meglio immagino
il problema con questo è quello che jwf
mappa emette l’output di quello
la funzione è una promessa di un risultato sì
quindi questa è una promessa di un risultato e così
quindi se faccio questa mappa TW t WF e I in
il corpo di quella funzione ritorno
qualcosa che sta restituendo una promessa
un risultato quindi alla fine lo farò
restituire una promessa di una promessa di a
risultato okay e io non voglio così
quello che voglio invece è che voglio prendere
quella promessa di promessa di risultato e
appiattirli in un solo
promessa di un risultato e quindi di ciò che siamo
non è una mappa ma una mappa piatta
quindi la mappa così piatta è il modo in cui mi manca
paren sì, sto bene quindi la mappa è piatta
modo che facciamo una mappa e un appiattito e
lo facciamo in questo ordine e non lo so
perché l’abbiamo chiamata mappa piatta, immagino
perché Matt non si muove
la lingua quindi la chiamiamo pisolino ma
in realtà è una mappa e poi appiattita
appiattire è solo appiattendo quelli
cose così ora che stiamo tornando
è la promessa di un risultato, così ora noi
avere queste funzioni concatenate e
non importa quale ordine questi in realtà
sono definiti in questo caso perché quando
quando non sto effettivamente facendo la mappa
funzione quando non sto effettivamente chiamando
la funzione mappa è solo la memoria sul
mucchio che tiene il risultato di quella promessa
Quindi io non sono in realtà intenzione di utilizzare un
infila l’ordine non lo fa
importa quindi proviamo e assicuriamoci
Funziona così che dovremmo vedere
cinguettio ci andiamo c’è twitter
com e testo e poi da qualche parte
quaggiù sarà James Ward calmo
quindi ora sono stato in grado di farlo, ma ora
ci sono tre richieste e ovviamente tutto
questi sono lavorati a maglia e non bloccanti
così ad un certo punto nel tempo dove il
la richiesta di twitter è inattiva la richiesta
a James Ward la calma è oziosa
allora non userò nessuno
discussioni giuste per questo, ecco cos’è
dove possiamo ottenere un po ‘di alto valore
con parallelizzazione senza dover
avere questi costosi thread in uso
quindi puoi immaginare un caso d’uso più reale
qualcosa che ho effettivamente fatto è
fare come l’analisi dei sedimenti usando alcune API
su un gruppo di cose contemporaneamente e voglio
essere in grado di fare il maggior numero di quelli come me
può in parallelo quindi il fattore di gating su
quante cose posso fare in parallelo è
saranno quanti fili posso
allocare ma è attivo
connessioni quindi se io se ne ho dieci
thread assegnati che significa che potrei
avere 10 connessioni attive effettive aperte
per alcuni servizi che potrebbero significare
che ne ho in realtà un migliaio
connessioni che sono aperte ma
la maggior parte di loro tutti tranne 10 di loro sono aperti
ma stando semplicemente inattivo aspettando a
risposta va bene così che è reattivo
domande sulla composizione a riguardo
quindi l’ API ws è l’API REST in uscita
Sto solo lavorando con le stringhe ma tu
può sicuramente funzionare con Jason e poi
anche i metodi del controller supportano
Jason così così vedrai una delle cose
che possiamo passare a quello che è il
il codice di stato 200 è un oggetto nodo adiacente
quindi sto passando solo una stringa ma quello
potresti anche trasmettere il contenuto di Jason
sia l’uscita attraverso la libreria ws
e quindi la risposta del controller è entrambe
sostieni anche Jason
attualmente un problema con osservabili e
Sto cercando di pensare se lo farò
ricordati che ce n’erano alcuni
problema con il modo in cui usi osservabili e
futuro insieme credo ma quando noi
parlare di flussi reattivi c’è a
soluzione in arrivo per quel problema e
sarebbe un modo perfettamente accettabile
per farlo con RX java o qualcosa del genere
così così so che è così
flussi reattivi tecnicamente possibili
sarà il modo giusto per fare tutto questo
cosa con RX java ma ma parlerò
su questo in pochi minuti bene
domanda così non ho parlato di qualsiasi
resilienza quindi c’è a
modello di resilienza sulle promesse e c’è
diversi modi con cui puoi gestire
che così una promessa ha davvero tre
afferma che può essere sospeso può avere un
valore o può avere l’aria e poi
puoi impostare la gestione dell’aria attraverso
funzioni come queste sulle promesse quindi
uno dei modi che si possono affrontare
va in onda sulle promesse, si fa un recupero
recuperiamo in realtà possiamo provarlo
veloce quindi se faccio un recupero lo do
cosa una funzione che sta per recuperare
dal fallimento con con un valore
comunque e dovrei avere
qualcosa che ha recuperato con la destra
valore in questo caso una risposta WS non lo farò
in realtà compila il codice così è
solo un modo che potremmo gestire questo
fallimento potremmo anche c’è un on
gestore di aria che potremmo usare e noi
potrebbe registrare l’aria quindi c’è un numero di
modi diversi che vorremmo che noi
farebbe la resilienza sul futuro
dipende da cosa stai cercando e
gli errori in questi futuri stanno andando a
propagare così così se ho per impostazione predefinita se
ho uno stato di errore e uno dei miei
il bambino promette che si propagherà
completamente fuori in modo che potessi prenderlo
il tutto alla fine alla fine o io
potrebbe prenderlo dove è iniziato così
come si gestisce anche quello
va bene così è composizione reattiva con
più cose in parallelo andiamo
torna ad una coppia scorre tutte queste diapositive
sono in linea si blocca jet James Ward calmo
e abbiamo capito che non lo sono
andando a fare la vera demo attuale
ma lascia che ti mostri quello che spinge
come e con il server ha inviato eventi in gioco
noi questo non abbiamo davvero niente
Java 8 Penso che ci sia impiegato 23 a
nuova API Java 8 per eventi inviati dal server
ma gli eventi inviati dal server sono push a senso unico
dal server al client, quindi cosa
fa con gli eventi lato server è unghie
aprire una connessione che è un sink e
non bloccante e poi quando vuoi
puoi chiamare il metodo di invio dei dati a
spingere i dati verso il browser così belli
API semplice sia sul lato server che
dal lato del cliente per farlo così e
quindi anche WebSockets
quindi con una WebSocket ne abbiamo ora due
i canali di entrambi i canali sono reattivi
canali di spinta reattivi in modo tale da provenire
il client al server e l’altro
uno è dal server al client così
posso leggere i valori sul server i
può leggere i valori fuori dal canale
proveniente dal client al server e
quindi posso scrivere valori nel canale
proveniente dal server al client
entrambi sono un lavandino e
non bloccante quindi quando non lo sono
in realtà c’è oltre una connessione ma
quando non sono quando non siamo realmente
mandare qualcosa su quella connessione
allora non ne userà nessuno
filo così semplice implementazione
vedrai che questo è un riferimento al metodo
che sto usando qui in Java 8 così è
solo chiamarlo è come un eco
WebSocket così quando ricevo un messaggio
dal client ho intenzione di girare intorno
e scrivilo al cliente e così via
Faccio solo un metodo per gestire un metodo Java
maneggiate per quello ok quindi passiamo alcuni
minuti parlando di attori reattivi così
gli attori vengono dai giorni di Erlang e
ci sono alcune idee di attori che io
voglio evidenziare e poi mostrerò
qualche codice quindi l’attore
implementazione che sto per essere
usando si chiama acha acha è un attore
implementazione sulla JVM e così via
alcune cose che fa il modello dell’attore
per noi uno è che gestisce il nostro
concorrenza per noi quindi probabilmente hai
metti le chiamate sincronizzate nel tuo codice Java
prima questo è un modo per gestire il tuo
concorrenza è un modo doloroso per
fai che gli attori lo facciano per quello che loro
fai come lo fanno tu
creare un attore e c’è un attore in
il tuo sistema ma per parlarne
attore in realtà non lo usi direttamente
invece quello che fai con un attore sei tu
mandagli un messaggio e quel messaggio vada
in una casella di posta e poi quando possiamo ottenere
un filo saremo noi a consegnare il
messaggio all’attore e poi all’attore
elaborerà il messaggio e una volta è
fatto elaborare il messaggio a cui va
dormire è solo usando la memoria sul calore
allora sarà pronto a riceverne un altro
messaggio ma in attori garantiti solo
processo uno
tempo sagitta quindi ora hai un
alternativa al sincrono
blocchi sincronizzati ora hai
qualcosa che puoi garantire è solo
sta per succedere solo a te
in un momento quindi ti aiuta a gestire
la tua concorrenza in un livello molto più alto
costruire in modo usiamo sempre che l’attore
ref per pochi altri motivi uno dei
le ragioni sono che allora abbiamo la posizione
trasparenza quindi con acha quando invii
un messaggio a quell’attore che rifatta il reale
il vero attore che sarà
gestire un messaggio potrebbe effettivamente essere
da qualche altra parte sul cluster e tu
puoi decidere come vuoi che lo faccia
capita o se vuoi che ciò accada ma
ti permette di avere lo stesso costrutto
per in jbm così come attraverso jbm così tu
può salire e uscire e poi l’altro
motivo per l’attore ref per l’utilizzo di un
il riferimento è questo se per qualche motivo
quell’attore muore o se ne va potrebbe essere
un’eccezione non rilevata o la JVM è andata
giù o qualunque cosa possa essere funzionando
con quell’attore che ref è l’attore ref
sempre bene è sempre buono da ottenere
messaggi nella cassetta postale per quell’attore
quindi ci sarà una coda di messaggi
costruendo e potrebbe essere quello mentre
lavorando attraverso i messaggi su quella stecca
che l’extra si riavvia effettivamente o
si sposta su un server diverso o altro
potrebbe essere e la casella di posta non va
via e i messaggi stanno ancora andando
essere consegnati anche attraverso quei riavvii
dell’attore vero e proprio così ce lo offre
trasparenza o trans capacità di non
doversi preoccupare di cosa sta succedendo
quella effettiva implementazione dell’attore quindi
l’ultima parte sugli attori di cui hai bisogno
so che gli attori sono costruiti sugli alberi
quindi iniziamo con il sistema dell’attore che è
veramente la radice e poi costruiamo a
albero di attori, quindi ciò che significa è
quegli attori hanno figli e attori
genitore è supervisore è la cosa
è responsabile per determinare
cosa succede quando l’attore fallisce e
la strategia di supervisione predefinita è giusta
per riavviare l’ attore ma puoi costruire
la tua supervisione, ma ciò lo consente
di contenere il fallimento nella la
i rami del tuo sistema di attori così
che non si propaghi nel sistema
e abbattere tutto in modo che imparino
le parti importanti degli attori sono le uniche
costruire per agire per comunicare con
attori è di mandargli un messaggio ma
gli attori possono comunicare con l’invio
messaggi ad altre cose, quindi questo è
come gli attori comunicano è sempre attraverso
mandando questi messaggi gli attori possono avere un
durata di entrambi i millisecondi
o dell’intera durata che a
l’applicazione è in esecuzione o una sola
richiesta dell’utente in modo da poterne avere molti
attori che hanno molto molto diversi
diverse durate e un tipico attore
il sistema può avere decine di centinaia di migliaia
anche milioni di attori in un singolo in a
sistema di attore singolo quindi diamo un’occhiata
un po ‘di codice e questa roba sto andando
per copiare e incollare, quindi ho intenzione di passare
la mia piccola app qui da usare
attori invece di usare le promesse
che ho usato in modo ho intenzione di
per prima cosa crea qui una nuova classe Java e
chiameremo questo un attore che lo ha inserito
il pacchetto degli attori ora mi limiterò a incollare
in questo e poi passare qualche minuto
importare cose così è importare
spero di ottenere tutti quelli giusti e
se ti starai chiedendo perché ce ne sono due
diverse due diverse API se lo hai
notato che in queste importazioni vedono lì
viene riprodotto su un punto pi e su un punto non API
la convenzione di denominazione più strana che sia mai stata
In realtà i giochi francesi sono creati dal francese
ragazzi e quindi API in realtà è la Scala
API la non API è la API Java
tutti dovrebbero averlo saputo
è ovvio quindi sì, così andiamo così
devi assicurarti di ottenere il per
usando Java assicurati di avere ragione
nan api api lì ok, va bene così
allora ho intenzione di cambiare il mio
controller in modo da avere il mio attore lo farò
mostra il codice per questo in un secondo
torniamo qui e cambiamo
quello è un attore che pochi altri lo importano
uno e vediamo puntelli questo potrebbe essere
come un gioco che suoniamo e WS reattivo
ok oh foo attore uno di più va bene così andiamo
per prima cosa guarda il nostro attore qui, quindi cosa?
Ho fatto è che ho creato un nuovo non tipizzato
attore e attore il principale punto di ingresso in
questo attore è il metodo on receive
c’è una nuova API Java 8 e akka per
questo e io non sto usando il nuovo Java 8
API ma è molto più lambda e per
facendo questo genere di cose così questo è
solo l’API Java standard così ho
ottenuto questo in ricezione e ci vuole un
messaggio non tipizzato così ogni volta che tu
comunicare con gli attori è sempre un
messaggio non tipizzato e quindi puoi farlo
corrispondenza del modello o qualcosa del genere
oggetto di capire cosa fare e così
in questo caso lo sto solo facendo
chiedere di riprendere la mia promessa ma poi
Devo fare qualcosa di speciale quindi ora
Sto facendo qualcosa di affondante e non blocco
dentro e ho bisogno di vincere quella cosa
completa a cui voglio indirizzare un messaggio
la persona che mi ha inviato questo dall’altro
lato di quella chiamata giusta così così sto andando
per attraversare questo confine asincrono e voglio
per preservare il mittente della persona
chi mi ha mandato questo e volevo non capirlo
che si è mescolato in un programma concorrente
e quindi uso questo modello stop pipe in
per gestire quello che non ha un sacco di
tempo di andare in quello che è in realtà
facendo ma fidati di me se lo fai
tutto ciò che un lavandino e un attore usano
pattern pipe ok così ora nel nostro
controller qui è dove siamo effettivamente
creando l’attore quindi vado al
sistema dell’attore e sto dicendo creare per
io un attore del tipo foo attore e così
questo si spegne e dice al sistema dell’attore
per creare un’istanza di quell’attore ma
vedrai quello che torno non è il
istanza attore ma un attore respira il
riferimento a quella cosa e ora sono
intenzione di usare quell’attore
per comunicare con esso così che cosa sto facendo
è qui è il mio mio foo attore che sto facendo un
chiedi e il modo predefinito in cui l’ho detto
l’unico modo per comunicare
con un attore è di mandargli un messaggio
c’è quello è vero ma c’è un API
tipo di zucchero sintattico in cima a quello
chiamato e chiesto e chiede invia un
messaggio ma poi mi dà una promessa di a
risposta indietro esso fondamentalmente imposta
internamente una promessa che sarà
soddisfatta quando quell’attore risponde a me
con qualcos’altro così gli attori non lo fanno
deve essere richiesta la risposta, ma per alcuni
motivo amo le cose con richieste di risposta così
e poi quando lo fai ti chiedo sempre
Devo specificare un time out quindi sono
specificando un intervallo di cinque secondi okay
quindi quello che torno è una promessa
oggetto da quello perché questi messaggi
tra gli attori sono oggetti e poi
quello che sto per fare è fare una mappa
quella promessa e poi ho intenzione di lanciare
questa cosa a una risposta WS e poi
restituiscilo, così ora è il mio attore
implementazione basata andiamo ad aggiornarlo
e quello che dovremmo vedere adatto a tutte le compilazioni
c’è James Ward calmo, quindi non c’è
James Ward calmo ora attraversando il
attore quindi ci sono alcuni vantaggi per il
modello di attore possiamo possiamo usare entrambi
entrambi i modelli ci sono sicuramente casi d’uso
per entrambi uno dei grandi casi d’uso per
attori che non ho menzionato è quando
abbiamo uno stato mutabile quindi gli attori sono a
ottimo posto per mettere gli Stati mutabili che sei
sarà garantito che solo uno
i thread stanno per mutare quello stato
in un momento così così gli attori sono grandi per
gestiscono anche lo stato mutevole
ottimo per gestire cose come i tentativi
quindi quello che possiamo fare è avere un
attore che si comporta come questo
tipo di manager per tentativi e per
assicurandoci di ottenere una risposta a
un esempio molto semplice di questo è che è molto
comune che avrò nei miei sistemi e
attore che sta per ottenere alcuni dati ma
Ho sia il database che io ho un
sistema di cassa per ottenere dati da o voglio
per ottenerlo idealmente voglio ottenerlo
dai contanti ma se ricevo un errore di cache
e
voglio andare nel database giusto e così
quindi se ho un attore faccio una richiesta
per l’attore e dire hey ho bisogno di questo
i dati posso effettivamente utilizzare un router in acha
per dire ora inviare una richiesta a entrambi
attore di cassa e attore di database e
c’è un router chiamato è come
scatter raccogliere prima completo è il
router in modo che sparga i messaggi
li invia ad entrambi i miei attori bambini
e poi il primo che mi dà un
la risposta è quella che io in realtà
finiscono usando il valore che io
effettivamente utilizzare in modo da poter utilizzare qualcosa
così o ci sono altri router in
acha anche per creare un tipo di riprova di
i tentativi di sistema probabilmente hanno qualche stato
coinvolto come numero di tentativi quanti
volte ho provato questo genere di cose così
un attore diventa un buon modo per dirlo
informazioni sullo stato e fare i tentativi
sì sì, potresti sicuramente crearne uno
router acha che avrebbe esattamente
quel comportamento ce ne sono alcuni
router pronti all’uso e quindi è possibile
scrivi anche i tuoi router personalizzati
forse qualcuno che ne ha già scritto uno
quello che lo fa specificamente ma
okay , questa è una vera e rapida introduzione
attori che voglio andare avanti così posso
parlare di flussi reattivi molto velocemente
e poi avremo qualche minuto
per domande così reattive flussi cosa
è un nuovo progetto in tutto
collaborazione tra typesafe Netflix
Twitter e un sacco di altre persone a
creare fondamentalmente uno standard JVM per
facendo un sink e reattivo non bloccante
flussi con contropressione e così là
sarà un numero di ciò che il
il progetto di flussi ripidi reattivi è a
implementazione di riferimento una specifica
un TCK quindi tutte le cose che qualcuno
potrebbe creare un’implementazione di
flussi reattivi in cima così la RX
i ragazzi di java stanno lavorando a un reattivo
implementazione dei flussi su RX java
c’è ovviamente un’implementazione di naka
e penso ci sia un film e un film
è schizzinoso, no, mi dispiace c’è un vortice
il vertice ha ottenuto un terzo vertice
implementazione di flussi reattivi come
bene
quindi questo è un nuovo progetto davvero eccitante
per essere in grado di fare un lavandino e
flussi non bloccanti di dati con retro
pressione così reale esempio veloce di ritorno
la pressione è se ho un caricamento in arrivo
da un client a un server e quindi lo sono
prendendo quei morsi e spingendoli
ad amare Amazon s3 o qualche altro servizio
Io davvero non voglio che il cliente invii
più morsi di quelli che posso inviare a quello successivo
servizio perché poi mi costruirò
Buffers giganti e ed esaurendo
memoria e quindi voglio essere in grado di mettere
contropressione sul produttore da dire
smettere di produrre così tanti dati o rallentare
ma voglio essere in grado di farlo in un
modo reattivo tradizionalmente contropressione
è stato fatto nella maggior parte delle implementazioni in
un modo molto sincrono in un molto
modo di blocco e flussi così reattivi è
riguardo alla possibilità di farlo in un non
bloccando il modo in cui controllarlo reattivo
desk flussi org per ulteriori informazioni
c’è già implementazioni c’è
nell’attivatore typesafe c’è già
alcune applicazioni di esempio per farti
iniziato con flussi reattivi quindi controlla
questo è abbastanza nuovo e
eccitante ok così il tempo per le domande noi
avere un paio di minuti in più in questo
caso voglio essere in grado di chiamare il mio
funzione quando ho ricevuto la risposta
e questo è tutto un sink e non-blocking
per entrambi così così quando vincono il
la risposta ritorna dal servizio
mi siedo sul mucchio finché non lo faccio davvero
finché non ne ho davvero bisogno e così è così
in realtà non si utilizza una discussione no no
non sei tu quando è quando è solo
stare inattivo è quando non sono attivamente
trasferendo punture sul filo è
non usando le risorse di rete non lo è
usando un thread è solo usando la memoria
il caldo così era quello che era il
l’intero obiettivo era quello di ottenere una sincronizzazione
non bloccando completamente
tutta la catena e non stare mai bloccando
risorse che non vengono mai utilizzate
ecco perché ho dovuto nidificare quelli lì
c’è un altro modo per farlo
non ha mostrato e se ho un sacco di
è tecnicamente la stessa cosa, ma se io
avere un sacco di ballo di fine anno
questo è quello che voglio tipo di aggregato
insieme c’è qualcosa chiamato
promettere la sequenza o il futuro di quella sequenza
e questo prende una lista di promesse e
quindi mi consente di avere una funzione mappa
su tutti quelli che poi ottengo
indietro un elenco di tutte le mie risposte o
tutti gli oggetti che torno così tanto
quello sarebbe un altro modo per farlo
c’è anche una zip e un numero di altro
modi ma ma in ogni caso si guarda così a lungo
come ti attacchi con le funzioni della mappa e
e un sink e costrutti non bloccanti
allora sarai sincronizzato non bloccante
tutta la strada in tutta non ci sarà mai
essere un momento in cui blocchi le risorse
inutilmente quindi per promesse di default
in realtà non hanno un concetto di a
il timeout in essi riproduce il client del servizio web
la biblioteca fa e poi c’è anche tu
puoi creare la nostra promessa?
avere un timeout se lo hai appena trovato
stack overflow ma ma così si crea a
prometto che ha un timeout e
allora quello sarebbe fallito e poi lo faresti
fare un recupero con quello da affrontare
con l’errore con il timeout
fallimento posso mostrarvi esempi di codice di
che se vuoi dopo tutto okay
bene, grazie per essere venuto, lo spero
è stato utile sarò in giro se lo hai
altre domande grazie
tu
non ero preso come sei settimane fa
a forza lavoro che lavora su alcuni
i progetti là più recentemente ne hanno fatti
ovunque applicazione intera così questo
questa presentazione sarà circa
costruire lavori reattivi quindi prima di tutto
iniziamo un po ‘di setup
quindi la ragione per cui le persone reattive sono
parlare di persone o di costruire è
perché ciò che gli utenti vogliono è cambiato ma
ora abbiamo alcuni strumenti che aiutano
noi per soddisfare le esigenze degli utenti che sono state
in giro per molto tempo quindi alcuni di questi
le esigenze degli utenti sono sincronizzate in tempo reale
collaborazione feedback immediato non a
Aspetti queste sono cose che abbiamo sempre
voluto ma per costruire questi tipi di
le applicazioni in passato non l’abbiamo fatto
davvero gli strumenti sono facilmente accessibili
quindi la cosa su reattivo è questo
è in qualche modo solo prendendo un sacco di
queste idee che sono state in giro per a
molto tempo e li rende generalmente
accessibile a noi come sviluppatori così
c’è qualcosa chiamato reattivo
manifesto che puoi scoprire reattivo
Manifesto org e e l’idea del
manifesto del reattore è quello di mettere insieme
queste idee in alcuni modi di alto livello per
descrivi come consegniamo queste cose
che gli utenti vogliono e quindi me ne andrò
attraverso di loro è molto veloce ma puoi farlo
controlla il manifesto del reattore sul tuo
proprio e puoi firmarlo se sei d’accordo
con esso così a prima che gli utenti vogliono
applicazioni che sono reattive e
reattivo comprende un sacco di
cose diverse latenza e non andare
giù e tutto quel genere di cose da fare
che dobbiamo costruire su una base
quello è scalabile e resiliente così quelli
sono i due tipi di tratti centrali di
reattivo e quindi per fare tutto
questo abbiamo bisogno di una fondazione che sia
guidato dagli eventi è proprio ciò che consente
noi per essere scalabili e resistenti al
stesso tempo e consegnare reattivo
interfacce per i nostri utenti così questo è il tuo
breve piccola sinossi su ciò che è reattivo
è su di te puoi leggere molto di più
su reagire a manifest org il manifesto
è intenzionalmente tecnologia agnostica così
non importa quale sia la tecnologia
stai usando l’idea dovrebbe dovrebbe
applica in modo che vedrai queste idee in un certo modo
intrecciato ma voglio concentrarmi
più oggi sul reale come come facciamo noi
effettivamente costruire applicazioni reattive e
quindi ho intenzione di passare attraverso un po ‘di
tre diversi modi in cui lo facciamo così
prima parla di web reattivo e
parlando di attori reattivi e poi
parlando di flussi reattivi, quindi quelli
sono i tre argomenti principali, quindi tratteremo
e probabilmente passerò la maggior parte del tempo
sul web le cose hanno un po ‘ di
tempo la fine per attori e flussi così
per prima cosa parliamo del
web reattivo così web reattivo è tutto
su un sink e non-blocking
probabilmente la terminologia che hai
sentito più in giro reattivo è un lavandino e
non bloccante è un po ‘su un lavandino
e non bloccante per dire davvero un lavandino
e il non-blocco è un po ‘strano
perché non possiamo essere realmente
non bloccante senza essere un lavandino, così noi
potrei dire solo non bloccante ma per alcuni
motivo diciamo un sink e non-blocking
ma se sei solo un lavandino, c’è davvero
è davvero un negativo che non vuoi
basta essere un lavandino per il gusto di essere un
affondare c’è non c’è davvero alcun motivo per
fallo complicare la tua programmazione
modello assicurati che il tuo codice sia più difficile
fare il debug così veramente la ragione per cui siamo
andare avanti è perché vogliamo essere
non bloccante quindi ne coprirò quattro
diversi modi in cui possiamo essere un sink e
non bloccare le richieste reattive reattive
spinta reattiva composizione e a
reattivo quindi in poche parole un lavandino e
non-bloccante in termini di web è
per prima cosa dobbiamo contrastare questo con il nostro
tipico modello servlet tipico servlet
il modello ottiene un nuovo post e questo è pari
vero per servlet 30 e 31 il
percorso tradizionale attraverso una rete
la richiesta sta bloccando e cosa significa
è quello quando quella connessione è giusta
seduto lì tipo di attesa per il
dall’altra parte per rispondere aspettando il
dall’altra parte per generarne qualcuna di più
dati in realtà lo terremo
gira intorno in modo che manterremo il
filo attivo voi
quando la connessione non è attiva
essere usato è il modello tradizionale
è così che abbiamo costruito
applicazioni per lungo tempo così nel
modello asincrono e non bloccante cosa noi
voglio fare è vogliamo essere in grado di prendere
quel thread e quando vinci quella connessione
è inattivo, vogliamo essere in grado di prenderlo
risorsa che filtra e da ‘ a
qualcun altro e questo ci permette di avere
migliore resilienza di scalabilità parleremo
circa un po ‘più tardi, quindi questo il
ragione per cui questo ci permette di avere di meglio
la scalabilità è una coppia quindi prima possiamo
fare molte più cose in parallelo quando noi
usa questo modello dove non stiamo bloccando
tutti questi fili idealmente vogliamo il nostro
i numeri dei thread devono essere ridotti a circa il
numero di core che abbiamo sul nostro
sistema che è davvero il numero ottimale
di thread all’interno della JVM di solito
avere un sacco di discussioni in testa e quello
tipo di cose quindi è difficile in realtà
ottenere esattamente lì ma ma questo è il
ideale è quello che vogliamo puntare
ci sono alcuni motivi per cui vogliamo mirare
per quella CPU le cache rimangono meglio memorizzate nella cache
quando non stai facendo il contesto
commutazione di thread inoltre c’è un
overhead piuttosto significativo per thread così
la dimensione dello stack predefinita su GBM I
penso sia un megabyte e quindi questo significa
che ogni thread sul tuo sistema richiede un
megabyte solo per lo stack e così via
non possiamo semplicemente allocare migliaia di
discussioni anche se abbiamo performant a
modo performante per passare da quelli
discussioni stiamo ancora assegnando molto
memoria e ci piacerebbe pensare che noi
can e 64-bit jbm è solo avere come
molta memoria che vogliamo usare tanto
memoria come vogliamo una singola JVM che sia
davvero non è vero, c’è GC più grande e
pause GC più grandi almeno nella maggior parte delle JVM
più grande è il tuo mucchio e così tu
non voglio solo assegnare migliaia di
discussioni perché poi stai andando
ho un sacco di memoria che è quello
questo sta prendendo più tempo nel tuo GCS
così così fa questo è uno degli altri
effetti collaterali e perché vorrebbe andare
asincrono un non-blocco è quando non lo sei
usare i thread perché li hanno assegnati
non stiamo usando una vera connessione perché
averlo assegnato così l’altra parte di
questo e ‘quello
ora dobbiamo essere in grado di gestire molto
più connessioni ai nostri server perché
abbiamo tempo reale perché forse abbiamo
Dispositivi Internet of Things e milioni
di dispositivi tutti collegati al nostro servizio
quindi essere in grado di gestirne così tanti
connessioni che iniziamo a fare in realtà
colpire limita i limiti fisici sull’hardware
se abbiamo bisogno di essere in grado di gestire facciamo
diciamo un milione di connessioni simultanee noi
non hanno affondano e non bloccano
quindi allora l’ultima ragione per cui lo farò
coprire intorno async asincrono e non
il blocco è per ismo parallelo è spesso
ora nelle nostre applicazioni abbiamo un
chiedi , entra e poi stiamo andando
per soddisfare un maggior numero di richieste e
vogliamo provare a fare come molti di quelli in
il più parallelo possibile e veramente uno di
i nostri fattori di gating per quanto possiamo
fare in parallelo è quanti fili abbiamo
può allocare e quindi quindi se siamo a
affondare e non bloccare quindi quelli smazzati
le richieste saranno in grado di
operare in modo molto più efficiente in
parallelo perché non avremo
il sovraccarico delle richieste per connessione
o un thread tenuto per tutto l’idolo
connessioni in modo che è la nostra rapida panoramica
su un lavandino e senza bloccare voglio
immergersi in qualche codice per mostrare effettivamente come
faremmo questo puoi prenderne un po ‘
queste idee un po ‘meglio, ma voglio
fai un sondaggio del pubblico a cui arrivi
selezionare codice Java 8 o codice Scala
ok ok, java 8 ok, penso che succederà
essere un codice Scala di un’ora era vicino ma
Penso che Java 8 1 sia così ok, così siamo
Ci tufferemo e costruiremo un
piccola app per mostrare come fare un lavandino e
sblocco con Java 8 così ho intenzione di
usa qualcosa chiamato attivatore typesafe
è un modo per costruire gioco e akka e
Applicazioni Scala e Java 8
applicazioni così ho intenzione di chiamare
attivatore e dire non creare nuovi sono
andando a creare una nuova applicazione ho appena
attivatore scaricato è un file zip e
l’ho estratto e l’ho aggiunto al mio percorso così
poi selezionerò il gioco java
esempio e ci andiamo quindi lasciami andare
in quel gioco Java questo è ora il mio nuovo
progetto che ho appena creato e che sono
andando a correre così vado a
attivatore finché non corrono e mentre è così
Iniziando fammi entrare in IntelliJ qui
e aprire questo progetto così ho voluto
inizia da zero in modo da poter ottenere un
idea per quello che sembra per te
quando inizi da zero così sarà
prenditi un secondo per ottenere tutto e
in esecuzione in IntelliJ e ottenere il
progetto tutto pronto quindi andiamo a prendere un
guarda prima il layout di questo
progetto quindi se guardo in questo progetto
whoa ignoriamo la directory di destinazione
lì quindi se guardo in questo progetto
ci sono alcune cose diverse che sto andando
per essere passato così per primo in una commedia
questo è un gioco di applicazione di gioco
quadro è un sink e non bloccante
della scatola non usa il servlet
api usa Neddie per un lavandino e non
bloccare così giocare nel modo in cui siamo fuori
è il modo in cui gestiamo le richieste
attraverso un controller daremo un’occhiata a
che in un secondo e poi ho opinioni
quali sono i miei template lato server che posso
ovviamente uso angolare e lato client
le tecnologie ci sono compilatori di risorse
che potremmo vedere un po ‘se noi
avere tempo c’è un file di rotte dove io
definire in modo dichiarativo il routing di
richieste per la mia domanda e poi a
pochi altri file per build build simile
informazioni e quel genere di cose così
questa è la mia struttura di progetto di base
sembra che sia attivo e funzionante su IntelliJ
prima che io vada là, andiamo a tirare questo
cosa nel browser così dovrebbe essere
su e in esecuzione su localhost 9000 lì
noi andiamo c’è la nostra piccola giocata
applicazione Va bene così andiamo ad aprire
quel file di rotte e ho intenzione di andare
crea un nuovo percorso in modo che il percorso sia solo un
mappatura tra un verbo HTTP e un percorso
metterà / cibo per il percorso e poi
un metodo di controllo per chiamare e quindi sono
andrò nel mio controller qui e
vedrai che c’è già un controller
Ne aggiungerò uno nuovo, così farai
vedi che sto usando statico qui con il gioco
possiamo iniziare con metodi statici
e quindi possiamo passare dalla statica
metodi per l’iniezione di dipendenza, se noi
voglio ma i metodi statici sono i più semplici
modo per la demo, quindi lo useremo oggi
quindi un controllore in gioco quello che fa è
è ci vuole una richiesta e ritorna
una risposta quindi in questo caso la risposta
l’oggetto è chiamato il risultato così ora io
ho solo bisogno di restituire un nuovo risultato, quindi sono
andando a restituire un risultato del codice di stato 200
con un corpo stringa che contiene solo
Asda è il mio controller di base
e suona proviamo e facciamo
certo che funziona così ci andiamo c’è
il mio controller è ok, quindi è la mia base
il controller sotto le cover suona
facendo ciò sincronizzato non bloccando ma
quello che hai visto finora è il mio codice
non era un lavandino esplicitamente così sotto
le coperture questo è un lavandino e non
bloccando ma dal mio punto di vista il
codice I Britain è sincrono quindi andiamo
fai un altro passo avanti e facciamolo ora
asincrono quindi invece di restituire a
risultato ho bisogno di restituire qualcosa che
promette di restituire il risultato nel
futuro, quindi userò il f’d up
prometto che questo è davvero solo un involucro
intorno al futuro della Scala, quindi gioca
è costruito internamente con Scala, quindi questo
è un’API che è una bella interfaccia Java
in cima a questa questa futura API in Scala
quindi un po ‘di futures e
promette che la terminologia è una specie di
usato mescolato di solito il
terminologia almeno nello studioso
mondo penso nel mondo JavaScript come
bene è che il futuro è il lato che
Posso leggere un risultato futuro da e
quindi la promessa è quella giusta
posso scriverlo così è la maniglia
entrambi sono maniglie, la promessa è la
gestire che posso scrivere il risultato in
il futuro è il lato che posso leggere
il risultato fuori da così in Java API I
pensa di essere coerente con altri Java
api per qualche motivo siamo crollati
il futuro e i concetti promessi in a
un singolo oggetto chiamato promessa non del tutto
certo perché l’abbiamo fatto, ma lo vedrai
Ora ho un errore di compilazione perché lo sono
restituendo non una promessa di un risultato ma
Sto ancora restituendo un risultato così
quello che devo fare è creare qualcosa
quello che in futuro produrrà il
risultato e
allora saremo un sink esplicitamente
asincrono quindi creerò a
nuova promessa qui e userò
il metodo promessa punto promessa e il
promesso metodo promettente se guardiamo
se guardiamo la firma vedremo
che prende una funzione così perché II
non voglio realmente chiamare questo codice
quando la richiesta entra nel modo giusto se io
sinistra come questo allora sarebbe
provando a chiamare questo ok e produrre
il risultato immediatamente invece ho bisogno
qualcosa che posso chiamare più tardi
produrre quel risultato per soddisfare il
prometti ed essere in grado di ottenere il risultato
fuori dal futuro, quindi non posso tornare
non posso semplicemente chiamare questa cosa e
restituire il risultato che devo invece dare
è una funzione che poi può giocare
internamente quindi chiama quella funzione in seguito
per ottenere il risultato da così ora sono
andando a usare la sintassi Java 8 nu lambda
e ho intenzione di definire un po ‘
funzione in linea qui molto più bello
rispetto alla vecchia sintassi Java per farlo
ma ora quella è una funzione che ho
appena definito che non richiede parametri
questo è il parametro lambda lì
non ci sono parametri e quindi la funzione
il corpo restituisce il risultato così ora
giocare internamente ora ha una maniglia così quando
la richiesta entra in questo metodo di gioco
ora ha una maniglia per qualcosa che lo farà
in futuro produrre il risultato e così via
allora quando il gioco è pronto per essere in grado di
ottenere quel risultato che sta per invocare
questa funzione e quella funzione lo faranno
produrre il risultato quindi proviamo
e andiamo a cambiare quella stringa così noi
può verificare che funzioni effettivamente così colpito
aggiornare e compilare e quindi dovremmo
vedi ooh azione non trovata che è un io sono
usando il gioco due tre e quello è un bug
devo amare il nuovo software tutto a posto
Ho sicuramente un percorso
proviamo di nuovo, hai sempre pulito
oh uomo sono in cattivo stato qui
andiamo lì andiamo bene quindi non usare
punto zero software giusto questo è il gioco 2
30 aspetta fino a 231 ok ma vedremo
che ha funzionato vuole capire il compilatore
fuori cosa fare così ci andiamo ora ho
ho il mio controller che è quello che è ora
esplicitamente asincrono, quindi va bene
Sono esplicitamente asincrono ma lo sono
ancora non proprio non bloccante per non essere
bloccando devi avere qualcosa da fare
non bloccare su e in questo momento non lo faccio
ho davvero qualcosa da non bloccare su così
buoni esempi di cose da non bloccare
la nostra rete i / o è qualcosa che non possiamo
blocco e poi timeout o qualcosa del genere
non possiamo bloccare i messaggi degli attori
ci sono un sacco di cose là fuori
che stanno diventando più comuni a
non bloccare, ma quindi abbiamo bisogno di uno di quelli
cose così solo come esempio un modo per
il blocco non è con un timeout ritardato
fondamentalmente qualcosa che dice chiama questo
funzione in una certa quantità di tempo così
invece della promessa promessa, vado
fare un ritardo di promessa vedrà che c’è un
pochi altri parametri qui così il secondo
parametro è la quantità di ritardo e
allora dirò di farlo per tempo
unità di secondi quindi 45 secondi, quindi sta andando
per ora aspetta per cinque secondi e così
aspetta probabilmente il modo sbagliato di usarlo
cinque secondi invocheranno questo
funzione che soddisferà questa promessa
e quindi restituire il risultato, quindi facciamolo
proviamoci con speranza, il
compilatore collabora questa volta sto andando
per aprire la finestra di ispezione perché noi
dovrebbe essere in grado di una volta che viene compilato
dovremmo essere in grado di vederlo davvero
il ritardo di cinque secondi accade così ci siamo
sembra che abbia funzionato, lo vedrai
c’era un secondo e mezzo di compilazione
tempo e poi e poi i cinque secondi
ritardo quindi torniamo al codice così
ora ho qualcosa che è un lavandino e
non bloccante quindi sono esplicitamente asincrono ma
ora ho qualcosa su cui non posso bloccare
è un po ‘di inganno qui
perché
è lì per avere qualcosa
è su un timer che si attiva ad un certo punto
in futuro ci deve essere un
infilare lì, quindi c’è un filo che
viene utilizzato per tutti questi tipi di
timeout all’interno della JVM quindi non c’è
un thread ma potrei avere un milione
le richieste entrano in questo controller e
tutti loro per quei cinque secondi
semplicemente andando a sedermi lì senza usare nessuno
discussioni Avrò solo quel timer
thread che gestisce tutti i timeout
quindi questo è ora un sink e
non bloccante quindi torniamo qui e
colpiamolo di nuovo così ce n’è un cinque
secondi in cui il mio browser è solo
girando quindi ho una richiesta HTTP aperta
per il mio server questo è solo uno standard
Richiesta HTTP non c’è nulla di speciale
il browser non ha conoscenze speciali
su questo ciò che è in realtà essere
accade sul server per rendere questo a
affondare e non bloccare così per quel cinque
secondi la ruota del browser è giusta
girare è come hey non ho
ricevuto qualcosa ancora non ho ricevuto
tutto ancora così, ma dal lato server
la richiesta è arrivata in quel controller
il metodo ha restituito la promessa del risultato
e quindi il thread per quella connessione
andò via andò da qualcun altro e così
poi cinque secondi dopo il ritardo
sta andando a calci sta andando a correre
quella funzione allora avremo un
infiliamo indietro e poi abbiamo intenzione di essere
in grado di inviare tali dati in modo che per
che la maggior parte di quei cinque secondi ci sono stati
in realtà nessun thread allocato sul
lato server da gestire in questa richiesta
sì, dal lato del cliente, penso che
Chrome probabilmente sta facendo anche un sink e
non bloccante ma questo dipende dal
cliente reale per decidere come gestisce
il vero networking così tutto questo è
basata su Java Java niño niño fornisce
noi un modo asincrono di fare rete Io oh così
Nettie è l’implementazione che gioca
usi di Java niño e quindi questo è davvero
ciò che ci dà la possibilità di essere sincronizzati
non bloccante quindi tutti i controller fuori
la scatola o un non-blocco sincronizzato ma noi
può essere esplicitamente un sink e non
bloccando se abbiamo qualcosa da non fare
blocco su ok voglio fermarmi per un secondo
e vedere se ci sono domande
prima di ottenere di più
complicato e più utile, sì vai
avanti è totalmente a voi quello che fai
questo è il tuo futuro e le tue promesse
solo un esempio molto banale ma puoi farlo
creare una promessa e quindi si può avere
qualunque cosa tu voglia adempiere a quella promessa
quindi diciamo che parli al tuo livello dao
tu passi quella promessa nel tuo dao
strato e quindi il tuo livello dao potrebbe quindi
adempiere quella promessa giusto così questo è uno
come potresti farlo probabilmente a
il modo migliore per farlo è che avresti effettivamente
un metodo chiama al tuo dao il loro ritorno a
promessa di alcuni dati e poi tu
allora saresti in grado di ascoltare
all’interno del controller impostare una maniglia
su quel completamento e poi trasformalo
nel risultato attuale e questo è
molto simile a quello che vedremo
in un secondo streaming sì, c’è così
quindi lo streaming è molto diverso
modi per fare streaming se cercherò di mostrare
uno di loro in un po ‘che è
entrambe le prese web o servizio ed eventi
ma puoi anche fare commenti o scusami non
commento puoi anche fare pezzi
le risposte e puoi renderle a pezzi
risponde a un sink e non blocca come
bene, quindi non ho intenzione di mostrare un chunked
uno ma ce n’è uno buono nel gioco
documentazione che mostra come fare
risposta Chunked un sink e sblocco
risposte Chunked okay, andiamo
rendi questo più utile quindi l’ho fatto
questo ritardo non è molto utile facciamolo
qualcosa di più utile che è una rete
chiamata di servizio quindi vado a vincere il
la richiesta arriva al server che sto andando
per poi fare un’altra richiesta dal mio
il server su un altro server ottiene alcuni dati
e quindi restituire quei dati indietro così facciamo
scrivi il codice per primo, quindi cosa
Ho intenzione di tornare sarà una F
punto prometto di risposta AWS e lo faremo
chiama questo jwf e poi per fare questo lo sono
andando a utilizzare il servizio web di gioco
la biblioteca dovrebbe essere così per essere sicuro di averlo
quello giusto ha importato, okay allora lo sono
andando a impostare l’URL di James Ward calmo
e poi farò una richiesta di ottenere
quindi se guardiamo a cosa succede
effettivamente facendo una richiesta di ottenere guardiamo
ciò che ritorna è una promessa di AWS
risposta quindi questo non è il reale
risposta è una promessa a qualcosa
che in futuro mi darebbe
la risposta e quindi non posso non posso usare
questa risposta ancora quello che voglio davvero
fare è solo prendere la risposta che ottengo
da James Ward calmo e rimandalo indietro
alla persona che sta chiamando questo
metodo del controller per fare ciò di cui abbiamo bisogno
per essere un po ‘funzionale qui così
che avrà un impatto su tutti
programmazione java 8 che avremo
per imparare alcuni concetti funzionali così così
ecco il tuo primo, quindi quello che ho è
una promessa di risposta AWS di cui ho bisogno
converti che non voglio semplicemente bloccare
su questa risposta da James Ward calmo
è un lavandino e non lo blocco voglio
fanculo così, invece, quello che voglio
fare è voglio trasformare la cosa
all’interno della risposta c’è la cosa
dentro la promessa che voglio
trasforma quella cosa dentro in questo caso
la risposta WS in un risultato va bene, ma io
voglio farlo senza bloccare così il
il modo in cui lo facciamo è con la mappa così
quello che farò è che lo farò
il mio jwf e poi ho intenzione di fare una mappa
mappa ciò che la mappa fa si trasforma
le cose dentro le scatole è tutto
la mappa fa e così in questo caso sto andando
per trasformare la risposta di ws in a
risultato così il modo in cui lo faccio
una funzione in modo che la mappa abbia una funzione
farò la trasformazione così in questo
caso che la trasformazione avverrà
quando avrò la risposta di James
Ward calmo e poi gestirà questo
funzione di mappa su quella cosa e poi fare
la trasformazione quindi sto davvero andando
avere due promesse qui, giusto
la promessa per cui ho dato il gioco
questa effettiva richiesta al controller
richiesta e quindi hanno la promessa
per James Ward è calmo e quello esteriore
prometti quello che sta gestendo l’utente
connessione che non si sarà
soddisfatto fino a quando non lo adempia basato su
la richiesta di James Ward è una promessa calmo
essere soddisfatti così nella nostra funzione mappa
useremo di nuovo un lambda e
Ho intenzione di dire tutto adesso ho il mio
e quindi questo è il mio parametro e poi il mio
il corpo sarà per tornare okay e
allora userò quella risposta e
Vado a prendere il corpo di James
Ward calmo e poi ho solo bisogno di tornare
così che fuori il tipo di questa mappa
funziona ciò che effettivamente riesco a ottenere
vedremo se IntelliJ mi dice un po ‘
un po ‘strano, ma l’output di
quella funzione mappa è una promessa di a
risultato così mi sono trasformato da a
promessa di risposta a una promessa di a
risultato non chiedermi perché abbiamo un
risposta e un risultato obiettano perché lì
sono cose diverse in realtà lo so
che risposta è il risultato del lato di lettura
è il lato giusto quindi probabilmente lo sono
potrebbe essere un api unificato per leggere e
scrivi ma questo è il lato che leggiamo
i valori fuori e poi il risultato
che sto tornando è il lato che scriviamo
i valori vanno bene così è così
perché sono lì okay, andiamo a provare
questo qui spero che il compilatore
collabora e ci andiamo così solo
ho visto James Ward calmo in forma di testo
non ha impostato il tipo di contenuto così vediamo
james ward nel testo ok quindi ora era così
ciò che chiamiamo composizione reattiva così
Ho una richiesta che viene a casa mia
erver quindi una richiesta da parte mia
a James Ward com ho due richieste
e c’è un momento preciso in cui sono
sto solo aspettando calma il reparto di James
rispondere è wordpress PHP in modo che potesse
essere secondi e quindi sto aspettando quelli
pochi secondi perché PHP risponda e così via
c’è un po ‘ di tempo in cui ho
ottenuto queste due connessioni che normalmente
prenderebbe due fili e invece io
voglio prendere entrambi questi thread mentre
Sto solo aspettando che li dia
qualcun altro e poi quando la risposta
Torna da James Ward calmo quindi sono
andando a recuperare i thread e inviare
la risposta torna al browser così
è esattamente quello che sta succedendo qui
quando facciamo quella richiesta ok così c’è
c’è di nuovo il codice quindi domande
riguardo a quel tentativo speculativo così
gli attori sarebbero il modo giusto per farlo
fare un tentativo speculativo così quando noi
parlare degli attori otterrà di più
questo genere di cose
così i futures sono un modo per fare questo
gli attori di roba asincrona concorrenza sono
un altro modo di cui parleremo in a
pochi minuti quindi parliamo di
composizione anche se così così molti di questi
richieste e uno dei grandi motivi per
reattivo è ciò che voglio essere in grado di fare
cose in parallelo, quindi entriamo in
questa richiesta fa una seconda richiesta
in questo caso a Twitter com chiameremo
questo twf e ora quello che devo fare
è quello che voglio fare è creare un risultato
che prende sia la risposta di Twitter
corpo e il corpo di risposta di James Ward
e li compone insieme in a
unico risultato e ovviamente voglio il
tutta la faccenda è un lavandino e
non bloccante quindi per fare questo andiamo
per diventare un po ‘ più funzionale
così quello che ho intenzione di fare è che ho intenzione di
prendi il mio futuro su Twitter e lo farò
fai una mappa su questo e poi dentro di esso
faremo una funzione in questo modo
sarà il mio Twitter il parametro lì
è la mia risposta su Twitter e poi dentro
di questo il corpo di risposta quindi voglio
prendi il mio futuro JW e voglio fare una mappa
su quello e poi ho intenzione di essere
capace alla fine di tutto dentro
queste funzioni annidate sto andando
per poter chiamare questo JW sono
andando a essere in grado di fare il mio Twitter più
il mio JW che usa le stringhe è probabilmente un
esempio orribile ma come probabilmente
ho realizzato nel caso d’uso del mondo reale
useremmo dati JSON o altri
dati strutturati e tutto questo
insieme, okay, andiamo così così
non andando a compilare come è ed è
andando a prendere un po ‘per spiegare
perché così è una specie di modo normale
che pensiamo che va bene
Ho intenzione di fare una mappa sul mio Twitter 1
ho intenzione di fare una mappa sul mio JW e
quindi puoi essere in grado di ottenere entrambi
IntelliJ è un po ‘confuso riguardo al
aria dice che interferisce ciclicamente
Interferenza interessante forse è così
preciso non so cosa significhi
ma il problema qui è che l’output
di JW f mappare l’output di questo questo
funzione qui
spostiamoli giù così noi
vedere le cose un po ‘meglio immagino
il problema con questo è quello che jwf
mappa emette l’output di quello
la funzione è una promessa di un risultato sì
quindi questa è una promessa di un risultato e così
quindi se faccio questa mappa TW t WF e I in
il corpo di quella funzione ritorno
qualcosa che sta restituendo una promessa
un risultato quindi alla fine lo farò
restituire una promessa di una promessa di a
risultato okay e io non voglio così
quello che voglio invece è che voglio prendere
quella promessa di promessa di risultato e
appiattirli in un solo
promessa di un risultato e quindi di ciò che siamo
non è una mappa ma una mappa piatta
quindi la mappa così piatta è il modo in cui mi manca
paren sì, sto bene quindi la mappa è piatta
modo che facciamo una mappa e un appiattito e
lo facciamo in questo ordine e non lo so
perché l’abbiamo chiamata mappa piatta, immagino
perché Matt non si muove
la lingua quindi la chiamiamo pisolino ma
in realtà è una mappa e poi appiattita
appiattire è solo appiattendo quelli
cose così ora che stiamo tornando
è la promessa di un risultato, così ora noi
avere queste funzioni concatenate e
non importa quale ordine questi in realtà
sono definiti in questo caso perché quando
quando non sto effettivamente facendo la mappa
funzione quando non sto effettivamente chiamando
la funzione mappa è solo la memoria sul
mucchio che tiene il risultato di quella promessa
Quindi io non sono in realtà intenzione di utilizzare un
infila l’ordine non lo fa
importa quindi proviamo e assicuriamoci
Funziona così che dovremmo vedere
cinguettio ci andiamo c’è twitter
com e testo e poi da qualche parte
quaggiù sarà James Ward calmo
quindi ora sono stato in grado di farlo, ma ora
ci sono tre richieste e ovviamente tutto
questi sono lavorati a maglia e non bloccanti
così ad un certo punto nel tempo dove il
la richiesta di twitter è inattiva la richiesta
a James Ward la calma è oziosa
allora non userò nessuno
discussioni giuste per questo, ecco cos’è
dove possiamo ottenere un po ‘di alto valore
con parallelizzazione senza dover
avere questi costosi thread in uso
quindi puoi immaginare un caso d’uso più reale
qualcosa che ho effettivamente fatto è
fare come l’analisi dei sedimenti usando alcune API
su un gruppo di cose contemporaneamente e voglio
essere in grado di fare il maggior numero di quelli come me
può in parallelo quindi il fattore di gating su
quante cose posso fare in parallelo è
saranno quanti fili posso
allocare ma è attivo
connessioni quindi se io se ne ho dieci
thread assegnati che significa che potrei
avere 10 connessioni attive effettive aperte
per alcuni servizi che potrebbero significare
che ne ho in realtà un migliaio
connessioni che sono aperte ma
la maggior parte di loro tutti tranne 10 di loro sono aperti
ma stando semplicemente inattivo aspettando a
risposta va bene così che è reattivo
domande sulla composizione a riguardo
quindi l’ API ws è l’API REST in uscita
Sto solo lavorando con le stringhe ma tu
può sicuramente funzionare con Jason e poi
anche i metodi del controller supportano
Jason così così vedrai una delle cose
che possiamo passare a quello che è il
il codice di stato 200 è un oggetto nodo adiacente
quindi sto passando solo una stringa ma quello
potresti anche trasmettere il contenuto di Jason
sia l’uscita attraverso la libreria ws
e quindi la risposta del controller è entrambe
sostieni anche Jason
attualmente un problema con osservabili e
Sto cercando di pensare se lo farò
ricordati che ce n’erano alcuni
problema con il modo in cui usi osservabili e
futuro insieme credo ma quando noi
parlare di flussi reattivi c’è a
soluzione in arrivo per quel problema e
sarebbe un modo perfettamente accettabile
per farlo con RX java o qualcosa del genere
così così so che è così
flussi reattivi tecnicamente possibili
sarà il modo giusto per fare tutto questo
cosa con RX java ma ma parlerò
su questo in pochi minuti bene
domanda così non ho parlato di qualsiasi
resilienza quindi c’è a
modello di resilienza sulle promesse e c’è
diversi modi con cui puoi gestire
che così una promessa ha davvero tre
afferma che può essere sospeso può avere un
valore o può avere l’aria e poi
puoi impostare la gestione dell’aria attraverso
funzioni come queste sulle promesse quindi
uno dei modi che si possono affrontare
va in onda sulle promesse, si fa un recupero
recuperiamo in realtà possiamo provarlo
veloce quindi se faccio un recupero lo do
cosa una funzione che sta per recuperare
dal fallimento con con un valore
comunque e dovrei avere
qualcosa che ha recuperato con la destra
valore in questo caso una risposta WS non lo farò
in realtà compila il codice così è
solo un modo che potremmo gestire questo
fallimento potremmo anche c’è un on
gestore di aria che potremmo usare e noi
potrebbe registrare l’aria quindi c’è un numero di
modi diversi che vorremmo che noi
farebbe la resilienza sul futuro
dipende da cosa stai cercando e
gli errori in questi futuri stanno andando a
propagare così così se ho per impostazione predefinita se
ho uno stato di errore e uno dei miei
il bambino promette che si propagherà
completamente fuori in modo che potessi prenderlo
il tutto alla fine alla fine o io
potrebbe prenderlo dove è iniziato così
come si gestisce anche quello
va bene così è composizione reattiva con
più cose in parallelo andiamo
torna ad una coppia scorre tutte queste diapositive
sono in linea si blocca jet James Ward calmo
e abbiamo capito che non lo sono
andando a fare la vera demo attuale
ma lascia che ti mostri quello che spinge
come e con il server ha inviato eventi in gioco
noi questo non abbiamo davvero niente
Java 8 Penso che ci sia impiegato 23 a
nuova API Java 8 per eventi inviati dal server
ma gli eventi inviati dal server sono push a senso unico
dal server al client, quindi cosa
fa con gli eventi lato server è unghie
aprire una connessione che è un sink e
non bloccante e poi quando vuoi
puoi chiamare il metodo di invio dei dati a
spingere i dati verso il browser così belli
API semplice sia sul lato server che
dal lato del cliente per farlo così e
quindi anche WebSockets
quindi con una WebSocket ne abbiamo ora due
i canali di entrambi i canali sono reattivi
canali di spinta reattivi in modo tale da provenire
il client al server e l’altro
uno è dal server al client così
posso leggere i valori sul server i
può leggere i valori fuori dal canale
proveniente dal client al server e
quindi posso scrivere valori nel canale
proveniente dal server al client
entrambi sono un lavandino e
non bloccante quindi quando non lo sono
in realtà c’è oltre una connessione ma
quando non sono quando non siamo realmente
mandare qualcosa su quella connessione
allora non ne userà nessuno
filo così semplice implementazione
vedrai che questo è un riferimento al metodo
che sto usando qui in Java 8 così è
solo chiamarlo è come un eco
WebSocket così quando ricevo un messaggio
dal client ho intenzione di girare intorno
e scrivilo al cliente e così via
Faccio solo un metodo per gestire un metodo Java
maneggiate per quello ok quindi passiamo alcuni
minuti parlando di attori reattivi così
gli attori vengono dai giorni di Erlang e
ci sono alcune idee di attori che io
voglio evidenziare e poi mostrerò
qualche codice quindi l’attore
implementazione che sto per essere
usando si chiama acha acha è un attore
implementazione sulla JVM e così via
alcune cose che fa il modello dell’attore
per noi uno è che gestisce il nostro
concorrenza per noi quindi probabilmente hai
metti le chiamate sincronizzate nel tuo codice Java
prima questo è un modo per gestire il tuo
concorrenza è un modo doloroso per
fai che gli attori lo facciano per quello che loro
fai come lo fanno tu
creare un attore e c’è un attore in
il tuo sistema ma per parlarne
attore in realtà non lo usi direttamente
invece quello che fai con un attore sei tu
mandagli un messaggio e quel messaggio vada
in una casella di posta e poi quando possiamo ottenere
un filo saremo noi a consegnare il
messaggio all’attore e poi all’attore
elaborerà il messaggio e una volta è
fatto elaborare il messaggio a cui va
dormire è solo usando la memoria sul calore
allora sarà pronto a riceverne un altro
messaggio ma in attori garantiti solo
processo uno
tempo sagitta quindi ora hai un
alternativa al sincrono
blocchi sincronizzati ora hai
qualcosa che puoi garantire è solo
sta per succedere solo a te
in un momento quindi ti aiuta a gestire
la tua concorrenza in un livello molto più alto
costruire in modo usiamo sempre che l’attore
ref per pochi altri motivi uno dei
le ragioni sono che allora abbiamo la posizione
trasparenza quindi con acha quando invii
un messaggio a quell’attore che rifatta il reale
il vero attore che sarà
gestire un messaggio potrebbe effettivamente essere
da qualche altra parte sul cluster e tu
puoi decidere come vuoi che lo faccia
capita o se vuoi che ciò accada ma
ti permette di avere lo stesso costrutto
per in jbm così come attraverso jbm così tu
può salire e uscire e poi l’altro
motivo per l’attore ref per l’utilizzo di un
il riferimento è questo se per qualche motivo
quell’attore muore o se ne va potrebbe essere
un’eccezione non rilevata o la JVM è andata
giù o qualunque cosa possa essere funzionando
con quell’attore che ref è l’attore ref
sempre bene è sempre buono da ottenere
messaggi nella cassetta postale per quell’attore
quindi ci sarà una coda di messaggi
costruendo e potrebbe essere quello mentre
lavorando attraverso i messaggi su quella stecca
che l’extra si riavvia effettivamente o
si sposta su un server diverso o altro
potrebbe essere e la casella di posta non va
via e i messaggi stanno ancora andando
essere consegnati anche attraverso quei riavvii
dell’attore vero e proprio così ce lo offre
trasparenza o trans capacità di non
doversi preoccupare di cosa sta succedendo
quella effettiva implementazione dell’attore quindi
l’ultima parte sugli attori di cui hai bisogno
so che gli attori sono costruiti sugli alberi
quindi iniziamo con il sistema dell’attore che è
veramente la radice e poi costruiamo a
albero di attori, quindi ciò che significa è
quegli attori hanno figli e attori
genitore è supervisore è la cosa
è responsabile per determinare
cosa succede quando l’attore fallisce e
la strategia di supervisione predefinita è giusta
per riavviare l’ attore ma puoi costruire
la tua supervisione, ma ciò lo consente
di contenere il fallimento nella la
i rami del tuo sistema di attori così
che non si propaghi nel sistema
e abbattere tutto in modo che imparino
le parti importanti degli attori sono le uniche
costruire per agire per comunicare con
attori è di mandargli un messaggio ma
gli attori possono comunicare con l’invio
messaggi ad altre cose, quindi questo è
come gli attori comunicano è sempre attraverso
mandando questi messaggi gli attori possono avere un
durata di entrambi i millisecondi
o dell’intera durata che a
l’applicazione è in esecuzione o una sola
richiesta dell’utente in modo da poterne avere molti
attori che hanno molto molto diversi
diverse durate e un tipico attore
il sistema può avere decine di centinaia di migliaia
anche milioni di attori in un singolo in a
sistema di attore singolo quindi diamo un’occhiata
un po ‘di codice e questa roba sto andando
per copiare e incollare, quindi ho intenzione di passare
la mia piccola app qui da usare
attori invece di usare le promesse
che ho usato in modo ho intenzione di
per prima cosa crea qui una nuova classe Java e
chiameremo questo un attore che lo ha inserito
il pacchetto degli attori ora mi limiterò a incollare
in questo e poi passare qualche minuto
importare cose così è importare
spero di ottenere tutti quelli giusti e
se ti starai chiedendo perché ce ne sono due
diverse due diverse API se lo hai
notato che in queste importazioni vedono lì
viene riprodotto su un punto pi e su un punto non API
la convenzione di denominazione più strana che sia mai stata
In realtà i giochi francesi sono creati dal francese
ragazzi e quindi API in realtà è la Scala
API la non API è la API Java
tutti dovrebbero averlo saputo
è ovvio quindi sì, così andiamo così
devi assicurarti di ottenere il per
usando Java assicurati di avere ragione
nan api api lì ok, va bene così
allora ho intenzione di cambiare il mio
controller in modo da avere il mio attore lo farò
mostra il codice per questo in un secondo
torniamo qui e cambiamo
quello è un attore che pochi altri lo importano
uno e vediamo puntelli questo potrebbe essere
come un gioco che suoniamo e WS reattivo
ok oh foo attore uno di più va bene così andiamo
per prima cosa guarda il nostro attore qui, quindi cosa?
Ho fatto è che ho creato un nuovo non tipizzato
attore e attore il principale punto di ingresso in
questo attore è il metodo on receive
c’è una nuova API Java 8 e akka per
questo e io non sto usando il nuovo Java 8
API ma è molto più lambda e per
facendo questo genere di cose così questo è
solo l’API Java standard così ho
ottenuto questo in ricezione e ci vuole un
messaggio non tipizzato così ogni volta che tu
comunicare con gli attori è sempre un
messaggio non tipizzato e quindi puoi farlo
corrispondenza del modello o qualcosa del genere
oggetto di capire cosa fare e così
in questo caso lo sto solo facendo
chiedere di riprendere la mia promessa ma poi
Devo fare qualcosa di speciale quindi ora
Sto facendo qualcosa di affondante e non blocco
dentro e ho bisogno di vincere quella cosa
completa a cui voglio indirizzare un messaggio
la persona che mi ha inviato questo dall’altro
lato di quella chiamata giusta così così sto andando
per attraversare questo confine asincrono e voglio
per preservare il mittente della persona
chi mi ha mandato questo e volevo non capirlo
che si è mescolato in un programma concorrente
e quindi uso questo modello stop pipe in
per gestire quello che non ha un sacco di
tempo di andare in quello che è in realtà
facendo ma fidati di me se lo fai
tutto ciò che un lavandino e un attore usano
pattern pipe ok così ora nel nostro
controller qui è dove siamo effettivamente
creando l’attore quindi vado al
sistema dell’attore e sto dicendo creare per
io un attore del tipo foo attore e così
questo si spegne e dice al sistema dell’attore
per creare un’istanza di quell’attore ma
vedrai quello che torno non è il
istanza attore ma un attore respira il
riferimento a quella cosa e ora sono
intenzione di usare quell’attore
per comunicare con esso così che cosa sto facendo
è qui è il mio mio foo attore che sto facendo un
chiedi e il modo predefinito in cui l’ho detto
l’unico modo per comunicare
con un attore è di mandargli un messaggio
c’è quello è vero ma c’è un API
tipo di zucchero sintattico in cima a quello
chiamato e chiesto e chiede invia un
messaggio ma poi mi dà una promessa di a
risposta indietro esso fondamentalmente imposta
internamente una promessa che sarà
soddisfatta quando quell’attore risponde a me
con qualcos’altro così gli attori non lo fanno
deve essere richiesta la risposta, ma per alcuni
motivo amo le cose con richieste di risposta così
e poi quando lo fai ti chiedo sempre
Devo specificare un time out quindi sono
specificando un intervallo di cinque secondi okay
quindi quello che torno è una promessa
oggetto da quello perché questi messaggi
tra gli attori sono oggetti e poi
quello che sto per fare è fare una mappa
quella promessa e poi ho intenzione di lanciare
questa cosa a una risposta WS e poi
restituiscilo, così ora è il mio attore
implementazione basata andiamo ad aggiornarlo
e quello che dovremmo vedere adatto a tutte le compilazioni
c’è James Ward calmo, quindi non c’è
James Ward calmo ora attraversando il
attore quindi ci sono alcuni vantaggi per il
modello di attore possiamo possiamo usare entrambi
entrambi i modelli ci sono sicuramente casi d’uso
per entrambi uno dei grandi casi d’uso per
attori che non ho menzionato è quando
abbiamo uno stato mutabile quindi gli attori sono a
ottimo posto per mettere gli Stati mutabili che sei
sarà garantito che solo uno
i thread stanno per mutare quello stato
in un momento così così gli attori sono grandi per
gestiscono anche lo stato mutevole
ottimo per gestire cose come i tentativi
quindi quello che possiamo fare è avere un
attore che si comporta come questo
tipo di manager per tentativi e per
assicurandoci di ottenere una risposta a
un esempio molto semplice di questo è che è molto
comune che avrò nei miei sistemi e
attore che sta per ottenere alcuni dati ma
Ho sia il database che io ho un
sistema di cassa per ottenere dati da o voglio
per ottenerlo idealmente voglio ottenerlo
dai contanti ma se ricevo un errore di cache
e
voglio andare nel database giusto e così
quindi se ho un attore faccio una richiesta
per l’attore e dire hey ho bisogno di questo
i dati posso effettivamente utilizzare un router in acha
per dire ora inviare una richiesta a entrambi
attore di cassa e attore di database e
c’è un router chiamato è come
scatter raccogliere prima completo è il
router in modo che sparga i messaggi
li invia ad entrambi i miei attori bambini
e poi il primo che mi dà un
la risposta è quella che io in realtà
finiscono usando il valore che io
effettivamente utilizzare in modo da poter utilizzare qualcosa
così o ci sono altri router in
acha anche per creare un tipo di riprova di
i tentativi di sistema probabilmente hanno qualche stato
coinvolto come numero di tentativi quanti
volte ho provato questo genere di cose così
un attore diventa un buon modo per dirlo
informazioni sullo stato e fare i tentativi
sì sì, potresti sicuramente crearne uno
router acha che avrebbe esattamente
quel comportamento ce ne sono alcuni
router pronti all’uso e quindi è possibile
scrivi anche i tuoi router personalizzati
forse qualcuno che ne ha già scritto uno
quello che lo fa specificamente ma
okay , questa è una vera e rapida introduzione
attori che voglio andare avanti così posso
parlare di flussi reattivi molto velocemente
e poi avremo qualche minuto
per domande così reattive flussi cosa
è un nuovo progetto in tutto
collaborazione tra typesafe Netflix
Twitter e un sacco di altre persone a
creare fondamentalmente uno standard JVM per
facendo un sink e reattivo non bloccante
flussi con contropressione e così là
sarà un numero di ciò che il
il progetto di flussi ripidi reattivi è a
implementazione di riferimento una specifica
un TCK quindi tutte le cose che qualcuno
potrebbe creare un’implementazione di
flussi reattivi in cima così la RX
i ragazzi di java stanno lavorando a un reattivo
implementazione dei flussi su RX java
c’è ovviamente un’implementazione di naka
e penso ci sia un film e un film
è schizzinoso, no, mi dispiace c’è un vortice
il vertice ha ottenuto un terzo vertice
implementazione di flussi reattivi come
bene
quindi questo è un nuovo progetto davvero eccitante
per essere in grado di fare un lavandino e
flussi non bloccanti di dati con retro
pressione così reale esempio veloce di ritorno
la pressione è se ho un caricamento in arrivo
da un client a un server e quindi lo sono
prendendo quei morsi e spingendoli
ad amare Amazon s3 o qualche altro servizio
Io davvero non voglio che il cliente invii
più morsi di quelli che posso inviare a quello successivo
servizio perché poi mi costruirò
Buffers giganti e ed esaurendo
memoria e quindi voglio essere in grado di mettere
contropressione sul produttore da dire
smettere di produrre così tanti dati o rallentare
ma voglio essere in grado di farlo in un
modo reattivo tradizionalmente contropressione
è stato fatto nella maggior parte delle implementazioni in
un modo molto sincrono in un molto
modo di blocco e flussi così reattivi è
riguardo alla possibilità di farlo in un non
bloccando il modo in cui controllarlo reattivo
desk flussi org per ulteriori informazioni
c’è già implementazioni c’è
nell’attivatore typesafe c’è già
alcune applicazioni di esempio per farti
iniziato con flussi reattivi quindi controlla
questo è abbastanza nuovo e
eccitante ok così il tempo per le domande noi
avere un paio di minuti in più in questo
caso voglio essere in grado di chiamare il mio
funzione quando ho ricevuto la risposta
e questo è tutto un sink e non-blocking
per entrambi così così quando vincono il
la risposta ritorna dal servizio
mi siedo sul mucchio finché non lo faccio davvero
finché non ne ho davvero bisogno e così è così
in realtà non si utilizza una discussione no no
non sei tu quando è quando è solo
stare inattivo è quando non sono attivamente
trasferendo punture sul filo è
non usando le risorse di rete non lo è
usando un thread è solo usando la memoria
il caldo così era quello che era il
l’intero obiettivo era quello di ottenere una sincronizzazione
non bloccando completamente
tutta la catena e non stare mai bloccando
risorse che non vengono mai utilizzate
ecco perché ho dovuto nidificare quelli lì
c’è un altro modo per farlo
non ha mostrato e se ho un sacco di
è tecnicamente la stessa cosa, ma se io
avere un sacco di ballo di fine anno
questo è quello che voglio tipo di aggregato
insieme c’è qualcosa chiamato
promettere la sequenza o il futuro di quella sequenza
e questo prende una lista di promesse e
quindi mi consente di avere una funzione mappa
su tutti quelli che poi ottengo
indietro un elenco di tutte le mie risposte o
tutti gli oggetti che torno così tanto
quello sarebbe un altro modo per farlo
c’è anche una zip e un numero di altro
modi ma ma in ogni caso si guarda così a lungo
come ti attacchi con le funzioni della mappa e
e un sink e costrutti non bloccanti
allora sarai sincronizzato non bloccante
tutta la strada in tutta non ci sarà mai
essere un momento in cui blocchi le risorse
inutilmente quindi per promesse di default
in realtà non hanno un concetto di a
il timeout in essi riproduce il client del servizio web
la biblioteca fa e poi c’è anche tu
puoi creare la nostra promessa?
avere un timeout se lo hai appena trovato
stack overflow ma ma così si crea a
prometto che ha un timeout e
allora quello sarebbe fallito e poi lo faresti
fare un recupero con quello da affrontare
con l’errore con il timeout
fallimento posso mostrarvi esempi di codice di
che se vuoi dopo tutto okay
bene, grazie per essere venuto, lo spero
è stato utile sarò in giro se lo hai
altre domande grazie
tu
Please follow and like us: