Database e cache vanno di pari passo e sono in stretta collaborazione da molto tempo ormai. Le cache come livello intermedio riducono la pressione sui database mantenendo i dati nella cache per un'elaborazione più rapida. NCache è una soluzione di memorizzazione nella cache distribuita in memoria per le applicazioni .NET e Java. Per anni, NCache ha fornito prestazioni e scalabilità elevate riducendo il carico sui database. Garantisce inoltre tempi di risposta più rapidi per le applicazioni mission-critical.
JSON è stato uno dei formati di scambio dati più famosi tra le moderne applicazioni. È un linguaggio indipendente dalla piattaforma, leggero e molto leggibile e comprensibile grazie alla sua natura modellata. È estremamente veloce e può essere utilizzato dai moderni linguaggi di programmazione ed è supportato da tutti i principali framework JavaScript.
Parlare delle due cose sopra menzionate separatamente ci porta al nostro argomento di discussione qui che è il supporto di JSON in NCache. NCache essendo estremamente scalabile e distribuito supporta l'archiviazione dei dati JSON nella cache insieme alla serializzazione JSON dei tuoi dati. Puoi archiviare un documento JSON nella cache per una manipolazione facile e veloce. NCache fornisce le proprie classi per l'archiviazione dei dati JSON, derivate da una classe astratta JsonValueBase in base alle loro proprietà. Queste classi sono:
- Json Value
- Json Object
- JsonArray
- Json Null
NCache Dettagli Operazioni nella cache in NCache
Esempio JSON rapido tra .NET e Java
Per cominciare, diamo un'occhiata a un rapido esempio che mostra l'utilizzo dei dati JSON in NCache. Puoi aggiungere un documento JSON nella tua cache utilizzando un'applicazione .NET e questi dati possono essere recuperati da un'applicazione Java poiché JSON è indipendente dalla piattaforma.
L'esempio riportato di seguito mostra l'aggiunta di un documento JSON nella cache come JsonObject utilizzando .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); |
Il documento JSON aggiunto sopra può essere recuperato utilizzando un'applicazione Java. Il codice riportato di seguito mostra il recupero degli stessi documenti JSON tramite Java. Rimuove ulteriormente gli attributi di JsonObject e quindi reinserisce JsonObject nella 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); |
Supporto JSON in NCache
NCache è la soluzione di memorizzazione nella cache principale che consente di aggiungere dati personalizzati nella cache e recuperarli in formato JSON. Allo stesso modo, puoi aggiungere dati JSON nella cache e recuperarli come oggetto dati personalizzato.
Come menzionato prima, NCache fornisce le proprie classi derivate da JsonValueBase e queste classi vengono quindi ulteriormente utilizzate per aggiungere diversi formati di dati JSON nella cache. Daremo un'occhiata più da vicino a queste classi una per una:
1. Valore Json
Json Value rappresenta i tipi di dati primitivi nelle convenzioni di JSON. Puoi aggiungere valori di qualsiasi tipo primitivo inclusi altri come string, DateTime o decimale in .NET come JsonValue nella 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. JsonOggetto
Json Object è un contenitore per coppie nome/valore non ordinate dove nome o chiave è il nome dell'attributo e valore può essere uno qualsiasi dei tipi di dati primitivi. Puoi analizzare un'intera stringa contenente i dati JSON e popolare un JsonObject da esso. Allo stesso modo, un oggetto personalizzato può anche essere recuperato come JsonObject e viceversa. L'esempio seguente mostra la creazione di un JsonObject con attributi e i relativi valori e quindi l'aggiunta alla cache. Mostra quindi ulteriori operazioni su JsonObject come la rimozione di un particolare attributo.
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 è una raccolta di oggetti e rappresenta JArray in NCachedominio di. Proprio come JsonObject, puoi specificare qualsiasi valore o oggetto derivato da JsonValueBase. Puoi aggiungere, recuperare o persino rimuovere valori da un JsonArray in qualsiasi indice specificato.
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. Json Null
Questa classe rappresenta un valore nullo negli standard JSON. L'esempio fornito mostra il valore null per un attributo di JsonObject. Recuperando ulteriormente l'attributo con il valore null, viene generata un'eccezione.
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 Dettagli Memorizza i dati nella cache come documenti JSON Serializzazione JSON
Indicizzazione di documenti JSON in NCache
Se la tua cache è un negozio JSON, puoi indicizzare i tuoi dati utilizzando uno dei seguenti:
- ATTIVITA' E GRUPPI: gli elementi in una cache che hanno una relazione tra loro o che rientrano in una categoria simile possono essere raggruppati NCache utilizzando NCache Funzione "Gruppi". Usando ATTIVITA' E GRUPPI, puoi partizionare logicamente i tuoi dati per una migliore efficienza.
- tag: i tag sono identificatori basati su stringhe, associati ai tuoi dati. Usando tag, puoi associare le parole chiave agli elementi della cache che sono quindi utili per eseguire varie operazioni di cache sui dati utilizzando tali parole chiave.
- Tag con nome: Tag con nome è una funzionalità fornita da NCache che è una forma avanzata di tag. Associano informazioni particolari agli elementi sotto forma di coppia chiave-valore in fase di esecuzione.
I documenti JSON vengono aggiunti nella cache con questi identificatori e NCache indicizza i dati in base a questi identificatori. In seguito puoi utilizzare le query fornite da NCache per eseguire operazioni su di esso. L'esempio seguente mostra l'aggiunta di un documento JSON nella cache con tag denominati ad esso associati.
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); |
Ricerca di documenti JSON con SQL in NCache
NCache fornisce query simili a SQL per recuperare i dati e rimuoverli. Puoi utilizzare le query sui dati indicizzati per recuperare i dati JSON in qualsiasi formato fornito da NCache.
L'esempio fornito mostra l'interrogazione dei dati indicizzati nell'esempio precedente, che è un documento JSON aggiunto con tag denominati. La query recupera tutti i JsonObject dalla cache con il valore di sconto di 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 |
Documenti JSON persistenti
NCache dispone di una serie di funzionalità lato server per eseguire operazioni dirette sull'origine dati master. Queste caratteristiche offrono la flessibilità di leggere o scrivere dati da e verso l'origine dati master, nonché di precaricare i dati nella cache. Una di queste funzionalità chiamata Fonte di supporto ti offre la facilità di:
- Leggi tutto: Leggi attraverso recupera i dati dall'origine dati nel caso in cui non siano presenti nell'archivio cache.
- Scrivere attraverso:Scrivere attraverso aggiorna l'origine dati (qualsiasi operazione di scrittura) dopo aver aggiornato l'archivio cache.
NCache chiama un provider che è stato scritto da te, con la tua logica personalizzata per caricare i dati dall'origine dati master o scrivere dati nell'origine dati master. I fornitori sono quindi schierato utilizzando NCache Web Manager per utilizzare Read-Through/Write-Through.
Per le origini dati master basate su JSON come Cosmos DB, c'è un ulteriore vantaggio nell'usare i dati JSON nella cache. A differenza di .NET, per JSON puoi scrivere un provider generico per tutte le tue applicazioni in JSON da distribuire nella cache per caricare direttamente i dati dal database. Puoi ottenere una maggiore persistenza utilizzando questi provider generici poiché JSON è indipendente dalla piattaforma. .NET richiede la scrittura di un provider diverso per ciascuna applicazione poiché i dati devono essere serializzati e quindi deserializzati. Quando la tua cache e il tuo database sono entrambi archivi JSON, queste funzionalità ti forniscono una persistenza di altissimo livello aumentando le prestazioni delle tue applicazioni. Di seguito è riportato un codice che mostra come funziona il write-through con 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); |
È possibile ottenere una guida completa a NCachefunzionalità lato server di.
Serializzazione JSON di oggetti .NET e Java
In NCache, tutti i dati aggiunti nella cache vengono serializzati. La serializzazione può essere binaria o JSON. È un linguaggio indipendente dalla piattaforma e ha molto vantaggio per essere ampiamente supportato. Quasi tutti i linguaggi di programmazione supportano la serializzazione e la deserializzazione di JSON nelle loro librerie standard. NCache prende il tuo oggetto personalizzato, JSON lo serializza convertendolo in JSON e quindi lo deserializza di nuovo nell'oggetto personalizzato.
Serializzazione JSON i tuoi dati in NCache ti consente molta flessibilità poiché utilizza JSON.NET, quindi è estremamente portatile con più lingue e deserializza i dati in base alle esigenze dell'utente. Non richiede alcuna modifica del codice e ti offre la possibilità di specificare facilmente gli attributi non serializzabili.
Guarda l'esempio seguente per i dati in .NET ed è l'equivalente di JSON.
.NET | JSON |
Product product = new Product(); |
{ |
La condivisione dei dati è uno dei vantaggi centrali della serializzazione JSON dei tuoi dati. Essendo JSON abbastanza semplice, comprensibile e senza librerie complesse, puoi fornire il tipo in cui i dati devono essere deserializzati. Ha uno schema molto flessibile per la serializzazione dato che gli attributi sono gli stessi durante la deserializzazione. Non solo, ti consente anche di mappare due diverse versioni della stessa classe serializzate con JSON. Puoi serializzare JSON i tuoi dati da una classe .NET e un'applicazione Java può accedere ai dati serializzati con gli attributi del nome. La figura 1 illustra come i dati vengono condivisi tra le applicazioni .NET e Java utilizzando la serializzazione JSON nella cache.
Conclusione
Questo ci porta alla fine del nostro blog che mostra il significato di NCache come negozio JSON. NCache è una cache distribuita in memoria che ti consente di utilizzare i documenti JSON nella cache. Ti consente di mantenere i dati persistenti nella cache con ulteriori vantaggi della serializzazione JSON e della condivisione dei dati tra .NET e l'applicazione Java.