Datenbanken und Caches gehen Hand in Hand und sind schon lange eng miteinander verbunden. Caches als mittlere Ebene reduzieren den Druck auf Ihre Datenbanken, indem sie Ihre Daten für eine schnellere Verarbeitung im Cache halten. NCache ist eine verteilte In-Memory-Caching-Lösung für Ihre .NET- und Java-Anwendungen. Jahrelang, NCache bietet hohe Leistung und Skalierbarkeit, indem es die Belastung der Datenbanken reduziert. Es gewährleistet außerdem eine schnellere Reaktionszeit für Ihre geschäftskritischen Anwendungen.
JSON ist eines der bekanntesten Datenaustauschformate zwischen modernen Anwendungen. Es handelt sich um eine plattformunabhängige, leichte und aufgrund ihrer strukturierten Natur sehr gut lesbare und verständliche Sprache. Es ist extrem schnell und kann von modernen Programmiersprachen verwendet werden und wird von allen wichtigen JavaScript-Frameworks unterstützt.
Wenn wir über die beiden oben genannten Dinge getrennt sprechen, kommen wir hier zu unserem Diskussionsthema, nämlich der Unterstützung von JSON in NCache. NCache Da es extrem skalierbar und verteilt ist, unterstützt es die JSON-Datenspeicherung im Cache sowie die JSON-Serialisierung Ihrer Daten. Sie können ein JSON-Dokument zur schnellen und einfachen Bearbeitung im Cache speichern. NCache stellt eigene Klassen für die JSON-Datenspeicherung bereit, die auf der Grundlage ihrer Eigenschaften von einer abstrakten Klasse JsonValueBase abgeleitet werden. Diese Klassen sind:
- JsonWert
- JsonObject
- JsonArray
- JsonNull
NCache Details Cache-Operationen in NCache
Schnelles JSON-Beispiel zwischen .NET und Java
Schauen wir uns zunächst ein kurzes Beispiel an, das die Verwendung von JSON-Daten in zeigt NCache. Sie können mit einer .NET-Anwendung ein JSON-Dokument zu Ihrem Cache hinzufügen und diese Daten können von einer Java-Anwendung abgerufen werden, da JSON plattformunabhängig ist.
Das folgende Beispiel zeigt das Hinzufügen eines JSON-Dokuments in Ihrem Cache als JsonObject mithilfe von .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); |
Das oben hinzugefügte JSON-Dokument kann mit einer Java-Anwendung abgerufen werden. Der unten angegebene Code zeigt den Abruf derselben JSON-Dokumente über Java. Außerdem werden die Attribute des JsonObject entfernt und das JsonObject dann erneut in den Cache eingefügt.
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); |
JSON-Unterstützung in NCache
NCache ist die primäre Caching-Lösung, mit der Sie benutzerdefinierte Daten zu Ihrem Cache hinzufügen und diese im JSON-Format abrufen können. Ebenso können Sie JSON-Daten im Cache hinzufügen und als benutzerdefiniertes Datenobjekt abrufen.
Wie bereits erwähnt, NCache stellt eigene, von JsonValueBase abgeleitete Klassen bereit und diese Klassen werden dann weiter verwendet, um verschiedene Formate von JSON-Daten im Cache hinzuzufügen. Wir werden uns diese Klassen einzeln genauer ansehen:
1. JsonValue
JsonWert stellt die primitiven Datentypen in den JSON-Konventionen dar. Sie können Werte jedes beliebigen primitiven Typs, einschließlich anderer wie String, DateTime oder Decimal in .NET, als JsonValue im Cache hinzufügen.
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 ist ein Container für ungeordnete Name/Wert-Paare, wobei Name oder Schlüssel der Name des Attributs ist und Wert jeder der primitiven Datentypen sein kann. Sie können eine ganze Zeichenfolge mit den JSON-Daten analysieren und daraus ein JsonObject füllen. Ebenso kann ein benutzerdefiniertes Objekt auch als JsonObject abgerufen werden und umgekehrt. Das folgende Beispiel zeigt die Erstellung eines JsonObject mit Attributen und ihren Werten und das anschließende Hinzufügen zum Cache. Anschließend werden weitere Vorgänge am JsonObject angezeigt, beispielsweise das Entfernen eines bestimmten Attributs.
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. JsonArray
JsonArray ist eine Sammlung von Elementen und repräsentiert JArray in NCache's Domäne. Genau wie bei JsonObject können Sie jeden von JsonValueBase abgeleiteten Wert oder jedes Objekt angeben. Sie können einem JsonArray an jedem angegebenen Index Werte hinzufügen, abrufen oder sogar daraus entfernen.
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
Diese Klasse stellt in JSON-Standards einen Nullwert dar. Das angegebene Beispiel zeigt einen Nullwert für ein Attribut des JsonObject. Beim weiteren Abrufen des Attributs mit dem Nullwert wird eine Ausnahme ausgelöst.
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 Details Daten als JSON-Dokumente zwischenspeichern JSON-Serialisierung
Indizieren von JSON-Dokumenten in NCache
Wenn es sich bei Ihrem Cache um einen JSON-Speicher handelt, können Sie Ihre Daten mit einer der folgenden Methoden indizieren:
- Groups: Elemente in einem Cache, zwischen denen eine Beziehung besteht oder die in eine ähnliche Kategorie fallen, können gruppiert werden NCache Verwendung von NCache Funktion „Gruppen“. Benutzen Groupskönnen Sie Ihre Daten für eine bessere Effizienz logisch partitionieren.
- Schlüsselwörter: Tags sind stringbasierte Identifikatoren, die Ihren Daten zugeordnet sind. Benutzen Schlüsselwörterkönnen Sie Ihren Cache-Elementen Schlüsselwörter zuordnen, die dann bei der Durchführung verschiedener Cache-Vorgänge für Ihre Daten mithilfe dieser Schlüsselwörter hilfreich sind.
- Benannte Tags: Benannte Tags ist eine Funktion von NCache Dies ist eine erweiterte Form von Tags. Sie verknüpfen zur Laufzeit bestimmte Informationen mit den Elementen in Form eines Schlüssel-Wert-Paares.
JSON-Dokumente werden mit diesen Bezeichnern und im Cache hinzugefügt NCache indiziert die Daten basierend auf diesen Kennungen. Sie können später die von bereitgestellten Abfragen verwenden NCache um Operationen daran durchzuführen. Das folgende Beispiel zeigt das Hinzufügen eines JSON-Dokuments mit zugeordneten benannten Tags zum Cache.
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); |
Durchsuchen von JSON-Dokumenten mit SQL in NCache
NCache Bietet SQL-ähnliche Abfragen zum Abrufen und Entfernen von Daten. Sie können Abfragen für die indizierten Daten verwenden, um die JSON-Daten in jedem der von bereitgestellten Formate abzurufen NCache.
Das gegebene Beispiel zeigt die Abfrage der im obigen Beispiel indizierten Daten, bei denen es sich um ein JSON-Dokument handelt, dem benannte Tags hinzugefügt wurden. Die Abfrage ruft alle JsonObjects mit dem Rabattwert 0.5 aus dem Cache ab.
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 |
Persistente JSON-Dokumente
NCache verfügt über eine Reihe serverseitiger Funktionen zur Durchführung direkter Vorgänge an Ihrer Stammdatenquelle. Diese Funktionen bieten die Flexibilität, Daten von und in die Master-Datenquelle zu lesen oder zu schreiben sowie die Daten vorab in den Cache zu laden. Eine dieser Funktionen heißt Hintergrundquelle bietet Ihnen die Leichtigkeit von:
- Durchlesen: Durchlesen ruft Daten aus der Datenquelle ab, falls diese nicht im Cache-Speicher vorhanden sind.
- Durchschreiben:Durchschreiben Aktualisiert die Datenquelle (jeden Schreibvorgang), nachdem der Cache-Speicher aktualisiert wurde.
NCache ruft einen von Ihnen geschriebenen Anbieter mit Ihrer benutzerdefinierten Logik auf, um Daten aus der Stammdatenquelle zu laden oder Daten in Ihre Stammdatenquelle zu schreiben. Die Anbieter sind dann Einsatz Verwendung von NCache Web Manager zur Verwendung von Read-Through/Write-Through.
Für JSON-basierte Stammdatenquellen wie Cosmos DB bietet die Verwendung von JSON-Daten im Cache einen zusätzlichen Vorteil. Im Gegensatz zu .NET können Sie für JSON einen generischen Anbieter für alle Ihre Anwendungen in JSON schreiben, der in Ihrem Cache bereitgestellt wird, um Daten direkt aus der Datenbank zu laden. Durch die Verwendung dieser generischen Anbieter können Sie eine höhere Persistenz erreichen, da JSON plattformunabhängig ist. .NET erfordert, dass Sie für jede Ihrer Anwendungen einen anderen Anbieter schreiben, da die Daten serialisiert und anschließend deserialisiert werden müssen. Wenn Ihr Cache und Ihre Datenbank beide JSON-Speicher sind, bieten Ihnen diese Funktionen eine sehr hohe Persistenz, die Ihre Anwendungsleistung steigert. Unten finden Sie einen Code, der zeigt, wie das Durchschreiben mit JSON funktioniert.
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); |
Sie können eine vollständige Anleitung dazu erhalten NCache's serverseitige Funktionen.
JSON-Serialisierung von .NET- und Java-Objekten
In NCache, werden alle im Cache hinzugefügten Daten serialisiert. Die Serialisierung kann entweder binär oder JSON sein. Es ist eine plattformunabhängige Sprache und hat große Vorteile, weil sie umfassend unterstützt wird. Fast alle Programmiersprachen unterstützen die Serialisierung und Deserialisierung von JSON in ihren Standardbibliotheken. NCache nimmt Ihr benutzerdefiniertes Objekt, JSON serialisiert es durch Konvertierung in JSON und deserialisiert es dann wieder in das benutzerdefinierte Objekt.
JSON-Serialisierung Ihre Daten in NCache Bietet Ihnen viel Flexibilität, da JSON.NET verwendet wird, sodass es mit mehreren Sprachen äußerst portierbar ist und die Daten entsprechend den Benutzeranforderungen deserialisiert. Es erfordert keine Codeänderung und ermöglicht Ihnen die einfache Angabe der nicht serialisierbaren Attribute.
Sehen Sie sich das folgende Beispiel für Daten in .NET und dem JSON-Äquivalent an.
.NET | JSON |
Product product = new Product(); |
{ |
Der Datenaustausch ist einer der zentralen Vorteile der JSON-Serialisierung Ihrer Daten. Da JSON relativ einfach und verständlich ist und keine komplexen Bibliotheken enthält, können Sie den Typ angeben, in dem Daten deserialisiert werden müssen. Es verfügt über ein sehr flexibles Schema für die Serialisierung, da die Attribute beim Deserialisieren dieselben sind. Darüber hinaus können Sie damit sogar zwei verschiedene Versionen derselben Klasse zuordnen, die mit JSON serialisiert sind. Sie können Ihre Daten aus einer .NET-Klasse JSON-serialisieren und eine Java-Anwendung kann mit den Namensattributen auf die serialisierten Daten zugreifen. Abbildung 1 zeigt, wie Daten mithilfe der JSON-Serialisierung im Cache zwischen .NET- und Java-Anwendungen gemeinsam genutzt werden.
Zusammenfassung
Damit sind wir am Ende unseres Blogs angelangt, der die Bedeutung von zeigt NCache als JSON-Store. NCache ist ein verteilter In-Memory-Cache, mit dem Sie JSON-Dokumente im Cache verwenden können. Es ermöglicht Ihnen, die persistenten Daten im Cache zu behalten, mit zusätzlichen Vorteilen der JSON-Serialisierung und der Datenfreigabe zwischen .NET- und Java-Anwendungen.