Hai sentito di eBay utilizzando MongoDB come loro database principale? Ora, perché una multinazionale di e-commerce come eBay dovrebbe utilizzare MongoDB e non un tradizionale RDBMS? È perché MongoDB è stato un argomento caldo tra gli sviluppatori per il suo archivio di valori chiave distribuito e orientato ai documenti NoSQL caratteristiche. E, se eBay lo sta utilizzando, sono sicuro che anche la tua applicazione di e-commerce utilizza MongoDB.
Dimentica eBay. Prendiamo la tua applicazione di e-commerce e analizziamo i suoi dati di base e le sue esigenze di prestazioni. Ora nel tuo .NET/.NET Core app, ti sei mai sentito come se le prestazioni fossero compromesse perché hai richieste limitate al secondo? Hai notato il ritardo nelle chiamate di lettura/scrittura al database basato su disco? Hai avuto la sensazione che, nonostante tutte le sue meravigliose funzionalità, MongoDB manchi ancora di un certo collegamento che potrebbe portare gloria alla tua applicazione?
Questo, amico mio, è dove qualcuno (io) ti colpisce (solo virtualmente) e ti presenta NCache nella vostra vita. NCache è un in-memory, distribuito e altamente scalabile cache che rimane sempre accanto alla tua applicazione; migliorando la velocità di transazione e quindi rendendolo la soluzione perfetta per tutte le tue esigenze di memorizzazione nella cache. Facciamo un piccolo tour di come puoi ottenere il meglio dalla tua applicazione utilizzando NCache.
NCache Dettagli Sincronizza la cache con il database NCache NoSql Datastore
utilizzando NCache come cache distribuita con MongoDB
Con un'applicazione di e-commerce altamente transazionale come la tua che viene eseguita in un ambiente multi-server, non puoi permetterti di avere una singola cache del server che intrattenga tutte le tue richieste di dati. Maggiore è il carico sulla tua applicazione, maggiori sono le possibilità che la tua cache si strozzi per le richieste.
Potrebbe venire un momento durante l'esecuzione dell'applicazione in cui il carico delle transazioni sull'applicazione aumenta e il numero di server cache inizialmente impostati non è abbastanza per accogliere le richieste in arrivo. Qui è dove NCache ridimensiona perfettamente la tua applicazione permettendoti di farlo aggiungere server cache aggiuntivi in fase di esecuzione quindi la cache non diventa mai un collo di bottiglia per la tua applicazione. Quindi, garantendo prestazioni ottimali nel tuo .NET/.NET Core applicazione.
Per avere un'immagine corretta di dove esattamente NCache si trova all'interno dello stack dell'applicazione, diamo un'occhiata all'architettura di base.
MongoDB è considerato più scalabile rispetto ai database relazionali, ma il fatto che sia un datastore basato su disco rimane uno svantaggio. Quindi, usando NCache fornisce la memorizzazione nella cache dei dati basata sulla memoria rimanendo all'interno o all'esterno della rete virtuale dell'app (chiamata totalmente tua). Ciò rende i processi delle tue applicazioni molto più veloci del previsto, riducendo così la latenza.
Questo non ti dà più del motivo per usarlo NCache per memorizzare nella cache i dati del tuo database? Non fermiamoci qui e tuffiamoci un po' più a fondo in cosa NCache porta al tavolo.
NCache Dettagli Sincronizza la cache con il database NCache NoSql Datastore
Come memorizzare nella cache con MongoDB
La memorizzazione nella cache con MongoDB è estremamente semplice. Sia che tu voglia cercare un dato specifico nella cache o interrogare il database stesso per recuperare i dati richiesti, o semplicemente aggiungere nuovi dati al database, tutto può essere fatto con la massima facilità d'uso NCache.
Il frammento di codice seguente spiega come eseguire tutte queste operazioni di cui sopra nella tua applicazione di e-commerce. Qui cerchiamo un tuo cliente molto fedele e intelligente, Einstein, nella cache da eseguire Operazioni CRUD su di esso. E nel caso in cui la cache non abbia il cliente richiesto, lo cerchiamo nel database. Una volta recuperato, aggiungiamo quel cliente alla cache con un scadenza di 5 minuti. Questo viene fatto in modo che il la cache non ha mai dati obsoleti da offrirti. Quindi, garantire la coerenza dei dati.
1 2 3 4 5 6 7 8 9 10 11 12 13 |
var customer = cache.Get("Customer:CustomerID:EINSTEIN"); if (customer == null) { MongoClient mongoClient = new MongoClient("mongodb://20.200.20.10:27017"); IMongoDatabase mongoDatabase = mongoClient.GetDatabase("DemoDatabase"); IMongoCollection <Customer> mongoCollection = mongoDatabase.GetCollection<Customer>("Customers"); response = mongoCollection.FindAsync<Customer>(x => x.Id == "EINSTEIN").GetAwaiter().GetResult().ToList<Customer>(); customer = (Customer)response.FirstOrDefault(); var expiration = new Expiration(ExpirationType.Absolute, TimeSpan.FromMinutes(5)); var cacheItem = new CacheItem(customer) { Expiration = expiration }; cache.Insert($"Customer:CustomerID:{customer.Id}", cacheItem); } |
NCache Dettagli Sincronizza la cache con il database NCache NoSql Datastore
Memorizzazione nella cache della raccolta di elementi del database
Il più grande vantaggio dell'introduzione NCache alla tua applicazione e il database è che i viaggi al database appositamente per leggere le operazioni ridurre notevolmente, riducendo le chiamate di rete non necessarie e migliorando le prestazioni. L'unico motivo di questo posizionamento logico è che ogni volta che si desidera recuperare elementi dal database ed eseguire operazioni su di esso, è possibile eseguire tutto nel livello di memorizzazione nella cache.
Per realizzare questo, NCache ti consente di memorizzare nella cache una raccolta MongoDB come file elemento della cache o un singolo elemento come un elemento della cache. Diamo un'occhiata a come memorizzare nella cache gli elementi come coppie chiave-valore NCache da MongoDB.
Raccolta cache come elemento singolo
Memorizzazione nella cache di una raccolta di elementi come un singolo CacheItem torna utile quando gli articoli sono simili o rientrano nella stessa categoria. Ad esempio, supponiamo che il database della tua applicazione abbia un elenco di clienti sparsi in tutto il mondo ma desideri interrogare quelli che vivono in Germania (perché il tuo Einstein sempre preferito è dalla Germania). Si desidera che questa query restituisca tutti questi clienti sotto forma di un unico elenco in modo che questo elenco possa essere aggiunto alla cache. Ecco come lo fai:
1 2 3 4 5 6 7 |
var customersInGermany = mongoCollection.FindAsync(x => x.Country == 'Germany').GetAwaiter().GetResult().ToList(); if(customersInGermany > 0) { var expiration = new Expiration(ExpirationType.Absolute, TimeSpan.FromMinutes(5)); var cacheItem = new CacheItem(customersInGermany) { Expiration = expiration }; cache.Insert("CustomersInGernamy", cacheItem); } |
Elementi della raccolta della cache separatamente
Nel caso in cui desideri associare informazioni aggiuntive a ciascun elemento come tag, etichette nomee gruppi per semplificare il recupero dei dati, dovresti memorizzare nella cache ciascun elemento separatamente utilizzando identificatori univoci. In questo modo, puoi recuperare più elementi in base a un tag logico, ad esempio, tutti i clienti che vivono in Germania.
Per memorizzare nella cache tutti i clienti che vivono in Germania, puoi aggiungere il tag Customer:Country:Germany
con il set di dati della query. Ecco un esempio di come memorizzare nella cache tutti i clienti tedeschi con il tag "Germania".
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
var customersInGermany = mongoCollection.FindAsync(x => x.Country == 'Germany').GetAwaiter().GetResult().ToList(); if(customersInGermany > 0) { var expiration = new Expiration(ExpirationType.Absolute, TimeSpan.FromMinutes(5)); foreach (var customer in customersInGermany) { cacheItem = new CacheItem(customer) { Tags = new[] { new Tag("Customer:Country:Germany") }, Expiration = expiration }; cache.Add($"Customer:CustomerID:{customer.Id}", cacheItem); } } |
A questo punto, abbiamo discusso in dettaglio come destreggiarsi tra i dati tra la tua applicazione e MongoDB utilizzando NCache. Puoi dire quanto sia facile accedere e manipolare i dati eseguendo Operazioni CRUD su tutto a causa di NCache. Lascia che ora ti porti in un breve tour di come NCache porta efficienza al piatto; la ciliegina sulla torta se puoi.
Ecco alcune delle caratteristiche che NCache fornisce per migliorare le prestazioni della tua applicazione di e-commerce che utilizza MongoDB.
NCache Dettagli Sincronizza la cache con il database NCache NoSql Datastore
Elimina i costi di serializzazione con la cache serializzata JSON
MongoDB memorizza i dati sotto forma di JSON binario (BSON), che è la serializzazione con codifica binaria di documenti simili a JSON. Questo funziona perfettamente con NCache in quanto supporta il Serializzazione JSON di oggetti. Questo MongoDB-NCache la collaborazione non solo migliora i tempi di prestazione dell'applicazione prevenendo la necessità di serializzare/deserializzare i dati, ma sostiene anche l'accuratezza dei dati.
1 2 3 4 5 |
var response = mongoCollection.FindAsync<Customer>(x => x.Id == "EINSTEIN").GetAwaiter().GetResult().ToList<Customer>(); Customer customer = (Customer)response.FirstOrDefault(); JObject customerJson = JObject.Parse(JsonSerializer.Serialize(customer)); cache.Insert($"Customer:CustomerID:{customer.Id}", customerJson); customer = cache.Get<Customer>($"Customer:CustomerID:EINSTEIN "); |
Fornitori di origini dati per l'ottimizzazione delle risorse
NCache fornisce Fornitori di origini dati per garantire un unico punto di ingresso nel livello di accesso ai dati della tua applicazione; il punto di ingresso è la tua cache. Nel caso in cui i dati non siano disponibili nella cache, a Leggi tutto il provider è responsabile dell'accesso al database, della ricerca e del recupero dei dati richiesti, della memorizzazione nella cache per un uso futuro e della presentazione all'applicazione.
1 |
var customer = cache.Get<Customer>( "EINSTEIN", new ReadThruOptions(ReadMode.ReadThru, "mongoDBReadThroughProvider")); |
Allo stesso modo, hai un Scrivere attraverso provider per quando si desidera eseguire un'operazione di scrittura sul database. Devi semplicemente eseguire l'operazione richiesta sulla cache e la cache scriverà automaticamente i dati nel database per te. Aggiungiamo "Einstein 2" nella cache in modo che aggiunga la versione 2.0 del tuo cliente preferito nel database utilizzando WriteThru
.
1 2 3 4 |
Customer customer = new Customer(); customer.Id = "EINSTEIN2"; ... cache.Insert(customer.Id,new CacheItem(customer),new WriteThruOptions(WriteMode.WriteThru,"mongoDBWriteThroughProvider"); |
NCache Dettagli Sincronizza la cache con il database NCache NoSql Datastore
Interroga i dati della cache
Quando si usa NCache come livello di memorizzazione nella cache intermedio tra la tua applicazione .NET e MongoDB, NCache ti offre la possibilità di cercare i dati memorizzati nella cache indicizzati tramite query. L'esecuzione di query sui dati della cache in memoria riduce direttamente il costo di viaggio che una query dovrebbe normalmente assumere su una rete.
Un frammento di codice di esempio che illustra l'uso di query sui dati indicizzati in NCache è mostrato qui:
1 2 3 4 5 6 7 8 9 10 11 12 |
string query = "SELECT * FROM Models.Customer WHERE Country == ?"; var queryCommand = new QueryCommand (query); queryCommand.Parameters.Add("Country", "Germany"); ICacheReader reader = cache.SearchService.ExecuteReader(queryCommand); if (reader.FieldCount > 0) { while (reader.Read()) { string result = reader.GetValue("ContactName"); // Perform operations } } |
Concludendo tutto
Considerando tutto il funzionalità e caratteristiche che NCache ti offre, è lecito concludere che non si può trovare una corrispondenza migliore di NCache memorizzare nella cache MongoDB. Ecco perché. MongoDB si trova lontano dalla tua applicazione; hai bisogno di una soluzione che rimanga vicina per aumentare le prestazioni: NCache lo prevede essendo in memoria. Hai bisogno di una soluzione che ti permetta di aggiungere un numero qualsiasi di server in fase di esecuzione: scalabile in modo lineare NCache te lo porta. Stai cercando una soluzione flessibile che riequilibri automaticamente i tuoi dati in modo dinamico: NCache fa esattamente questo plus senza alcuna interferenza del cliente.
NCache offre troppo sotto forma di prestazioni, riduzione dei costi, flessibilità, scalabilità, quindi cos'altro stai cercando? Vai a prendere NCache e divertiti con la memorizzazione nella cache!