NCache, una cache distribuita in memoria, mantiene intatti i tuoi dati in uno spazio di archiviazione temporaneo per un'esperienza più rapida delle operazioni di lettura e scrittura. Abbiamo visto NCache fare miracoli con la velocità quando si tratta di esibirsi operazioni sul cache store. Tuttavia, mantenendo NCache sincronizzato con l'origine dati principale è una sfida importante quando si tratta di coerenza dei dati. L'origine dati può essere qualsiasi database; tuttavia, questo blog tratta di mantenere la tua cache sincronizzata con PostgreSQL.
Due copie di dati separate: una sfida
Lo stack della tua applicazione funziona con NCache come la cache risiede come un livello di memorizzazione nella cache tra il database e l'applicazione. La tua applicazione è collegata direttamente alla cache, inviando così tutte le chiamate operative direttamente alla cache come lettura o scrittura. Supponiamo che un altro utente modifichi qualcosa nel database senza che la cache lo sappia. Ora i dati nel database sono diversi dai dati che risiedono nella cache. Le due copie separate dei dati determinano un'incoerenza dei dati, che è una grande sfida.
NCache Dettagli NCache Docs Sincronizza la cache con PostgreSQL
NCache Mantenere i dati sincronizzati
Data la sfida dell'incoerenza dei dati, NCache si precipita con una soluzione per questo, proprio come tutto il resto. Quello che devi fare è sincronizzare la tua cache con il database usando NCache sincronizzazione del database tecniche. Il database discusso in questo blog, come accennato in precedenza, è PostgreSQL, un database relazionale a oggetti open source con un set di funzionalità ben sviluppato e prestazioni e affidabilità elevate. Abbiamo una soluzione realizzata e caricata su GitHub su Sincronizzazione della cache con PostgreSQL che mostra come la tua cache può migliorare la scalabilità e la coerenza dei dati.
Il diagramma seguente mostra come funziona NCache aiutarti a mantenere i dati sincronizzati con il tuo database PostgreSQL.
Sincronizzazione NCache con il database PostgreSQL
NCache ti consente di mantenere i tuoi dati sincronizzati con PostgreSQL utilizzando NotificaExtensibleDependency, che è una tecnica di sincronizzazione fornita da NCache per mantenere la cache e il database sincronizzati. NotifyExtensibleDependency viene utilizzato per implementare la tecnica di invalidamento dei dati utilizzando il sistema di notifica delle dipendenze PostgreSQL. La dipendenza di PostgreSQL è basata sul meccanismo LISTEN/NOTIFY che è simile a Modello Pub/Sub.
Insieme alla dipendenza dal database, Leggi ThruProvider viene utilizzato per comunicare direttamente con l'origine dati. NCache chiama il provider per caricare i dati dall'origine dati direttamente usando la tua logica personalizzata. Ciò mantiene i dati sincronizzati e aggiornati per evitare problemi come dati obsoleti, oltre a fornire una migliore scalabilità e operazioni di lettura più rapide.
Quindi, i componenti di base coinvolti sono:
-
- NotificaExtensibleDependency: NCache si registra con un canale specifico chiamando LISTEN in NotifyExtensibleDependency
Initialize
metodo. Sul database viene invocata una funzione TRIGGER che invia un Payload al canale e all'ascolto, in caso di incongruenza dei dati, i dati vengono rimossi dalla cache. - ReadThruProvider: questo provider ottiene i dati aggiornati automaticamente, direttamente dal database in caso di modifica dei dati nel database.
- NotificaExtensibleDependency: NCache si registra con un canale specifico chiamando LISTEN in NotifyExtensibleDependency
NCache Dettagli Leggi tutto Dipendenza basata sulle notifiche
Sincronizza la cache usando NotifyExtensibleDependency
NotificaExtensibleDependency viene utilizzato per invalidare i dati utilizzando il meccanismo di PostgreSQL Dependency, che funziona sul modello di Messaggistica Pub/Sub e il modello si chiama Ascolta/Notifica. Secondo questo meccanismo, qualsiasi aggiornamento nel database viene passato al client in ascolto su un canale specifico tramite un comando NOTIFY con un payload aggiuntivo contenente le informazioni. Il cliente nel nostro caso specifico lo è NCache e alla notifica di qualsiasi modifica nel database, l'elemento corrispondente viene rimosso dalla cache.
Diamo un'occhiata al codice seguente per vedere come viene aggiunto un elemento con la dipendenza da PostgreSQL:
1 2 3 4 5 6 7 8 9 10 11 |
const string connectionString = "your-connection-string"; var customer = new Customer(); var cacheItem = new CacheItem(customer) { Dependency = new PostGreSQLDependency(connectionString, customer.customerid, "public", "customers", "customer_channel") }; var key = customer.customerid; var cache = CacheManager.GetCache("democache"); cache.Insert(key, cacheItem); |
Tuttavia, è necessario comprendere l'implementazione di PostgreSQLDependency
e il codice qui sotto aiuterà. Il Initialize
contiene una stringa di connessione per connettersi al database e si registra per la notifica su qualsiasi modifica dei dati nei dati specifici.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 |
public PostGreSQLDependency(string connectionString, string dependencyKey, string schema, string table, string channel) { _connectionString = connectionString.Trim(); _dependencyKey = dependencyKey.Trim(); _schema = schema.Trim(); _table = table.Trim(); _channel = channel.Trim(); } public override bool Initialize() { connection = new NpgsqlConnection(_connectionString); connection.Open(); ((NpgsqlConnection)connection).Notification += (o, e) => { var entity = JsonConvert.DeserializeObject(e.AdditionalInformation); if (entity.DependencyKey == _dependencyKey && entity.Table == _table && entity.Schema == _schema) { done = true; } }; using (var cmd = new NpgsqlCommand($"LISTEN {_channel};", (NpgsqlConnection)connection)) { cmd.ExecuteNonQuery(); } task = Task.Run(() => { while (true) { ((NpgsqlConnection)connection).Wait(); if (done) { break; } } this.DependencyChanged.Invoke(this); }); return true; } |
NCache Dettagli NCache Docs Sincronizza la cache con PostgreSQL
Ricaricare automaticamente i dati utilizzando la funzione Read-Through
Utilizzando la dipendenza, ogni volta che i dati vengono modificati nell'origine dati, vengono cancellati dalla cache. Tuttavia, abbiamo ancora bisogno di ricaricare anche quei dati nella cache e per quello NCache ha una funzione chiamata Fonte di supporto. Forniamo al provider Read-Through la libertà di aggiungere la tua logica personalizzata nell'implementazione. Nel caso specificato, il provider Read-Through carica i dati dal database PostgreSQL. Devi configurare il provider Read-Through utilizzando prima gli strumenti di gestione.
L'utilizzo delle opzioni di risincronizzazione nel provider di read-through mantiene i dati sincronizzati con il database. Tuttavia, all'interno del ProviderCacheItem
, CacheItem ha una dipendenza aggiunta con esso, il che significa che il nuovo elemento aggiunto nella cache viene fornito con una dipendenza già aggiunta ad esso. Ti risparmia lo sforzo di aggiungere dipendenza più e più volte. Guarda al LoadFromSource
metodo all'interno del provider Read-Through per esaminare l'implementazione:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
public ProviderCacheItem LoadFromSource(string key) { var query = $"SELECT customerid, address, country, city FROM customers WHERE customerid = '{key}'"; // Define a query returning a single row result set NpgsqlCommand command = new NpgsqlCommand(query, _connection as NpgsqlConnection); var reader = command.ExecuteReader(); ProviderCacheItem providerCacheItem = null; while (reader.Read()) { if (providerCacheItem == null) { var customer = new Customer() { customerid = reader[0] as string, address = reader[1] as string, country = reader[2] as string, city = reader[3] as string, }; providerCacheItem = new ProviderCacheItem(customer) { Dependency = new PostGreSQLDependency(_connectionString, customer.customerid, "public", "customers", "customer_channel"), ResyncOptions = new ResyncOptions(true) }; } } } |
Aggiungendo ora l'elemento con read-through, carica semplicemente gli elementi modificati direttamente nella cache utilizzando dipendenza dal database. Quindi la tua cache rimane sincronizzata con il database PostgreSQL e tutti i tuoi problemi con i dati non aggiornati scompaiono.
Conclusione
Per mettere tutto nel blog in termini semplici, la cache e il database devono rimanere sincronizzati tra loro. Se la cache non è a conoscenza di eventuali modifiche apportate al database, l'applicazione può continuare a funzionare e a lavorare con i dati della cache non aggiornati. Questo problema viene risolto in modo molto efficiente con NCache Funzionalità di dipendenza da PostgreSQL. Ci sono un sacco di altre fantastiche funzionalità che puoi vedere semplicemente andando NCache sito web.
NCache Dettagli Confronto edizione NCache Scaricare