# Caching

Queuety indeholder et cachelag, der reducerer databaseforespørgsler på ofte benyttede kodeveje, f.eks. kontroller af køpauser, tællere for hastighedsbegrænsning, opslag af workflowtilstand og låsehandlinger. Cachen initialiseres automatisk, når du kalder `Queuety::init()`.

## Cachegrænseflade

Alle cachebackends implementerer `Queuety\Contracts\Cache`:

| Metode | Returnerer | Beskrivelse |
|---|---|---|
| `get( string $key )` | `mixed` | Hent en værdi. Returnerer `null`, hvis værdien ikke findes eller er udløbet. |
| `set( string $key, mixed $value, int $ttl = 0 )` | `void` | Gem en værdi. TTL på 0 betyder, at værdien ikke udløber. |
| `delete( string $key )` | `void` | Fjern en værdi. |
| `has( string $key )` | `bool` | Kontrollér, om en nøgle findes og ikke er udløbet. |
| `add( string $key, mixed $value, int $ttl = 0 )` | `bool` | Angiv kun en værdi, hvis nøglen ikke allerede findes (atomisk). Returnerer `true`, hvis værdien blev angivet. |
| `flush()` | `void` | Fjern alle elementer fra cachen. `ApcuCache::flush()` kalder `apcu_clear_cache()`, som rydder alle APCu-poster på serveren, ikke kun Queuety's. |

## Indbyggede backends

### MemoryCache (standard)

`Queuety\Cache\MemoryCache` er en arraybaseret cache pr. proces. Elementer gemmes i et PHP array og går tabt, når processen afsluttes. Dette er standardbackend, når APCu ikke er tilgængelig.

Den kræver ingen udvidelser, fungerer godt ved installationer med én worker og holder hver workerproces isoleret fra de andre.

### ApcuCache

`Queuety\Cache\ApcuCache` bruger APCu-udvidelsen til delt hukommelse på tværs af alle PHP-processer på samme server. Alle nøgler får automatisk præfikset `queuety:` for at undgå sammenfald med andre applikationer.

Denne backend kræver udvidelsen `php-apcu`, deler cacheposter mellem workers på samme server og gør `add()` ægte atomisk via `apcu_add()`.

## Automatisk registrering

`Queuety\Cache\CacheFactory` vælger automatisk den bedst tilgængelige backend:

Hvis `apcu_store()` findes, og `apcu_enabled()` returnerer `true`, bruger Queuety `ApcuCache`. Ellers falder den tilbage til `MemoryCache`. Dette sker i `Queuety::init()`, så standardadfærden kræver ingen ekstra konfiguration.

## Hvad der caches

Cachelaget bruges internt af flere undersystemer:

| Data | Formål |
|---|---|
| Køens pausetilstand | Undgår en databaseforespørgsel ved hver gentagelse af workerløkken |
| Tællere for hastighedsbegrænsning | Registrerer antal kørsler i hukommelsen i stedet for i databasen |
| Workflowtilstand | Reducerer antallet af læsninger under fremdrift i workflows med flere trin |
| Låsetilstand | Fremskynder kontrol af, om låse findes, for unikke jobs og mutex-middleware |

## TTL-konfiguration

Standard-TTL for cachen er 5 sekunder. Den gælder køens pausetilstand og tællere for hastighedsbegrænsning; status- og tilstandslæsninger for workflows caches i faste 2 sekunder, som konstanten ikke ændrer. Tilsidesæt standarden med konstanten `QUEUETY_CACHE_TTL` i din `wp-config.php`:

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

En lavere TTL betyder hyppigere databaseforespørgsler, men friskere data. En højere TTL reducerer belastningen på databasen, men giver mere forældede data. For de fleste installationer er standarden på 5 sekunder en god balance.

## Tilpasset cachebackend

Hvis du vil bruge en tilpasset cachebackend (Redis, Memcached eller en anden), skal du implementere grænsefladen `Contracts\Cache` og kalde `Queuety::set_cache()` fø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 );
```

Hvis `set_cache()` kaldes før `init()`, springes fabrikkens automatiske registrering helt over, og din tilpassede backend bruges.

## Adgang til cachen

Hent den aktive cacheinstans når som helst:

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

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

Dette returnerer den backend, der aktuelt er aktiv (MemoryCache, ApcuCache eller din tilpassede implementering).