Estratégias de armazenamento em cache; write-through, read-through, lazy loading e TTL

Write-Through: Essa estratégia é utilizada quando precisamos de consistência dos dados entre o meu banco de dados primário (SQL) e o cache. Para sua implementação correta, precisamos adicionar os dados no cache em todos os métodos que houver uma chamada para escrita de dados relacionada ao banco de dados principal.

Por exemplo, se em uma aplicação eu tiver uma funcionalidade para cadastrar um cliente, após esse cadastro ser concluído, devemos adicionar esses dados também no cache.

Portanto, uma das vantagens de utilizar essa estratégia é que eu sempre terei os dados atualizados, podendo assim sempre fazer a consulta diretamente no meu cache, ao invés de ir ao banco de dados, assim melhorando o tempo de resposta de uma consulta.

Sempre teremos os dados atualizados no cache e não iremos ter eventuais inconsistências entre cache e base de dados.
Quando precisarmos realizar uma consulta, podemos ir direto no cache ao invés de ir no banco de dados, resultando assim em um tempo reduzido para consultas e menor tráfego de acesso ao meu banco de dados.

Umas das desvantagem da utilização do padrão write-though, é o crescimento rápido do armazenamento dos dados em cache, já que se você adicionar no cache dados de toda e qualquer escrita do banco de dados primário, os dados menos acessados poderão ocupar muito espaço, assim inflando o armazenamento.
Adicionar uma TTL e uma boa estratégia de lazy loading, poderá contornar esse problema acima.

function insertDataOnDatabase() {
  // add logic of the insertion 
}

function insertDataOnCacheDatabase() {
  // add logic of the insertion
}

function updateClientOnDatabase() {
  // add logic for update
}

function updateClientOnCacheDatabase() {
  // add logic for update
}


function insertNewClient() {
  //should insert data into primary database
  insertDataOnDatabase();

  //insert data into database cache
  insertDataOnCacheDatabase();
}

function updateClient() {

  //should update client into primary database
  updateClientOnDatabase();

  //update client into database cache
  updateClientOnCacheDatabase();

}

Lazy Loading: Essa estratégia é utilizada quando queremos adicionar aqueles dados que são mais acessados nas aplicações. Para isso temos que implementar essa estratégia da seguinte forma:

1. O usuário solicita os dados de uma aplicação.

2. A aplicação vai primeiro consultar os dados no cache.

3. Se esses dados não existirem, a aplicação vai consultar esses dados no banco.

4. Em seguida os dados serão adicionados no armazenamento do cache.

Se em uma segunda vez o usuário solicitar esses mesmos dados, não precisamos buscar no banco de dados primário, agora eu busco diretamente no meu cache. Trazendo assim agilidade na consulta dos dados.

Vantagens:

• A aplicação só irá salvar os dados que realmente utilizamos.

• Agilidade na hora da consulta dos dados.

• Menos acessos ao meu banco de dados primário.

Desvantagens:

• Se o dado não existir no cache, tenho que passar por 4 passos (conforme listados acima) até retornar os dados ao usuário, gerando assim uma demora maior para retorná-los. Para evitar que todos esses passos sejam executados em sequência, atualize os dados do cache de maneira assíncrona.

• Dados inconsistentes no cache. Como o cache só irá ser atualizado quando houver alguma consulta, e se por algum momento esse dado ser atualizado no banco e não ser atualizado no cache, isso gerará uma inconsistência entre banco de dados primário e cache. Se você precisa garantir a consistência de dados entre cache e banco de dados primário, implemente também a estratégia de write-through. Porém se a inconsistência não for um problema, siga em frente com essa estratégia sem maiores problemas.
  

function findDataOnDatabase() {
  // add logic of the insertion 
}

function insertDataOnCacheDatabase() {
  // add logic of the insertion
}

function updateClientOnCacheDatabase() {
  // add logic for update
}

function findDataOnCacheDatabase() {
  // add logic for search 
}


function findClient() {

  const client = findDataOnCacheDatabase()

  if(client === null) {

    const dataOfClient = findDataOnDatabase();

    insertDataOnCacheDatabase();

    return dataOfClient;
  }

  return client;

}

Referências

• Caching patterns

• Introduction to database caching

• Cache Strategies