Cache

Warning: You are browsing the documentation for Symfony 3.x, which is no longer maintained.

Read the updated version of this page for Symfony 7.1 (the current stable version).

Using cache is a great way of making your application run quicker. The Symfony cache component is shipped with many adapters to different storages. Every adapter is developed for high performance.

The following example shows a typical usage of the cache:

1
2
3
4
5
6
7
8
9
if (!$cache->has('my_cache_key')) {
    // ... do some HTTP request or heavy computations
    $cache->set('my_cache_key', 'foobar', 3600);
}

echo $cache->get('my_cache_key'); // 'foobar'

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

Symfony supports PSR-6 and PSR-16 cache interfaces. You can read more about these at the component documentation.

Configuring Cache with FrameworkBundle

When configuring the cache component there are a few concepts you should know of:

Pool
This is a service that you will interact with. Each pool will always have its own namespace and cache items. There is never a conflict between pools.
Adapter
An adapter is a template that you use to create Pools.
Provider
A provider is a service that some adapters are using to connect to the storage. Redis and Memcached are example of such adapters. If a DSN is used as the provider then a service is automatically created.

There are two pools that are always enabled by default. They are cache.app and cache.system. The system cache is used for things like annotations, serializer, and validation. The cache.app can be used in your code. You can configure which adapter (template) they use by using the app and system key like:

1
2
3
4
5
# app/config/config.yml
framework:
    cache:
        app: cache.adapter.filesystem
        system: cache.adapter.system

The Cache component comes with a series of adapters already created:

Some of these adapters could be configured via shortcuts. Using these shortcuts will create pool with service id of cache.[type]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# app/config/config.yml
framework:
    cache:
        directory: '%kernel.cache_dir%/pools' # Only used with cache.adapter.filesystem

        # service: cache.doctrine
        default_doctrine_provider: 'app.doctrine_cache'
        # service: cache.psr6
        default_psr6_provider: 'app.my_psr6_service'
        # service: cache.redis
        default_redis_provider: 'redis://localhost'
        # service: cache.memcached
        default_memcached_provider: 'memcached://localhost'
        # service: cache.pdo
        default_pdo_provider: 'doctrine.dbal.default_connection'

Creating Custom Pools

You can also create more customized pools. All you need is an adapter:

1
2
3
4
5
6
7
8
9
10
11
12
# app/config/config.yml
framework:
    cache:
        default_memcached_provider: 'memcached://localhost'
        pools:
            my_cache_pool:
                provider: cache.adapter.filesystem
            cache.acme:
                adapter: cache.adapter.memcached
            cache.foobar:
                adapter: cache.adapter.memcached
                provider: 'memcached://user:password@example.com'

The configuration above will create 3 services: my_cache_pool, cache.acme and cache.foobar. The my_cache_pool pool is using the filesystem adapter and the other two are using the MemcachedAdapter. The cache.acme pool is using the Memcached server on localhost and cache.foobar is using the Memcached server at example.com.

For advanced configurations it could sometimes be useful to use a pool as an adapter.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# app/config/config.yml
framework:
    cache:
        app: my_configured_app_cache
        pools:
            my_cache_pool:
                adapter: cache.adapter.memcached
                provider: 'memcached://user:password@example.com'
            cache.short_cache:
                adapter: my_cache_pool
                default_lifetime: 60
            cache.long_cache:
                adapter: my_cache_pool
                default_lifetime: 604800
            my_configured_app_cache:
                # "cache.adapter.filesystem" is the default for "cache.app"
                adapter: cache.adapter.filesystem
                default_lifetime: 3600

Custom Provider Options

Some providers have specific options that can be configured. The RedisAdapter allows you to create providers with option timeout, retry_interval. etc. To use these options with non-default values you need to create your own \Redis provider and use that when configuring the pool.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# app/config/config.yml
framework:
    cache:
        pools:
            cache.my_redis:
                adapter: cache.adapter.redis
                provider: app.my_custom_redis_provider

services:
    app.my_custom_redis_provider:
        class: \Redis
        factory: ['Symfony\Component\Cache\Adapter\RedisAdapter', 'createConnection']
        arguments:
            - 'redis://localhost'
            - { retry_interval: 2, timeout: 10 }

Creating a Cache Chain

Different cache adapters have different strengths and weaknesses. Some might be really quick but optimized to store small items and some may be able to contain a lot of data but are quite slow. To get the best of both worlds you may use a chain of adapters.

A cache chain combines several cache pools into a single one. When storing an item in a cache chain, Symfony stores it in all pools sequentially. When retrieving an item, Symfony tries to get it from the first pool. If it's not found, it tries the next pools until the item is found or an exception is thrown. Because of this behavior, it's recommended to define the adapters in the chain in order from the fastest to the slowest.

If an error happens when storing an item in a pool, Symfony stores it in the other pools and no exception is thrown. Later, when the item is retrieved, Symfony stores the item automatically in all the missing pools.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# app/config/config.yml
framework:
    cache:
        pools:
            my_cache_pool:
                adapter: cache.adapter.psr6
                provider: app.my_cache_chain_adapter
            cache.my_redis:
                adapter: cache.adapter.redis
                provider: 'redis://user:password@example.com'
            cache.apcu:
                adapter: cache.adapter.apcu
            cache.array:
                adapter: cache.adapter.filesystem


services:
    app.my_cache_chain_adapter:
        class: Symfony\Component\Cache\Adapter\ChainAdapter
        arguments:
            - ['@cache.array', '@cache.apcu', '@cache.my_redis']
            - 31536000 # One year

Note

In this configuration the my_cache_pool pool is using the cache.adapter.psr6 adapter and the app.my_cache_chain_adapter service as a provider. That is because ChainAdapter does not support the cache.pool tag. So it is decorated with the ProxyAdapter.

Clearing the Cache

To clear the cache you can use the bin/console cache:pool:clear [pool] command. That will remove all the entries from your storage and you will have to recalculate all values. You can also group your pools into "cache clearers". There are 3 cache clearers by default:

  • cache.global_clearer
  • cache.system_clearer
  • cache.app_clearer

The global clearer clears all the cache in every pool. The system cache clearer is used in the bin/console cache:clear command. The app clearer is the default clearer.

Clear one pool:

1
$ php bin/console cache:pool:clear my_cache_pool

Clear all custom pools:

1
$ php bin/console cache:pool:clear cache.app_clearer

Clear all caches everywhere:

1
$ php bin/console cache:pool:clear cache.global_clearer
This work, including the code samples, is licensed under a Creative Commons BY-SA 3.0 license.
TOC
    Version