NCache, un cache distribué en mémoire, conserve vos données intactes dans un stockage temporaire pour une expérience plus rapide des opérations de lecture et d'écriture. Nous avons vu NCache faire des merveilles avec la vitesse quand il s'agit d'effectuer opérations sur le magasin de cache. Cependant, en gardant NCache synchronisée avec la source de données principale est un défi majeur en matière de cohérence des données. La source de données peut être n'importe quelle base de données ; cependant, ce blog concerne la synchronisation de votre cache avec PostgreSQL.
Deux copies de données distinctes – un défi
La pile de votre application fonctionne avec NCache comme le cache réside en tant que couche de mise en cache entre la base de données et l'application. Votre application est directement connectée au cache, envoyant ainsi tous les appels d'opération directement au cache tels que la lecture ou l'écriture. Supposons qu'un autre utilisateur modifie quelque chose dans la base de données sans en informer le cache. Désormais, les données de la base de données sont différentes des données résidant dans le cache. Les deux copies séparées des données entraînent une incohérence des données, ce qui est un grand défi.
NCache Détails NCache Docs Synchroniser le cache avec PostgreSQL
NCache Synchronisation des données
Compte tenu du problème d'incohérence des données, NCache se précipite avec un correctif pour cela comme tout le reste. Ce que vous devez faire est de synchroniser votre cache avec la base de données en utilisant NCache synchronisation de la base de données techniques. La base de données discutée dans ce blog, comme mentionné précédemment, est PostgreSQL - une base de données relationnelle objet open source avec un ensemble de fonctionnalités bien développé et des performances et une fiabilité élevées. Nous avons une solution créée et téléchargée sur GitHub sur Synchronisation du cache avec PostgreSQL qui montre comment votre cache peut améliorer l'évolutivité et la cohérence des données.
Le schéma ci-dessous montre comment fonctionne NCache vous aider à garder les données synchronisées avec votre base de données PostgreSQL.
Synchronisation NCache avec la base de données PostgreSQL
NCache vous permet de garder vos données synchronisées avec PostgreSQL en utilisant NotifyExtensibleDependency, c'est une technique de synchronisation fournie par NCache pour garder le cache et la base de données synchronisés. NotifyExtensibleDependency est utilisé pour implémenter la technique d'invalidation des données à l'aide du système de notification de dépendance PostgreSQL. La dépendance PostgreSQL est construite sur le mécanisme LISTEN/NOTIFY qui est similaire au Modèle pub/sous.
En plus de la dépendance à la base de données, Fournisseur ReadThru est utilisé pour communiquer directement avec la source de données. NCache appelle le fournisseur pour charger les données de la source de données directement à l'aide de votre logique personnalisée. Cela permet de maintenir les données synchronisées et actualisées pour éviter des problèmes tels que les données obsolètes, tout en offrant une évolutivité améliorée et des opérations de lecture plus rapides.
Ainsi, les composants de base impliqués sont:
-
- NotifyExtensibleDependency : NCache s'enregistre auprès d'un canal spécifique en appelant LISTEN dans NotifyExtensibleDependency
Initialize
méthode. Sur la base de données, une fonction TRIGGER est invoquée qui envoie une charge utile au canal et lors de l'écoute, en cas d'incohérence des données, les données sont supprimées du cache. - ReadThruProvider : ce fournisseur obtient automatiquement les données mises à jour, directement à partir de la base de données lors de la modification des données dans la base de données.
- NotifyExtensibleDependency : NCache s'enregistre auprès d'un canal spécifique en appelant LISTEN dans NotifyExtensibleDependency
NCache Détails Lire à travers Dépendance basée sur les notifications
Synchroniser le cache à l'aide de NotifyExtensibleDependency
NotifyExtensibleDependency est utilisé pour invalider les données en utilisant le mécanisme de PostgreSQL Dependency, qui fonctionne sur le modèle de Messagerie Pub/Sub et le modèle s'appelle Écouter/Notifier. Selon ce mécanisme, toute mise à jour dans la base de données est transmise au client écoutant sur un canal spécifique via une commande NOTIFY avec une charge utile supplémentaire contenant les informations. Le client dans notre cas spécifique est NCache et sur notification de tout changement dans la base de données, l'élément correspondant est supprimé du cache.
Regardons le code ci-dessous pour voir comment un élément est ajouté avec la dépendance 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); |
Cependant, vous devez comprendre la mise en œuvre de PostgreSQLDependency
et le code ci-dessous vous aidera. Le Initialize
contient une chaîne de connexion pour se connecter à la base de données et s'enregistre pour notification lors de toute modification de données dans les données spécifiques.
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 Détails NCache Docs Synchroniser le cache avec PostgreSQL
Rechargement automatique des données à l'aide de la lecture
En utilisant la dépendance, chaque fois que les données sont modifiées dans la source de données, elles sont effacées du cache. Cependant, nous devons également recharger ces données dans le cache et pour cela NCache a une fonctionnalité appelée Source de sauvegarde. Nous offrons au fournisseur Read-Through la liberté d'ajouter votre logique personnalisée dans l'implémentation. Dans le cas spécifié, le fournisseur Read-Through charge les données de la base de données PostgreSQL. Vous devez configurer le fournisseur de lecture directe utiliser les outils de gestion auparavant.
L'utilisation des options de resynchronisation dans le fournisseur de lecture continue permet de synchroniser les données avec la base de données. Cependant, à l'intérieur du ProviderCacheItem
, le CacheItem a une dépendance ajoutée avec lui, ce qui signifie que le nouvel élément ajouté dans le cache est livré avec une dépendance déjà ajoutée. Cela vous évite d'avoir à ajouter des dépendances encore et encore. Regarde le LoadFromSource
méthode à l'intérieur du fournisseur Read-Through pour examiner l'implémentation :
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) }; } } } |
L'ajout de l'élément avec lecture immédiate charge simplement les éléments modifiés directement dans le cache à l'aide de dépendance de la base de données. Par conséquent, votre cache reste synchronisé avec la base de données PostgreSQL et tous vos problèmes de données obsolètes disparaissent.
Conclusion
Pour tout mettre dans le blog en termes simples, votre cache et votre base de données doivent rester synchronisés les uns avec les autres. Si le cache n'est pas au courant des modifications apportées à la base de données, votre application peut continuer à fonctionner et à travailler avec des données de cache obsolètes. Ce problème est résolu très efficacement avec NCache Fonctionnalité de dépendance PostgreSQL. Il y a des tonnes d'autres fonctionnalités intéressantes que vous pouvez voir en allant simplement sur NCache site de NDN Collective.
NCache Détails Comparaison Des Éditions NCache Télécharger