Per applicazioni ad alta transazione con architetture complesse, lo scambio continuo di dati provoca un carico non uniforme e un ritardo nel throughput. Il perfezionamento dei dati è una grande sfida quando si tratta di applicazioni aziendali complesse e di grandi dimensioni. Per far fronte a ciò, l'elaborazione del flusso viene utilizzata per definire un particolare flusso di dati creando flussi di dati. Una tipica applicazione di flusso è costituita da diversi produttori che generano nuovi eventi e da un insieme di consumatori che elaborano questi eventi.
Una di queste applicazioni popolari è Pub/Sub, in cui gli editori immettono messaggi e gli abbonati ricevono i messaggi a cui si abbonano. Tuttavia, nell'elaborazione del flusso, Pub/Sub deve affrontare alcune limitazioni, ad esempio una volta che l'abbonato riceve il messaggio, l'applicazione non conserva più il messaggio. Quindi, in seguito, se un altro abbonato desidera i messaggi dell'editore, i messaggi precedenti non esistono. Inoltre, per i dati del flusso in entrata, il filtraggio dei dati avviene sul lato client (abbonato) e non sul server, rendendo complessa l'architettura dell'applicazione.
Per superare queste limitazioni di Pub/Sub, NCache viene fornito con un meccanismo efficiente di elaborazione dei dati sul lato server utilizzando le query continue. Le query continue consentono alle applicazioni di essere informate di tutte le modifiche che si verificano nei dati che risiedono nella cache, soddisfacendo determinati criteri. Questo blog ti aiuta a comprendere i vantaggi dell'utilizzo delle query continue nell'elaborazione del flusso con l'aiuto di una soluzione creata per l'elaborazione del flusso GitHub.
Utilizzo della query continua per l'elaborazione del flusso
La soluzione spiega un'applicazione di e-commerce, che elabora migliaia di clienti ogni giorno per i loro acquisti online. Se guardi il diagramma seguente, i clienti di tutti i tipi e categorie vengono aggiunti nell'applicazione. Per rendere efficiente l'elaborazione dei clienti, i clienti non filtrati vengono classificati e filtrati come clienti "Oro", "Argento" e "Bronzo" in base al numero dei loro ordini, utilizzando query continue.
Interrogazione continua consente alle applicazioni di ricevere notifiche quando un dato che soddisfa determinati criteri cambia all'interno della cache e i criteri vengono specificati utilizzando i comandi SQL. Ad esempio, se un'applicazione desidera contrassegnare i clienti con il numero maggiore di ordini come "Clienti Gold", tutto ciò che deve fare è registrare un criterio di comando SQL fornendo quindi una richiamata. Questo callback viene attivato su qualsiasi modifica che si verifica nel set di risultati che soddisfa i criteri. Una volta richiamata la richiamata, l'applicazione può classificare questi clienti come "Clienti Gold" utilizzando i tag.
Allo stesso modo, l'applicazione può creare più categorie registrando più CQ, ciascuno con i propri criteri e una richiamata. In questo modo l'applicazione ottiene solo i dati filtrati a cui è interessata. I dati filtrati possono quindi essere ulteriormente analizzati in base ai requisiti aziendali, ad esempio fornire sconti ai clienti di fascia alta in base alla categoria del cliente.
Gli eventi vengono attivati se nella cache viene eseguita una delle seguenti azioni di modifica dei dati:
- Aggiungere: Aggiunta di un nuovo elemento alla cache che soddisfi i criteri della query
- Aggiornare: Aggiornamento di un elemento esistente nel set di risultati della query.
- Rimuovere: Rimozione dell'elemento dalla cache o aggiornamento di qualsiasi elemento memorizzato nella cache in modo tale da causare la rimozione dell'elemento dal set di risultati della query.
Esaminiamo un rapido esempio di codice sull'utilizzo dell'elaborazione del flusso nella cache con query continua. In questo esempio viene eseguita una query continua sui dati in cui gli ordini superiori a 10 vengono aggiunti alla categoria “Clienti Gold”. Inoltre, viene attivato un evento su ogni elemento aggiunto al set di risultati della query.
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 Dettagli Interrogazione continua e Pub/Sub
La query continua conserva i dati che Pub/Sub non conserva
Ora i dati filtrati tramite query continua (per i clienti con ordini >10) sono contrassegnati come "Clienti Gold" e vengono aggiornati nella cache. Guarda il codice qui sotto per vedere come è fatto.
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 query continua mantiene i dati conservati nella cache anche dopo l'elaborazione. In questo modo, risolve il problema affrontato con Pub/Sub per i dati che emergono continuamente, ovvero che più applicazioni pubblicano i dati in NCache livello di messaggistica. Pertanto, più abbonati ricevono i dati e non dispongono di un'archiviazione dati affidabile poiché i messaggi vengono rimossi dal bus dei messaggi una volta ricevuti. I dati vengono archiviati dall'applicazione o aggiungendo una nuova origine dati che è uno scenario molto più complesso. La query continua d'altra parte, assicura che non vi sia alcuna perdita di dati, risparmiando così tutto lo sforzo extra di persistenza manuale dei dati.
NCache Dettagli Scaricare NCache Confronto edizione
La query continua consente il disaccoppiamento delle applicazioni tramite una potente filtrazione
Le applicazioni complesse di grandi dimensioni possono avere vari raggruppamenti in base alle loro architetture, ad esempio, con 10 applicazioni in esecuzione, due potrebbero avere a che fare con il set di dati dei clienti Gold mentre le altre due potrebbero avere a che fare con il set di dati dei clienti Silver. In questi casi si desidera una logica aziendale separata per ogni set di dati in cui i dati vengono filtrati in base alle esigenze di ciascuna applicazione per l'elaborazione del flusso. Pertanto, applicazioni così grandi e complesse devono essere disaccoppiate poiché la dipendenza delle applicazioni l'una dall'altra causa enormi colli di bottiglia delle prestazioni e una maggiore complessità delle applicazioni.
La query continua filtra in modo molto efficiente i dati delle tue applicazioni con l'aiuto di istruzioni SQL abbastanza sofisticate, quindi nessuna applicazione si sovrappone alle altre applicazioni. Questo disaccoppiamento diventa di grande utilità in un'architettura di microservizi in cui ogni servizio è in esecuzione su uno stack di applicazioni separato. Ogni microservizio ottiene ed elabora i propri dati senza causare alcuna dipendenza. Questo livello di filtraggio dei dati e disaccoppiamento delle applicazioni non può essere raggiunto utilizzando Pub/Sub.
La figura 2 mostra varie applicazioni client che gestiscono i rispettivi set di dati nell'architettura disaccoppiata utilizzando NCache interrogazioni continue.
Recupero dei dati utilizzando i tag
tag in NCache vengono aggiunti qualificatori per i dati utilizzati per classificare i dati in base ad essi. Per set di dati di grandi dimensioni come lo scenario menzionato, i tag sono davvero utili per recuperare dati rilevanti invece di cercare i dati nell'intera cache. Se un cliente rientra nella categoria "Clienti Gold", viene aggiunto un tag per un rapido recupero. Sulla base di queste categorie, ai clienti possono essere forniti vantaggi aggiuntivi come sconti, coupon ecc. NCache fornisce vari modi flessibili per recuperare i dati utilizzando i tag, spiegato in modo approfondito nella documentazione.
Ora esaminiamo l'esempio di codice dei tag associati ai "Clienti Gold". A questi clienti possono essere offerti coupon o servizi 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]); |
Dati cache in scadenza
NCache consente scadenza dei dati della cache che invalida i dati dopo un intervallo specifico e quindi li rimuove dalla cache a intervalli regolari.
NCache prevede due tipi di scadenze:
In caso di clienti, la scadenza viene aggiunta agli articoli che non rientrano in nessuna delle tre categorie ovvero Oro, Argento o Bronzo. Tutti gli altri clienti con ordini inferiori a 4 vengono aggiunti con un intervallo di tempo di scadenza e vengono rimossi dalla cache per non ulteriori analisi. Tuttavia, la scadenza di qualsiasi cliente appartenente a una delle categorie è impostata su Nessuno per mantenere i dati nella cache a meno che non vengano rimossi manualmente. Ecco come puoi aggiungere 15 secondi di scadenza a un cliente con meno di 4 ordini.
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); |
Perché usare NCache?
NCache is 100% .NET/.NET Core, soluzione di cache distribuita in memoria ed è stata leader nel mercato per molto tempo. È estremamente veloce e linearmente scalabile e rimuove in modo efficiente i colli di bottiglia delle prestazioni per l'applicazione memorizzando i dati nella cache. Ti fa risparmiare sui costi di rete riducendo i costosi viaggi di rete. NCache fornisce un ricco set di funzionalità come la query continua che rende l'analisi dei dati molto veloce ed efficiente insieme ad altre funzionalità per facilitare il flusso regolare della tua applicazione.