Canali cache

Un canale cache memorizza l'ultimo evento e lo ripropone a ogni nuovo iscritto. Un client che si connette dopo un aggiornamento può visualizzare lo stato corrente senza attendere una nuova pubblicazione.

Usa i canali cache per valori correnti come il punteggio di una partita, lo stato di un dispositivo, l'avanzamento di una build o lo stato di un ordine. La sottoscrizione fornisce lo stato iniziale e gli aggiornamenti successivi.

Dare un nome a un canale cache

Il nome del canale abilita il caching. Inserisci cache- all'inizio del nome o subito dopo il prefisso del tipo di canale.

Nome	Cache	Sottoscrizione
cache-orders	sì	chiunque possieda la app key
private-cache-orders	sì	il tuo backend firma per il client
presence-cache-lobby	sì	il tuo backend firma, membri tracciati
orders-cache	no	chiunque possieda la app key

orders-cache non è un canale cache. Il prefisso cache- deve precedere il nome dopo qualsiasi prefisso private- o presence-.

Tutto il resto del canale rimane invariato. Un canale private-cache- si autorizza esattamente come un canale privato, e un canale presence-cache- continua a tracciare i membri e a generare eventi di presenza come qualsiasi altro canale presence.

Sottoscrizione

const bird = new BirdRealtime({ appKey: "your-app-key", region: "us1" });

const match = bird.subscribe("cache-match-42");

match.bind("score-updated", (data) => {
  render(data);
});

match.bind("bird:cache_miss", () => {
  console.log("nothing cached for this channel yet");
});

let bird = BirdRealtime(options: .init(appKey: "your-app-key", region: "us1"))

let match = bird.subscribe("cache-match-42")

match.bind("score-updated") { data in
    render(data)
}

match.bind("bird:cache_miss") { _ in
    print("nothing cached for this channel yet")
}

val bird = BirdRealtime(BirdRealtimeOptions(appKey = "your-app-key", region = "us1"))

val match = bird.subscribe("cache-match-42")

match.bind("score-updated") { data ->
    render(data)
}

match.bind("bird:cache_miss") {
    println("nothing cached for this channel yet")
}

In caso di hit, l'evento in cache arriva dopo che la sottoscrizione è riuscita. Porta il nome e il payload dell'evento originale, quindi lo stesso handler elabora sia gli eventi in cache sia quelli live.

In caso di miss, il client riceve bird:cache_miss su quel canale. Il canale non ha mai ricevuto una pubblicazione oppure il suo evento in cache è scaduto.

Popolare la cache in caso di miss

Se un endpoint sottoscrive realtime.cache_channels, il miss raggiunge anche il tuo server. Gestisci il webhook leggendo lo stato corrente e pubblicandolo sul canale.

await bird.realtime.publish(appId, {
  event: "score-updated",
  channels: ["cache-match-42"],
  data: await currentScore(42),
});

client.realtime.publish(
    app_id,
    event="score-updated",
    channels=["cache-match-42"],
    data=current_score(42),
)

_, err := client.Realtime.Publish(context.Background(), appID, bird.RealtimePublishParams{
	Event:    "score-updated",
	Channels: []string{"cache-match-42"},
	Data:     currentScore(42),
})

$bird->realtime->publish($appId, (new RealtimePublish())
    ->setEvent('score-updated')
    ->setChannels(['cache-match-42'])
    ->setData(currentScore(42)));

Il client che ha causato il miss è sottoscritto prima che il tuo server pubblichi l'evento sostitutivo, quindi riceve il nuovo stato. Questo flusso popola anche una cache vuota per il primo iscritto.

Contenuti della cache e conservazione

Gli eventi pubblicati tramite API vengono memorizzati in cache, comprese le pubblicazioni singole e in batch. Gli eventi client i cui nomi iniziano con client- non vengono memorizzati in cache.

Gli eventi in cache possono restare disponibili fino a 30 minuti, ma possono scadere prima. Ripopola i canali aggiornati di rado dal webhook di cache-miss invece di dare per scontato che la cache sia ancora attiva.

Ogni canale memorizza solo l'evento più recente. Se pubblichi score-updated e poi match-ended, un nuovo iscritto riceve solo match-ended. Usa un solo nome evento per canale cache, oppure includi lo stato completo in ogni payload.

Limitazioni della cache

Un canale cache conserva solo l'evento più recente. Non mantiene uno storico degli eventi. Un client che perde due aggiornamenti mentre è offline riceve lo stato più recente senza l'evento intermedio. Conserva lo stato persistente nel tuo database. Dopo la riconnessione, il client si ri-sottoscrive e visualizza l'evento in cache se ancora disponibile. Consulta Pubblicazione degli eventi per le garanzie di consegna.

Prossimi passi

Pubblicazione degli eventi tratta la pubblicazione dal tuo server, il batching e il broadcasting.
Canali privati e Canali presence si combinano con cache- nello stesso nome.
Interrogazione dello stato del canale legge occupancy e conteggi dal tuo server.

Risorse correlate

Prosegui con la documentazione, le guide e gli esempi per questo argomento. Le risorse sono in inglese.

Esplora la funzionalitàRealtime Segui il percorso di apprendimentoBuild your first integration Guida all'implementazioneSend your first realtime event

Prova l'esercitazione e ottieni un brief di implementazione