The Cache Component

Installation

1

$ composer require symfony/cache

Cache Contracts versus PSR-6

This component includes two different approaches to caching:

PSR-6 Caching:

A generic cache system, which involves cache "pools" and cache "items".

Cache Contracts:

A simpler yet more powerful way to cache values based on recomputation callbacks.

Cache Contracts

All adapters support the Cache Contracts. They contain only two methods: get() and delete(). There's no set() method because the get() method both gets and sets the cache values.

The first thing you need is to instantiate a cache adapter. The FilesystemAdapter is used in this example:

1
2
3

use Symfony\Component\Cache\Adapter\FilesystemAdapter;

$cache = new FilesystemAdapter();

Now you can retrieve and delete cached data using this object. The first argument of the get() method is a key, an arbitrary string that you associate to the cached value so you can retrieve it later. The second argument is a PHP callable which is executed when the key is not found in the cache to generate and return the value:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

use Symfony\Contracts\Cache\ItemInterface;

// The callable will only be executed on a cache miss.
$value = $cache->get('my_cache_key', function (ItemInterface $item): string {
    $item->expiresAfter(3600);

    // ... do some HTTP request or heavy computations
    $computedValue = 'foobar';

    return $computedValue;
});

echo $value; // 'foobar'

// ... and to remove the cache key
$cache->delete('my_cache_key');

1
2
3
4
5
6
7
8
9

use Symfony\Contracts\Cache\ItemInterface;

$beta = 1.0;
$value = $cache->get('my_cache_key', function (ItemInterface $item): string {
    $item->expiresAfter(3600);
    $item->tag(['tag_0', 'tag_1']);

    return '...';
}, $beta);

Generic Caching (PSR-6)

To use the generic PSR-6 Caching abilities, you'll need to learn its key concepts:

Item

A single unit of information stored as a key/value pair, where the key is the unique identifier of the information and the value is its contents; see the Cache Items article for more details.

Pool

A logical repository of cache items. All cache operations (saving items, looking for items, etc.) are performed through the pool. Applications can define as many pools as needed.

Adapter

It implements the actual caching mechanism to store the information in the filesystem, in a database, etc. The component provides several ready to use adapters for common caching backends (Redis, APCu, PDO, etc.)

Basic Usage (PSR-6)

This part of the component is an implementation of PSR-6, which means that its basic API is the same as defined in the document. Before starting to cache information, create the cache pool using any of the built-in adapters. For example, to create a filesystem-based cache, instantiate FilesystemAdapter:

1
2
3

use Symfony\Component\Cache\Adapter\FilesystemAdapter;

$cache = new FilesystemAdapter();

Now you can create, retrieve, update and delete items using this cache pool:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// create a new item by trying to get it from the cache
$productsCount = $cache->getItem('stats.products_count');

// assign a value to the item and save it
$productsCount->set(4711);
$cache->save($productsCount);

// retrieve the cache item
$productsCount = $cache->getItem('stats.products_count');
if (!$productsCount->isHit()) {
    // ... item does not exist in the cache
}
// retrieve the value stored by the item
$total = $productsCount->get();

// remove the cache item
$cache->deleteItem('stats.products_count');

For a list of all of the supported adapters, see Cache Pools and Supported Adapters.

Marshalling (Serializing) Data

Symfony uses marshallers (classes which implement MarshallerInterface) to process the cache items before storing them.

The DefaultMarshaller uses PHP's serialize() function by default, but you can optionally use the igbinary_serialize() function from the Igbinary extension:

use SymfonyComponentCacheAdapterRedisAdapter; use SymfonyComponentCacheDefaultMarshaller; use SymfonyComponentCacheDeflateMarshaller;

$marshaller = new DeflateMarshaller(new DefaultMarshaller()); // you can optionally use the Igbinary extension if you have it installed // $marshaller = new DeflateMarshaller(new DefaultMarshaller(useIgbinarySerialize: true));

$cache = new RedisAdapter(new Redis(), 'namespace', 0, $marshaller);

There are other marshallers that can encrypt or compress the data before storing it.

Advanced Usage