NCache, um cache distribuído na memória, mantém seus dados intactos em um armazenamento temporário para uma experiência mais rápida de operações de leitura e gravação. Nós vimos NCache fazer maravilhas com a velocidade quando se trata de executar operações no armazenamento em cache. No entanto, mantendo NCache sincronizado com a fonte de dados principal é um grande desafio quando se trata de consistência de dados. A fonte de dados pode ser qualquer banco de dados; no entanto, este blog é sobre como manter seu cache sincronizado com o PostgreSQL.
Duas cópias de dados separadas - um desafio
A pilha do seu aplicativo funciona com NCache como o cache reside como uma camada de cache entre o banco de dados e o aplicativo. Seu aplicativo está conectado diretamente ao cache, enviando todas as chamadas de operação diretamente para o cache, como leitura ou gravação. Vamos supor que outro usuário altere algo no banco de dados sem informar o cache. Agora, os dados no banco de dados são diferentes dos dados que residem no cache. As duas cópias separadas de dados resultam em inconsistência de dados, o que é um grande desafio.
NCache Adicionar ao carrinho NCache Docs Sincronizar cache com PostgreSQL
NCache Mantendo os dados em sincronia
Dado o desafio da inconsistência de dados, NCache desce com uma correção para ele, assim como todo o resto. O que você precisa fazer é sincronizar seu cache com o banco de dados usando NCache sincronização de banco de dados técnicas. O banco de dados discutido neste blog, como mencionado anteriormente, é o PostgreSQL – um banco de dados relacional de objeto de código aberto com um conjunto de recursos bem desenvolvido e alto desempenho e confiabilidade. Temos uma solução feita e carregada no GitHub em Sincronizando o Cache com o PostgreSQL que mostra como seu cache pode melhorar a escalabilidade e a consistência dos dados.
O diagrama abaixo mostra como NCache ajudá-lo a manter os dados sincronizados com seu banco de dados PostgreSQL.
Sincronizando NCache com banco de dados PostgreSQL
NCache permite manter seus dados sincronizados com o PostgreSQL usando NotificarDependência Extensível, que é uma técnica de sincronização fornecida por NCache para manter o cache e o banco de dados sincronizados. NotifyExtensibleDependency é usado para implementar a técnica de invalidação de dados usando o sistema de notificação de dependência PostgreSQL. A dependência do PostgreSQL é construída no mecanismo LISTEN/NOTIFY que é semelhante ao Modelo Pub/Sub.
Junto com a dependência de banco de dados, ReadThruProvider é usado para se comunicar diretamente com a fonte de dados. NCache chama o provedor para carregar dados da fonte de dados diretamente usando sua lógica personalizada. Isso mantém os dados sincronizados e atualizados para evitar problemas como dados obsoletos, além de fornecer escalabilidade aprimorada e operações de leitura mais rápidas.
Assim, os componentes básicos envolvidos são:
-
- NotificarExtensibleDependency: NCache registra com um canal específico chamando LISTEN dentro de NotifyExtensibleDependency
Initialize
método. No banco de dados, é invocada uma função TRIGGER que envia um Payload para o canal e ao atender, em caso de inconsistência de dados, os dados são removidos do cache. - ReadThruProvider: Este provedor obtém os dados atualizados automaticamente, diretamente do banco de dados mediante modificação de dados no banco de dados.
- NotificarExtensibleDependency: NCache registra com um canal específico chamando LISTEN dentro de NotifyExtensibleDependency
NCache Adicionar ao carrinho Leia Dependência baseada em notificação
Sincronize o cache usando NotifyExtensibleDependency
NotificarDependência Extensível é usado para invalidar os dados usando o mecanismo de Dependência PostgreSQL, que funciona no modelo de Mensagens do Pub/Sub e o modelo é chamado de Ouvir/Notificar. De acordo com esse mecanismo, qualquer atualização no banco de dados é passada para o cliente que está escutando em um canal específico por meio de um comando NOTIFY com uma carga adicional contendo as informações. O cliente em nosso caso específico é NCache e ao ser notificado sobre qualquer alteração no banco de dados o item correspondente é removido do cache.
Vejamos o código abaixo para ver como um item é adicionado com a dependência do PostgreSQL:
1 2 3 4 5 6 7 8 9 10 11 |
const string connectionString = "your-connection-string"; var customer = new Customer(); var cacheItem = new CacheItem(customer) { Dependency = new PostGreSQLDependency(connectionString, customer.customerid, "public", "customers", "customer_channel") }; var key = customer.customerid; var cache = CacheManager.GetCache("democache"); cache.Insert(key, cacheItem); |
No entanto, você precisa entender a implementação de PostgreSQLDependency
e o código abaixo ajudará. o Initialize
O método contém uma cadeia de conexão para se conectar ao banco de dados e se registra para notificação sobre qualquer modificação de dados nos dados específicos.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 |
public PostGreSQLDependency(string connectionString, string dependencyKey, string schema, string table, string channel) { _connectionString = connectionString.Trim(); _dependencyKey = dependencyKey.Trim(); _schema = schema.Trim(); _table = table.Trim(); _channel = channel.Trim(); } public override bool Initialize() { connection = new NpgsqlConnection(_connectionString); connection.Open(); ((NpgsqlConnection)connection).Notification += (o, e) => { var entity = JsonConvert.DeserializeObject(e.AdditionalInformation); if (entity.DependencyKey == _dependencyKey && entity.Table == _table && entity.Schema == _schema) { done = true; } }; using (var cmd = new NpgsqlCommand($"LISTEN {_channel};", (NpgsqlConnection)connection)) { cmd.ExecuteNonQuery(); } task = Task.Run(() => { while (true) { ((NpgsqlConnection)connection).Wait(); if (done) { break; } } this.DependencyChanged.Invoke(this); }); return true; } |
NCache Adicionar ao carrinho NCache Docs Sincronizar cache com PostgreSQL
Recarregar dados automaticamente usando Read-Through
Usando a dependência, sempre que os dados são modificados na fonte de dados, eles são limpos do cache. No entanto, ainda precisamos recarregar esses dados no cache e para isso NCache tem um recurso chamado Fonte de apoio. Fornecemos ao provedor Read-Through a liberdade de adicionar sua lógica personalizada na implementação. No caso especificado, o provedor Read-Through carrega dados do banco de dados PostgreSQL. Você precisa configurar o provedor Read-Through usando as ferramentas de gestão antes.
O uso de opções de ressincronização no provedor de leitura mantém os dados sincronizados com o banco de dados. No entanto, dentro do ProviderCacheItem
, o CacheItem tem dependência adicionada, o que significa que o novo item adicionado no cache vem com dependência já adicionada a ele. Isso economiza o esforço de adicionar dependência repetidamente. Olhe para a LoadFromSource
dentro do provedor Read-Through para ver a implementação:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
public ProviderCacheItem LoadFromSource(string key) { var query = $"SELECT customerid, address, country, city FROM customers WHERE customerid = '{key}'"; // Define a query returning a single row result set NpgsqlCommand command = new NpgsqlCommand(query, _connection as NpgsqlConnection); var reader = command.ExecuteReader(); ProviderCacheItem providerCacheItem = null; while (reader.Read()) { if (providerCacheItem == null) { var customer = new Customer() { customerid = reader[0] as string, address = reader[1] as string, country = reader[2] as string, city = reader[3] as string, }; providerCacheItem = new ProviderCacheItem(customer) { Dependency = new PostGreSQLDependency(_connectionString, customer.customerid, "public", "customers", "customer_channel"), ResyncOptions = new ResyncOptions(true) }; } } } |
Adicionando o item com leitura agora, basta carregar itens modificados diretamente no cache usando dependência de banco de dados. Portanto, seu cache permanece sincronizado com o banco de dados PostgreSQL e todos os seus problemas de dados obsoletos desaparecem.
Conclusão
Para colocar tudo no blog em termos simples, seu cache e banco de dados precisam permanecer sincronizados entre si. Se o cache não estiver ciente de quaisquer modificações feitas no banco de dados, seu aplicativo poderá continuar trabalhando e trabalhando com dados de cache obsoletos. Este problema é resolvido de forma muito eficiente com NCache Recurso de dependência do PostgreSQL. Existem muitos outros recursos interessantes que você pode ver simplesmente acessando NCache site do Network Development Group.
NCache Adicionar ao carrinho Comparação de edições NCache Baixar