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');

Creating Sub-Namespaces

Sometimes you need to create context-dependent variations of data that should be cached. For example, the data used to render a dashboard page may be expensive to generate and unique per user, so you can't cache the same data for everyone.

In such cases, Symfony allows you to create different cache contexts using namespaces. A cache namespace is an arbitrary string that identifies a set of related cache items. All cache adapters provided by the component implement the NamespacedPoolInterface, which provides the withSubNamespace() method.

This method allows you to namespace cached items by transparently prefixing their keys:

1
2
3
4
5
6
7

$userCache = $cache->withSubNamespace(sprintf('user-%d', $user->getId()));

$userCache->get('dashboard_data', function (ItemInterface $item): string {
    $item->expiresAfter(3600);

    return '...';
});

In this example, the cache item uses the dashboard_data key, but it will be stored internally under a namespace based on the current user ID. This is handled automatically, so you don't need to manually prefix keys like user-27.dashboard_data.

There are no guidelines or restrictions on how to define cache namespaces. You can make them as granular or as generic as your application requires:

1
2
3
4
5
6
7
8

$localeCache = $cache->withSubNamespace($request->getLocale());

$flagCache = $cache->withSubNamespace(
    $featureToggle->isEnabled('new_checkout') ? 'checkout-v2' : 'checkout-v1'
);

$channel = $request->attributes->get('_route')?->startsWith('api_') ? 'api' : 'web';
$channelCache = $cache->withSubNamespace($channel);

There is no built-in way to invalidate caches by namespace. Instead, the recommended approach is to change the namespace itself. For this reason, it's common to include static or dynamic versioning data in the cache namespace:

1
2
3
4
5
6
7
8
9

// for simple applications, an incrementing static version number may be enough
$userCache = $cache->withSubNamespace(sprintf('v1-user-%d', $user->getId()));

// other applications may use dynamic versioning based on the date (e.g. monthly)
$userCache = $cache->withSubNamespace(sprintf('%s-user-%d', date('Ym'), $user->getId()));

// or even invalidate the cache when the user data changes
$checksum = hash('xxh128', $user->getUpdatedAt()->format(DATE_ATOM));
$userCache = $cache->withSubNamespace(sprintf('user-%d-%s', $user->getId(), $checksum));

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:

1
2
3
4
5
6
7
8
9

use Symfony\Component\Cache\Adapter\RedisAdapter;
use Symfony\Component\Cache\Marshaller\DefaultMarshaller;
use Symfony\Component\Cache\Marshaller\DeflateMarshaller;

$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