# Caching

Queuety bevat een cachelaag die databasequery's vermindert op veelgebruikte paden, zoals controles voor het pauzeren van wachtrijen, tellers voor snelheidslimieten, opvragingen van workflowstatus en vergrendelingsbewerkingen. De cache wordt automatisch geïnitialiseerd wanneer je `Queuety::init()` aanroept.

## Cache-interface

Alle cachebackends implementeren `Queuety\Contracts\Cache`:

| Methode | Retourneert | Beschrijving |
|---|---|---|
| `get( string $key )` | `mixed` | Haalt een waarde op. Retourneert `null` als deze niet is gevonden of is verlopen. |
| `set( string $key, mixed $value, int $ttl = 0 )` | `void` | Slaat een waarde op. Een TTL van 0 betekent dat deze niet verloopt. |
| `delete( string $key )` | `void` | Verwijdert een waarde. |
| `has( string $key )` | `bool` | Controleert of een sleutel bestaat en niet is verlopen. |
| `add( string $key, mixed $value, int $ttl = 0 )` | `bool` | Stelt een waarde alleen in als de sleutel nog niet bestaat (atomair). Retourneert `true` als de waarde is ingesteld. |
| `flush()` | `void` | Verwijdert alle items uit de cache. `ApcuCache::flush()` roept `apcu_clear_cache()` aan, waarmee elke APCu-vermelding op de server wordt gewist, niet alleen die van Queuety. |

## Ingebouwde backends

### MemoryCache (standaard)

`Queuety\Cache\MemoryCache` is een cache op basis van een array per proces. Items worden opgeslagen in een PHP-array en gaan verloren wanneer het proces wordt beëindigd. Dit is de standaardbackend wanneer APCu niet beschikbaar is.

Er zijn geen extensies voor nodig, werkt goed voor implementaties met één worker en houdt elk workerproces gescheiden van de andere.

### ApcuCache

`Queuety\Cache\ApcuCache` gebruikt de APCu-extensie voor gedeeld geheugen tussen alle PHP-processen op dezelfde server. Aan alle sleutels wordt automatisch het voorvoegsel `queuety:` toegevoegd om botsingen met andere applicaties te voorkomen.

Deze backend vereist de extensie `php-apcu`, deelt cachevermeldingen tussen workers op dezelfde server en maakt `add()` echt atomair via `apcu_add()`.

## Automatische detectie

`Queuety\Cache\CacheFactory` kiest automatisch de beste beschikbare backend:

Als `apcu_store()` bestaat en `apcu_enabled()` `true` retourneert, gebruikt Queuety `ApcuCache`. Anders wordt teruggevallen op `MemoryCache`. Dit gebeurt binnen `Queuety::init()`, dus voor het standaardgedrag is geen extra configuratie nodig.

## Wat er wordt gecachet

De cachelaag wordt intern gebruikt door verschillende subsystemen:

| Gegevens | Doel |
|---|---|
| Wachtrijpauzestatus | Voorkomt een databasequery bij elke iteratie van de workerlus |
| Tellers voor snelheidslimieten | Houdt uitvoeringstellingen bij in het geheugen in plaats van in de database |
| Workflowstatus | Vermindert het aantal leesbewerkingen tijdens het doorlopen van workflows met meerdere stappen |
| Vergrendelingsstatus | Versnelt controles op het bestaan van vergrendelingen voor unieke taken en mutex-middleware |

## TTL-configuratie

De standaard-TTL van de cache is 5 seconden. Deze geldt voor de wachtrijpauzestatus en tellers voor snelheidslimieten; het lezen van de workflowstatus en -toestand wordt gedurende een vaste 2 seconden gecachet, wat niet door de constante wordt gewijzigd. Overschrijf de standaardwaarde met de constante `QUEUETY_CACHE_TTL` in uw `wp-config.php`:

```php
define( 'QUEUETY_CACHE_TTL', 10 ); // 10 seconds
```

Een lagere TTL betekent vaker databasequery's, maar actuelere gegevens. Een hogere TTL verlaagt de databasebelasting, maar zorgt ervoor dat gegevens langer verouderd kunnen zijn. Voor de meeste implementaties is de standaardwaarde van 5 seconden een goede balans.

## Aangepaste cachebackend

Om een aangepaste cachebackend te gebruiken (Redis, Memcached of iets anders), implementeert u de interface `Contracts\Cache` en roept u `Queuety::set_cache()` aan vóór `Queuety::init()`:

```php
use Queuety\Contracts\Cache;
use Queuety\Queuety;

class RedisCache implements Cache {
    public function get( string $key ): mixed { /* ... */ }
    public function set( string $key, mixed $value, int $ttl = 0 ): void { /* ... */ }
    public function delete( string $key ): void { /* ... */ }
    public function has( string $key ): bool { /* ... */ }
    public function add( string $key, mixed $value, int $ttl = 0 ): bool { /* ... */ }
    public function flush(): void { /* ... */ }
}

// Set the cache before init() so all subsystems use it.
Queuety::set_cache( new RedisCache() );
Queuety::init( $connection );
```

Als `set_cache()` vóór `init()` wordt aangeroepen, wordt de automatische detectie door de factory volledig overgeslagen en wordt uw aangepaste backend gebruikt.

## De cache openen

Haal op elk moment de actieve cache-instantie op:

```php
$cache = Queuety::cache();

$cache->set( 'my_key', 'my_value', 60 );
$value = $cache->get( 'my_key' );
```

Dit retourneert de backend die op dat moment actief is (MemoryCache, ApcuCache of uw eigen implementatie).