Pour les applications à transactions élevées avec des architectures complexes, l'échange continu de données entraîne une charge non uniforme et un retard de débit. L'affinement des données est un défi de taille lorsqu'il s'agit d'applications métier volumineuses et complexes. Pour répondre à cela, le traitement de flux est utilisé pour définir un flux de données particulier en créant des flux de données. Une application de flux typique se compose de plusieurs producteurs générant de nouveaux événements et d'un ensemble de consommateurs traitant ces événements.
L'une de ces applications populaires est Pub/Sub, où les éditeurs saisissent des messages et les abonnés reçoivent les messages auxquels ils sont abonnés. Cependant, dans le traitement de flux, Pub/Sub est confronté à quelques limitations, comme une fois que l'abonné reçoit le message, l'application ne conserve plus le message. Ainsi plus tard, si un autre abonné veut les messages de l'éditeur, les messages précédents n'existent pas. De plus, pour les flux de données entrants, le filtrage des données a lieu côté client (abonné) et non côté serveur, ce qui rend l'architecture de l'application complexe.
Pour surmonter ces limitations de Pub/Sub, NCache est livré avec un mécanisme efficace de traitement des données côté serveur à l'aide de requêtes continues. Les requêtes continues permettent aux applications d'être notifiées de tous les changements survenant dans les données résidant dans le cache, répondant à certains critères. Ce blog vous aide à comprendre les avantages de l'utilisation des requêtes continues dans le traitement de flux à l'aide d'une solution créée pour le traitement de flux sur GitHub.
Utilisation de la requête continue pour le traitement de flux
La solution explique une application e-commerce, qui traite chaque jour des milliers de clients pour leurs achats en ligne. Si vous regardez le diagramme ci-dessous, les clients de toutes sortes et catégories sont ajoutés dans l'application. Pour rendre le traitement des clients efficace, les clients non filtrés sont catégorisés et filtrés en clients « Gold », « Silver » et « Bronze » en fonction du nombre de leurs commandes, à l'aide de requêtes continues.
Requête continue permet aux applications de recevoir des notifications lorsqu'une donnée répondant à certains critères change dans le cache et que les critères sont spécifiés à l'aide de commandes SQL. Par exemple, si une application souhaite marquer les clients avec le plus grand nombre de commandes en tant que "Clients Or", tout ce qu'elle a à faire est d'enregistrer un critère de commande SQL, fournissant ainsi un rappel. Ce rappel est déclenché lors de tout changement se produisant dans le jeu de résultats remplissant les critères. Une fois le rappel invoqué, l'application peut catégoriser ces clients comme "Clients Gold" à l'aide de balises.
De même, l'application peut créer plusieurs catégories en enregistrant plusieurs CQ, chacun avec ses propres critères et un rappel. De cette façon, l'application n'obtient que les données filtrées qui l'intéressent. Les données filtrées peuvent ensuite être analysées en fonction des besoins de l'entreprise, telles que l'offre de remises aux clients haut de gamme en fonction de la catégorie du client.
Des événements sont déclenchés si l'une des actions de modification de données suivantes a lieu dans le cache :
- Ajouter : Ajout d'un nouvel élément au cache qui remplit les critères de requête
- Mettre à jour: Mise à jour d'un élément existant dans le jeu de résultats de la requête.
- Retirer: Suppression d'un élément du cache ou mise à jour de tout élément existant mis en cache de sorte qu'il entraîne la suppression d'un élément du jeu de résultats de la requête.
Passons en revue un exemple de code rapide d'utilisation du traitement de flux dans le cache avec une requête continue. Dans cet exemple, une requête continue est exécutée sur les données où les commandes supérieures à 10 sont ajoutées à la catégorie "Gold Customers". De plus, un événement est déclenché sur chaque élément ajouté au jeu de résultats de la requête.
1 2 3 4 5 6 7 8 9 10 11 |
string query = SELECT $VALUE$ FROM Models.Customer WHERE OrdersCount >= ?; var queryCommand = new QueryCommand (query); queryCommand.Parameters.Add("OrdersCount", 10); var contQuery = new ContinuousQuery (queryCommand); // EventDataFilter.None returns the cache keys added cQuery.RegisterNotification (new QueryDataNotificationCallback (QueryItemCallBackForGoldCustomers), EventType.ItemAdded, EventDataFilter.None); cache.MessagingService.RegisterCQ(contQuery); // Register callback for event notifications in the result set |
NCache Détails Requête continue et Pub/Sub
La requête continue conserve les données que Pub/Sub ne conserve pas
Désormais, les données filtrées via une requête continue (pour les clients avec des commandes> 10) sont étiquetées comme "Clients Gold" et sont mises à jour dans le cache. Regardez le code ci-dessous pour voir comment c'est fait.
1 2 3 4 5 6 7 8 9 10 |
// A callback for previously executed query private void QueryItemCallBackForGoldCustomers (string key, CQEventArg arg) { var cacheItem = _cache.GetCacheItem(key); cacheItem.Expiration = new Expiration(ExpirationType.None); Tag[] tags = new Tag[1]; tags[0] = new Tag("GoldCustomers"); cacheItem.Tags = tags; cache.Insert(key, cacheItem); } |
La requête continue conserve les données conservées dans le cache même après le traitement. De cette façon, il résout le problème rencontré avec Pub/Sub pour les données émergentes en permanence, c'est-à-dire plusieurs applications publiant les données dans NCache couche de messagerie. Par conséquent, plusieurs abonnés reçoivent les données et n'ont pas de stockage de données fiable car les messages sont supprimés du bus de messages une fois reçus. Les données sont stockées soit par l'application, soit en ajoutant une nouvelle source de données, ce qui est un scénario beaucoup plus complexe. La requête continue, d'autre part, garantit qu'il n'y a pas de perte de données, ce qui vous évite tous les efforts supplémentaires liés à la persistance manuelle de vos données.
NCache Détails Télécharger NCache Comparaison Des Éditions
La requête continue permet le découplage des applications grâce à un filtrage puissant
Les grandes applications complexes peuvent avoir différents regroupements en fonction de leurs architectures, par exemple, avec 10 applications en cours d'exécution, deux d'entre elles pourraient traiter l'ensemble de données des clients Gold tandis que les deux autres pourraient traiter l'ensemble de données des clients Silver. Dans de tels cas, vous voudriez une logique métier distincte pour chaque ensemble de données où les données sont filtrées en fonction des besoins de chaque application en matière de traitement de flux. Par conséquent, ces grandes applications complexes doivent être découplées car la dépendance des applications les unes sur les autres entraîne d'énormes goulots d'étranglement des performances ainsi qu'une complexité accrue des applications.
La requête continue filtre très efficacement les données de vos applications à l'aide d'instructions SQL assez sophistiquées, ainsi aucune application ne se chevauche avec les autres applications. Ce découplage devient très utile dans une architecture de microservices où chaque service s'exécute sur une pile d'applications distincte. Chaque microservice obtient et traite ses propres données sans créer de dépendance. Ce niveau de filtrage des données et de découplage des applications ne peut pas être atteint avec Pub/Sub.
La figure 2 montre diverses applications clientes traitant leurs ensembles de données respectifs dans une architecture découplée à l'aide de NCache requêtes continues.
Récupération de données à l'aide de balises
Tags in NCache sont ajoutés des qualificatifs pour les données qui sont utilisées pour classer les données en fonction de celles-ci. Pour les grands ensembles de données tels que le scénario mentionné, les balises sont vraiment utiles pour récupérer les données pertinentes au lieu de rechercher les données dans tout le cache. Si un client appartient à la catégorie des "Clients Gold", une étiquette est ajoutée avec lui pour une récupération rapide. Sur la base de ces catégories, les clients peuvent bénéficier d'avantages supplémentaires tels que des remises, des coupons, etc. NCache fournit divers façons flexibles de récupérer des données à l'aide de balises, expliqué en détail dans la documentation.
Intéressons-nous maintenant à l'exemple de code des balises associées aux « Gold Customers ». Ces clients peuvent se voir proposer des coupons ou des services premium.
1 2 3 4 5 6 7 8 9 10 11 |
string key = $"Customers:{customer.CustomerID}"; var cacheItem = new CacheItem (customer); Tag[] tags = new Tag[2]; tags[0] = new Tag ("Gold Customers");] cacheItem.Tags = tags; CacheItemVersion version = cache.Insert(key, cacheItem); // Retrieve the cache items with the tag for processing ICollection retrievedKeys = cache.SearchService.GetKeysByTag(tags[0]); |
Expiration des données de cache
NCache permet expiration des données du cache qui invalide les données après un intervalle spécifique, puis les supprime du cache à un intervalle propre.
NCache fournit deux types d'expirations :
Dans le cas des clients, l'expiration est ajoutée aux articles qui ne relèvent d'aucune des trois catégories, à savoir l'or, l'argent ou le bronze. Tous les autres clients avec des commandes inférieures à 4 sont ajoutés avec un intervalle de temps d'expiration et sont supprimés du cache pour aucune autre analyse. Cependant, l'expiration de tout client appartenant à l'une des catégories est définie sur Aucun pour conserver les données dans le cache à moins qu'elles ne soient supprimées manuellement. C'est ainsi que vous pouvez ajouter 15 secondes d'expiration à un client avec moins de 4 commandes.
1 2 3 4 5 |
var cacheItem = new CacheItem(customers[0]); // Set Expiration TimeSpan cacheItem.Expiration = new Expiration(ExpirationType.Sliding, new TimeSpan(0, 0, 15)); cache.Insert("CustomerID:" + customers[0].Id, cacheItem); |
Pourquoi utiliser NCache?
NCache is 100% .NET/.NET Solution de mise en cache distribuée en mémoire de base et leader sur le marché depuis longtemps. Il est extrêmement rapide et évolutif de manière linéaire, et il supprime efficacement les goulots d'étranglement des performances de votre application en mettant les données en cache. Il vous permet d'économiser le coût du réseau en réduisant les trajets réseau coûteux. NCache vous offre un riche ensemble de fonctionnalités telles que la requête continue qui rend l'analyse des données très rapide et efficace, ainsi que d'autres fonctionnalités pour faciliter le bon déroulement de votre application.