ARTIGOS

Cache de objetos

Você já deve ter passado por algum problema de desempenho! Quem nunca passou. Aquele monte de SQL complexo para lá e para cá, análises de queries sem fim, você tentando otimizar o máximo possível, resumindo queries, eliminando outras, criando índices, e mesmo assim o programa está lento. Bancos de dados são excelentes quando se trata de armazenamento de dados, mas são lentos quando comparados com a velocidade da memória RAM.
  
Neste artigo falaremos em como acelerar o desempenho de uma aplicação mantendo objetos de negócio em memória. Esta estratégia já foi aplicada em aplicações críticas em grandes organizações e mostrou ganhos de até 100% no desempenho de rotinas complexas. Vamos ver como aplicar.

----

## Requerimentos
  
O PHP tem um recurso padrão para trabalhar com cache de informações, este recurso vem desabilitado por padrão. Mas para ligar é muito simples.

Em primeiro lugar é preciso ter o APC instalado:

```bash
sudo apt-get install php-apcu

# As configurações do servidor devem ser recarregadas
sudo service apache2 reload
```

E em seguida, já é possível escrever e ler informações diretamente na memória RAM do servidor. É importante lembrar que você deve criar um controle no carregamento de objetos que se a informação estiver em memória você deve usar ela, caso contrario será necessário carregar as informações do banco de dados e depois adicioná-las na memória.

## Funcionamento do CACHE

Em uma aplicação típica o programa carrega as informações do banco de dados sob demanda, ou seja quando necessário ele faz uma consulta ao banco e retornar com os dados solicitados. Ao trabalhar com cache esse fluxo se torna um pouco mais complexo.

A imagem a seguir demonstra uma como uma aplicação pode usar o APCache para extrair um maior desempenho:

![Funcionamento do cache](resources/posts/cache/images/1.png)

Como mencionado anteriormente uma aplicação típica solicita informações ao banco de dados `(a)` e ele as retorna `(b)`. Adicionando o cache nessa lógica as coisas mudam, por ser mais rápido sempre devemos verificar se as infrmações que desejamos não está em memória.

Sempre que um objeto for requisitado por meio de uma instanciação, primeiro devemos verificar se o objeto não está em memória `(d)` Caso encontrado, ele é disponibilizado imediatamente para a aplicação `(c)`. Caso ele não esteja na memória RAM, então ele é carregado do banco de dados `(b)`, e gravado na memória RAM `(d)`, para então ser disponibilizado para a aplicação.

Em resumo podemos observar que os dados organicamente são armazenados na memória RAM, conforme diferentes acessos de objetos que ainda não foram instanciados eles são adicionados a memória. Embora seja possível carregar todos os objetos na memória de ante-mão não entraremos em detalhes desta operação.

---

Até agora entendemos que devemos procurar os objetos primeiramente na memória da aplicação caso as informações não estejam lá, iremos ao banco de dados e popularemos a memória para que uma segunda chamada encontra as informações de uma maneira mais rápida. Essa mesma maneira de pensar deve ser aplicada a gravação de registros, sejam eles novos ou edições.

Sempre que  um registro for gravado no banco de dados, ele deve ser gravado também na memória RAM, assim como uma edição, pois se a edição for feita apenas no banco de dados quem utilizar a memória pode estar trabalhando com uma informação defasada.

---

## Como saber se o cache está habilitado

> Primeiro você deve ter todos os requerimentos habilitados.

Para saber se o seu PHP está com a extensão de cache habilitada basta executar o seguinte código:

```php
echo extension_loaded('apcu');
```

Retornos:

`TRUE` → a extensão está habilitada
`FALSE` → a extensão está desabilitada

---

## Como gravar informações na memória

A instrução que grava informações é:

```php
apcu_store($chave, $valor);
```

Portanto podemos gravar informações como:

```php
$user = new User;
apcu_store('1', $user);
```

---

## Como obter informações da memória

A instrução que lê as informações é :

```php
apcu_fetch($chave)
```

Portanto depois de gravar podemos obter informações assim:

```php
apcu_fetch('1')
```

## Performance

### Carregamento típico

Nesta seção mostraremos a diferença de performance entre o carregamento típico de informações do banco de dados *versus* cache.

Abaixo os códigos usados no carregamento típico:

**Classe de objeto**

A classe `User` lê a informação de um arquivo local simulando a leitura de um banco de dados.

```php
<?php

class User
{
	function __construct()
	{
		$a = file_get_contents('user.txt');
		$this->name = $a;
	}
}

```

**Classe de controle**

```php
<?php
require_once 'User.php';

$user = new User;
```

Para que a diferença de performance fique mais evidente colocaremos a instância do objeto dentro de um loop. Da seguinte maneira:

```php
<?php
require_once 'User.php';

for ($i=0; $i < 1000000; $i++)
{ 
	$user = new User;	
}
```

Para carregar 1000000 vezes o objeto User o script leva em média **8 segundos**.

### Carregamento com cache

Utilizaremos a mesma classe de objeto

```php
<?php

class User
{
	function __construct()
	{
		$a = file_get_contents('user.txt');
		$this->name = $a;
	}
}

```

**Classe de controle**

```php
// Carrega o usuário na primeira vez
$user = new User;
// Armazena o objeto na memória
apcu_store('1', $user);

// Dentro do loop sempre busca da memória
for ($i=0; $i < 1000000; $i++)
{ 
	$user = apcu_fetch('1');
}

```

Todas as execuções utilizando cache levaram menos de **1.2 segundos**.

Embora a implementação utilizada não use controles complexos é possível ter noção da brutal diferença de performance entre ler dados em disco contra informações na memória RAM.

É importante observar que se você for utilizar esse método em seus projetos, você crie os controle de uso de cache diretamente nas classes de modelo. Desta maneira, ao instanciar um objeto `new User` automaticamente seja checado a memória primeiramente. O mesmo vale para a gravação de objetos, deve-se sempre centralizar esse tipo de lógica.

ARTIGOS

Cache de objetos

COMENTE SOBRE