Questa domanda riguarda le migliori pratiche in architettura.
La nostra architettura attuale
Ho una classe PHP che accede a MySQL per le informazioni dell'utente. Chiamiamolo User
. User
è accessibile molte volte, quindi abbiamo implementato livelli di memorizzazione nella cache per ridurre il carico.
Il primo livello è ciò che chiamiamo la cache "per richiesta". Dopo che i dati sono stati recuperati da MySQL, archiviamo i dati in una proprietà privata di User
. Qualsiasi richiesta successiva per i dati restituisce la proprietà invece di richiedere nuovamente i dati da MySQL.
Poiché la richiesta Web è valida e muore in base alle richieste, questa cache impedisce all'applicazione di accedere a MySQL più di una volta in una singola richiesta.
Il nostro secondo livello è Memcached. Quando la proprietà privata è vuota, per prima cosa controlliamo Memcached per i dati. Se Memcached è vuoto, interrogiamo MySQL per i dati, aggiorna Memcached e aggiorniamo la proprietà privata di User
.
La domanda
La nostra applicazione è un gioco, ea volte è imperativo che alcuni dati siano il più aggiornati possibile. Nell'intervallo di circa cinque minuti, una richiesta di lettura dei dati dell'utente potrebbe verificarsi 10 o 11 volte; quindi potrebbe verificarsi un aggiornamento. Le richieste di lettura successive devono essere aggiornate o i meccanismi di gioco non riescono.
Quindi, quello che abbiamo fatto è implementare un pezzo di codice che viene eseguito quando si verifica un aggiornamento del database. Questo codice imposta la chiave in Memcached con i dati aggiornati, quindi tutte le richieste successive a Memcached sono aggiornate.
È ottimale? Ci sono problemi di prestazioni o altri "trucchi" di cui dovremmo essere a conoscenza quando proviamo a mantenere una sorta di "cache vivente" come questa?