Les bases de données et les caches vont de pair et sont étroitement associés depuis longtemps. Les caches en tant que niveau intermédiaire réduisent la pression sur vos bases de données en conservant vos données dans le cache pour un traitement plus rapide. NCache est une solution de mise en cache distribuée en mémoire pour vos applications .NET et Java. Pendant des années, NCache offre des performances et une évolutivité élevées en réduisant la charge sur les bases de données. Il assure également un temps de réponse plus rapide pour vos applications critiques.
JSON a été l'un des formats d'échange de données les plus connus entre les applications modernes. C'est un langage indépendant de la plate-forme, léger et très lisible et compréhensible en raison de sa nature structurée. Il est extrêmement rapide et peut être utilisé par les langages de programmation modernes et est pris en charge par tous les principaux frameworks JavaScript.
Parler des deux choses mentionnées ci-dessus séparément nous amène à notre sujet de discussion ici qui est le support de JSON dans NCache. NCache étant extrêmement évolutif et distribué, il prend en charge le stockage de données JSON dans le cache ainsi que la sérialisation JSON de vos données. Vous pouvez stocker un document JSON dans le cache pour une manipulation rapide et facile. NCache fournit ses propres classes pour le stockage de données JSON, dérivées d'une classe abstraite JsonValueBase basée sur leurs propriétés. Ces cours sont :
- Valeur Json
- JsonObject
- Tableau Json
- JsonNull
NCache Détails Opérations de cache dans NCache
Exemple JSON rapide entre .NET et Java
Pour commencer, examinons un exemple rapide montrant l'utilisation des données JSON dans NCache. Vous pouvez ajouter un document JSON dans votre cache à l'aide d'une application .NET et ces données peuvent être récupérées par une application Java car JSON est indépendant de la plate-forme.
L'exemple ci-dessous montre l'ajout d'un document JSON dans votre cache en tant que JsonObject utilisant .NET.
1 2 3 4 5 6 7 8 9 10 |
// Pre-Condition: Cache is JSON serialized // The data provided in the string is a jsonObject string jsonString = "{ 'ProductID' : 1001, 'ProductName' : 'Chai', 'Category': 'Beverages', 'UnitPrice' : 500, 'UnitsInStock' : 2000 }"; // Populate an instance of the JsonObject by passing the string var jsonProduct = new JsonObject(jsonString); // Insert the jsonObject in the cache with a key string key = “Product:ProductID:1001”; cache.Insert(key, jsonProduct); |
Le document JSON ajouté ci-dessus peut être récupéré à l'aide d'une application Java. Le code ci-dessous montre la récupération des mêmes documents JSON via Java. Il supprime en outre les attributs du JsonObject, puis réinsère le JsonObject dans le cache.
1 2 3 4 5 6 7 |
JsonObject jsonProduct = cache.get(key, JsonObject.class); // Remove the attribute UnitPrice from the JsonObject boolean result = jsonProduct2.removeAttribute("UnitPrice"); // Re-insert the item in the cache with the removed attribute cache.insert(key, jsonProduct); |
Prise en charge de JSON dans NCache
NCache est la principale solution de mise en cache qui permet d'ajouter des données personnalisées dans votre cache et de les récupérer au format JSON. De même, vous pouvez ajouter des données JSON dans le cache et les récupérer en tant qu'objet de données personnalisé.
Comme mentionné précédemment, NCache fournit ses propres classes dérivées de JsonValueBase et ces classes sont ensuite utilisées pour ajouter différents formats de données JSON dans le cache. Nous allons détailler ces classes une par une :
1. ValeurJson
Valeur Json représente les types de données primitifs dans les conventions de JSON. Vous pouvez ajouter une valeur de n'importe quel type primitif, y compris d'autres tels que string, DateTime ou décimal dans .NET en tant que JsonValue dans le cache.
1 2 3 4 5 |
string keyInt = $"Product:{product.ProductID}"; JsonValue jsonValue = 1001; // Insert a JsonValue in the cache with the key cache.Insert(keyInt,jsonValue); |
2. JsonObject
JsonObject est un conteneur pour les paires nom/valeur non ordonnées où nom ou clé est le nom de l'attribut et valeur peut être n'importe lequel des types de données primitifs. Vous pouvez analyser une chaîne entière contenant les données JSON et en remplir un JsonObject. De même, un objet personnalisé peut également être récupéré en tant que JsonObject et vice versa. L'exemple ci-dessous montre la création d'un JsonObject avec des attributs et leurs valeurs, puis son ajout au cache. Il montre ensuite d'autres opérations sur le JsonObject telles que la suppression d'un attribut particulier.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
string key = "jsonKey"; // Create a new JsonObject with the attributes and insert in the cache JsonObject jsonProduct = new JsonObject(); jsonProduct.AddAttribute("ProductID", 1001); jsonProduct.AddAttribute("ProductName", (JsonValue)"Chai"); cache.Insert(key, jsonProduct); // Retrieve the jsonObject previously added the attribute from jsonObject var jsonProduct2 = cache.Get<JsonObject>(key); // Remove the attribute from jsonObject without changing the entire object bool result = jsonProduct2.RemoveAttribute("UnitPrice"); cache.Insert(key, jsonProduct2); |
3. Tableau Json
Tableau Json est une collection d'éléments et représente JArray dans NCachele domaine. Tout comme JsonObject, vous pouvez spécifier n'importe quelle valeur ou objet dérivé de JsonValueBase. Vous pouvez ajouter, récupérer ou même supprimer des valeurs d'un JsonArray à n'importe quel index spécifié.
1 2 3 4 |
string jsonProductIds = " ['ProductIDs', { 'ProductID' : 1001 }, { 'ProductID' : 1002 }, { 'ProductID' : 1003 } ]"; // Create a JsonArray with from the JSON document provided var jsonArray = new JsonArray(jsonProductIds); |
4. JsonNull
Cette classe représente une valeur nulle dans les normes JSON. L'exemple donné montre une valeur null pour un attribut de JsonObject. Lors de la récupération ultérieure de l'attribut avec la valeur nulle, il lève une exception.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
// Create a new JsonObject with attributes and insert in the cache var jsonProduct = new JsonObject(); jsonProduct.AddAttribute("ProductID", product.ProductID); jsonProduct.AddAttribute("ProductName", (JsonValue)product.ProductName); jsonObject.AddAttribute("Category", null); cache.Insert(key, jsonProduct); // Retrieve the same jsonObject previously created var jsonProduct2 = cache.Get<JsonObject>(key); var productCategory = jsonObject.GetAttributeValue("Cateogry"); // Check if the attribute value is null if(category.DataType == Runtime.Enum.JsonDataType.Null) { // Throw category null Exception } |
NCache Détails Données de cache en tant que documents JSON Sérialisation JSON
Indexation de documents JSON dans NCache
Si votre cache est un magasin JSON, vous pouvez indexer vos données en utilisant l'une des méthodes suivantes :
- Groupes: Les éléments d'une cache ayant une relation entre eux ou relevant de la même catégorie peuvent être regroupés en NCache en utilisant NCache Fonction "Groupes". En utilisant Groupes, vous pouvez logiquement partitionner vos données pour une meilleure efficacité.
- Tags: Les balises sont des identifiants basés sur des chaînes, associés à vos données. En utilisant Tags, vous pouvez associer des mots-clés à vos éléments de cache qui sont ensuite utiles pour effectuer diverses opérations de cache sur vos données à l'aide de ces mots-clés.
- Balises nommées : Balises nommées est une fonctionnalité fournie par NCache qui est une forme améliorée de balises. Ils associent des informations particulières aux éléments sous forme de paire clé-valeur au moment de l'exécution.
Les documents JSON sont ajoutés dans le cache avec ces identifiants et NCache indexe les données en fonction de ces identifiants. Vous pouvez ensuite utiliser les requêtes fournies par NCache pour y effectuer des opérations. L'exemple ci-dessous montre l'ajout d'un document JSON dans le cache avec des balises nommées qui lui sont associées.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
string jsonString = "{'ProductID' : 1001, 'ProductName' : 'Chai', 'Category': 'Beverages', 'UnitPrice' : 500, 'UnitsInStock' : 2000 }"; // Populate an instance of the JsonObject by passing the string var jsonProduct = new JsonObject(jsonString); string key = $"Products:{product.ProductID}"; var item = new CacheItem(jsonProduct); var productNamedTag = new NamedTagsDictionary(); // Add NamedTag 'Discount' to the dictionary with the value productNamedTag.Add("Discount", 0.5); item.NamedTags = productNamedTag; // Add CacheItem with the NamedTag associated cache.Insert(key, item); |
Recherche de documents JSON avec SQL dans NCache
NCache fournit des requêtes de type SQL pour récupérer des données et les supprimer. Vous pouvez utiliser des requêtes sur les données indexées pour récupérer les données JSON dans l'un des formats fournis par NCache.
L'exemple donné montre l'interrogation des données indexées dans l'exemple ci-dessus qui est un document JSON ajouté avec des balises nommées. La requête récupère tous les JsonObjects du cache avec la valeur de remise de 0.5.
1 2 3 4 5 6 7 |
// Create a query for fetching item with NamedTag string query = "Select * FROM Alachisoft.NCache.Runtime.JSON.JsonArray WHERE Discount = ?"; QueryCommand queryCommand = new QueryCommand(query); queryCommand.Parameters.Add("Discount", 0.5); var queryResult = cache.SearchService.ExecuteReader(queryCommand); // QueryResult contains all the keys and metadata of result |
Documents JSON persistants
NCache dispose d'un certain nombre de fonctionnalités côté serveur pour effectuer des opérations directes sur votre source de données principale. Ces fonctionnalités offrent la possibilité de lire ou d'écrire des données depuis et vers la source de données principale ainsi que de précharger les données dans le cache. L'une de ces fonctionnalités appelée Source de sauvegarde vous offre la facilité de :
- Lire à travers: Lire à travers récupère les données de la source de données au cas où elles ne seraient pas présentes dans le magasin de cache.
- Ecriture :Ecriture met à jour la source de données (toute opération d'écriture) après la mise à jour du magasin de cache.
NCache appelle un fournisseur que vous avez écrit, avec votre logique personnalisée pour charger des données à partir de la source de données principale ou écrire des données dans votre source de données principale. Les prestataires sont alors déployé en utilisant NCache Web Manager pour utiliser Read-Through/Write-Through.
Pour les sources de données principales basées sur JSON telles que Cosmos DB, l'utilisation de données JSON dans le cache présente un avantage supplémentaire. Contrairement à .NET, pour JSON vous pouvez écrire un fournisseur générique pour toutes vos applications en JSON à déployer sur votre cache pour charger directement les données de la base de données. Vous pouvez obtenir une plus grande persistance en utilisant ces fournisseurs génériques car JSON est indépendant de la plate-forme. .NET vous oblige à écrire un fournisseur différent pour chacune de vos applications car les données doivent être sérialisées puis désérialisées. Lorsque votre cache et votre base de données sont tous deux des magasins JSON, ces fonctionnalités vous offrent une persistance de très haut niveau augmentant les performances de votre application. Vous trouverez ci-dessous un code montrant comment l'écriture immédiate fonctionne avec JSON.
1 2 3 4 5 6 7 8 9 10 11 12 |
string jsonString = "{ 'ProductID' : 1001, 'ProductName' : 'Chai', 'Category': 'Beverages', 'UnitPrice' : 500, 'UnitsInStock' : 2000 }"; // Populate an instance of the JsonObject by passing the string var jsonProduct = new JsonObject(jsonString); string key = $"Products:{product.ProductID}"; // Enable write through for the cacheItem created var writeThruOptions = new WriteThruOptions(); writeThruOptions.Mode = WriteMode.WriteThru; // Add the item in the cache with WriteThru enabled CacheItemVersion itemVersion = cache.Insert(key, cacheItem, writeThruOptions); |
Vous pouvez obtenir un guide complet pour NCacheFonctionnalités côté serveur de.
Sérialisation JSON des objets .NET et Java
In NCache, toutes les données ajoutées dans le cache sont sérialisées. La sérialisation peut être binaire ou JSON. C'est un langage indépendant de la plate-forme et il a beaucoup d'avantages pour être largement pris en charge. Presque tous les langages de programmation prennent en charge la sérialisation et la désérialisation de JSON dans leurs bibliothèques standard. NCache prend votre objet personnalisé, JSON le sérialise en le convertissant en JSON, puis le désérialise en retour à l'objet personnalisé.
Sérialisation JSON vos données dans NCache vous offre une grande flexibilité car il utilise JSON.NET, il est donc extrêmement portable avec plusieurs langues et désérialise les données en fonction des besoins de l'utilisateur. Il ne nécessite aucune modification de code et vous permet de spécifier facilement les attributs non sérialisables.
Regardez l'exemple ci-dessous pour les données dans .NET et c'est l'équivalent de JSON.
.NET | JSON |
Product product = new Product(); |
{ |
Le partage de données est l'un des principaux avantages de la sérialisation JSON de vos données. JSON étant assez simple, compréhensible et n'ayant pas de bibliothèques complexes, vous permet de fournir le type dans lequel les données doivent être désérialisées. Il a un schéma très flexible pour la sérialisation étant donné que les attributs sont les mêmes lors de la désérialisation. Non seulement cela, il vous permet même de mapper deux versions différentes de la même classe sérialisées avec JSON. Vous pouvez JSON sérialiser vos données à partir d'une classe .NET et une application Java peut accéder aux données sérialisées avec les attributs de nom. La figure 1 illustre le partage des données entre les applications .NET et Java à l'aide de la sérialisation JSON dans le cache.
Conclusion
Ceci nous amène à la fin de notre blog qui montre l'importance de NCache en tant que magasin JSON. NCache est un cache distribué en mémoire qui vous permet d'utiliser des documents JSON dans le cache. Il vous permet de conserver les données persistantes dans le cache avec les avantages supplémentaires de la sérialisation JSON et du partage de données entre les applications .NET et Java.