Read-through, Write-through, Write-behind em NCache

NCache é um cache distribuído na memória para .NET extremamente rápido e escalonável que armazena dados de aplicativos em cache para reduzir viagens dispendiosas ao banco de dados. Você pode usar NCache para remover gargalos de desempenho associados ao armazenamento de dados e à escalabilidade do banco de dados.

A maneira mais comum de usar esse cache é permitir que seu aplicativo leia dados do seu banco de dados/fonte de dados e, em seguida, armazene-os em cache. Depois disso, quando seu aplicativo atualizar esses dados em seu banco de dados, ele também atualizará o cache para garantir que ele esteja sincronizado com o banco de dados.

Além disso, NCache fornece outro mecanismo muito poderoso para leitura e gravação de dados chamado Provedores de fonte de dados (leitura/gravação/gravação por trás) para permitir NCache ler e gravar dados do seu banco de dados.

Existem três maneiras de usar NCache nesse contexto:

1. Leia: você desenvolve um manipulador de leitura que reside e é executado em todos os servidores de cache do cluster. Então, quando seu aplicativo buscar dados do cache, NCache chama o manipulador de leitura para ler esses dados de sua fonte de dados se esses dados ainda não estiverem presentes no cache.
2. Gravação (sincronização): você desenvolve um Manipulador Write-through que também reside e é executado em todos os servidores de cache no cluster. E, quando seu aplicativo atualiza dados no cache, NCache primeiro atualiza o cache e depois chama o manipulador Write-though para atualizar imediatamente seu banco de dados com ele também. E seu aplicativo também espera até que os dados sejam atualizados no banco de dados.
3. Write-behind (assíncrono): se você não quiser que seu aplicativo espere até que o manipulador Write-through conclua a atualização dos dados no banco de dados, você pode escolher a opção Write-behind onde NCache atualiza seu banco de dados de forma assíncrona e seu aplicativo não precisa esperar pela atualização do banco de dados. Isso acelera seu aplicativo, pois as atualizações do banco de dados geralmente são muito mais lentas que as atualizações do cache.

Benefícios do Read-through / Write-through / Write-behind

Aqui estão alguns benefícios de usar Read-through, Write-through e Write-behind em NCache.

1. Melhor desempenho de gravação com Write-behind: A atualização do seu banco de dados geralmente é muito mais lenta do que a atualização do cache. Quando você usa Write-behind, seu aplicativo apenas atualiza o cache e segue em frente enquanto NCache atualiza seu banco de dados de forma assíncrona. Isso melhora bastante o desempenho do seu aplicativo.
2. Mais escalabilidade de banco de dados com limitação de gravação por trás: Se o seu aplicativo estiver atualizando o banco de dados com bastante frequência, é provável que ele engasgue. Mas, se você ativar a otimização com Write-behind, então NCache mantém seus dados atualizados no cache com replicação e atualiza seu banco de dados lentamente. Isso alivia muita pressão do seu banco de dados.
3. Atualizar automaticamente o cache na expiração: Se você desenvolveu um manipulador de leitura, poderá ativar a atualização automática na expiração com NCache. Dessa forma, sempre que algum item em cache expirar, em vez de removê-lo do cache, NCache chama o manipulador de leitura para recarregar uma nova cópia da sua fonte de dados.
4. Atualizar automaticamente o cache nas alterações do banco de dados: Se você desenvolveu um manipulador de leitura, poderá ativar a atualização automática na Dependência SQL/Dependência Oracle com NCache. Dessa forma, sempre que os dados correspondentes no banco de dados forem alterados, em vez de remover o item em cache do cache, NCache chama o manipulador de leitura para recarregar uma nova cópia do seu banco de dados.

Destaques dos recursos

Aqui estão alguns destaques de Read-through, Write-through e Write-behind em NCache.

1. Código do lado do servidor (.NET ou Java): Você pode desenvolver seus manipuladores de leitura/gravação com .NET ou Java. Há uma interface para cada manipulador que você desenvolve e implanta seu código em todos os servidores de cache do cluster. NCache é capaz de chamá-los em tempo de execução quando necessário. Quaisquer manipuladores desenvolvidos em .NET são chamados nativamente por NCache já que também é desenvolvido em .NET. Porém, Handlers desenvolvidos em Java são chamados por NCache através da interface nativa Java (JNI).
2. Vários manipuladores de leitura/gravação: Você pode desenvolver vários manipuladores de leitura e gravação e registrá-los no NCache. Nesse caso, todos eles são nomeados e seu aplicativo pode solicitar qualquer um deles especificando o nome.
3. Manipulador de leitura/gravação padrão: Se você tiver vários manipuladores registrados como manipuladores nomeados, então NCache permite que você selecione uma delas como opções padrão. Este manipulador padrão é usado quando seu aplicativo não especifica um nome de manipulador.
4. Destaques de leitura
   1. Leitura forçada: NCache fornece uma opção onde você pode dizer para usar a leitura mesmo se o item existir no cache (normalmente, a leitura só é chamada quando um item não é encontrado no cache). Isso permite que você atualize este item do seu banco de dados se achar que os dados podem ter sido alterados lá.
   2. Leitura em massa: NCache fornece uma API Bulk Get que permite que seu aplicativo forneça uma lista de chaves com as quais você pode buscar dados do cache.
   3. Leitura de Estruturas de Dados (Contador, Dicionário, Lista, Fila, Conjunto): NCache fornece ao seu aplicativo a capacidade de buscar qualquer estrutura de dados e NCache chama um manipulador Read-through para buscar esses dados do seu banco de dados.
5. Destaques de gravação
   1. Remover gravação de itens: NCache também fornece ao seu aplicativo a API Remove, que permite usar uma chave para remover um item do cache e, em seguida, da fonte de dados.
   2. Gravação de itens de remoção em massa: NCache também fornece uma API de remoção em massa que permite que seu aplicativo forneça uma lista de chaves para remover do cache e da fonte de dados em massa.
   3. Gravação de adição/atualização em massa: NCache fornece uma API de adição/atualização em massa que permite que seu aplicativo forneça uma lista de chaves e seus valores para adicionar/atualizar o cache em massa. Write-through também funciona nessa situação e adiciona/atualiza seu banco de dados/fonte de dados com esses itens em massa.
   4. Write-through de estruturas de dados (contador, dicionário, lista, fila e conjunto): NCache fornece a capacidade de seu aplicativo atualizar qualquer estrutura de dados e NCache chama um manipulador Write-through para atualizar seu banco de dados com as alterações.
   5. Adicionar/atualizar/remover gravação assíncrona: NCache A API fornece adição/inserção/remoção assíncrona. Write-through oferece suporte a essa API e é invocado sempre que seu aplicativo faz essa chamada de API. Aqui. Write-through pressupõe que seu aplicativo está aguardando a conclusão da operação e que o fato de ser assíncrono só é reconhecido no nível da API do cliente.
6. Destaques de gravação posterior
   1. Fila de operações assíncronas replicadas (alta disponibilidade): Write-behind aceita a solicitação do cliente para atualizar o cache e atualiza imediatamente o cache, mas coloca a atualização do banco de dados na fila para execução assíncrona posteriormente. Essa fila é sempre replicada para mais de um servidor de cache, dependendo da topologia de cache, para garantir que essas operações nunca sejam perdidas se algum servidor de cache ficar inativo repentinamente.
   2. Throttling: Você pode especificar um nível de limitação para operações assíncronas de gravação por trás. Isso permite que você os espalhe. O nível de limitação padrão é 500 operações/seg.
   3. Modos write-behind (sem lote ou em lote): O modo Não Lote significa que cada operação na fila Write-behind é executada separadamente, enquanto no modo Lote você agrupa várias operações e as executa coletivamente.
   4. Atraso de operação do lote: Você pode especificar um atraso entre duas operações em modo lote. Isso permite que você desacelere as atualizações do banco de dados, se desejar.
   5. Fila de operações com falha: Como o Write-behind executa todas as operações de forma assíncrona quando uma operação falha, NCache pode colocá-lo na fila de operações com falha para que possa ser executado novamente sem interferir em novas operações que não falharam. Você pode especificar um tamanho máximo e despejo.
7. Monitore contadores write-through/write-behind: NCache fornece um conjunto avançado de contadores com os quais você pode monitorar o que está acontecendo em Write-through/Write-behind. Esses contadores estão disponíveis no NCache Monitor, ferramenta Windows PerfMon, contadores SNMP, Prometheus e Grafana.

Interface de código de leitura/gravação

Desenvolver código para manipuladores de leitura e gravação é um processo simples. Abaixo estão exemplos de interfaces para ambos.

• . NET
• Java

public interface IReadThruProvider
{
	void Init(IDictionary parameters, string cacheId);
	ProviderCacheItem LoadFromSource(string key);
	IDictionary<string, ProviderCacheItem> LoadFromSource(ICollection<string> keys);
	ProviderDataTypeItem<IEnumerable> LoadDataTypeFromSource(string key, DistributedDataType dataType);
	void Dispose();
}

public interface ReadThruProvider extends java.lang.AutoCloseable
{
	void init(java.util.Map<java.lang.String,java.lang.String> parameters, java.lang.String cacheId) throws java.lang.Exception;
	ProviderCacheItem loadFromSource(java.lang.String key) throws java.lang.Exception;
	java.util.Map<java.lang.String,ProviderCacheItem> loadFromSource(java.util.Collection<java.lang.String> keys) throws java.lang.Exception;
	ProviderDataStructureItem loadDataStructureFromSource(java.lang.String key, DistributedDataStructureType distributedDataStructureType) throws java.lang.Exception;
}

• . NET
• Java

public interface IWriteThruProvider
{
	void Init(IDictionary parameters, string cacheId);
	OperationResult WriteToDataSource(WriteOperation operation);
	ICollection<OperationResult> WriteToDataSource(ICollection<WriteOperation> operations);
	ICollection<OperationResult> WriteToDataSource(ICollection<DataTypeWriteOperation> dataTypeWriteOperations);
	void Dispose();
}

public interface WriteThruProvider extends java.lang.AutoCloseable
{
	void init(java.util.Map<java.lang.String,java.lang.String> parameters, java.lang.String cacheId) throws java.lang.Exception;
	OperationResult writeToDataSource(WriteOperation operation) throws java.lang.Exception;
	java.util.Collection<OperationResult> writeToDataSource(java.util.Collection<WriteOperation> operations) throws java.lang.Exception;
	java.util.Collection<OperationResult> writeDataStructureToDataSource(java.util.Collection<DataStructureWriteOperation< dataStructureWriteOperations) throws java.lang.Exception;
}