For files other than a Response object, max-age could be tune in .htaccess
# Requires mod_expires to be enabled.
<IfModule mod_expires.c>
# Enable expirations.
ExpiresActive On
# Cache all files for 2 weeks after access (A).
ExpiresDefault A1209600
<FilesMatch \.php$ >
# Do not allow PHP scripts to be cached unless they explicitly
# send cache headers themselves(...)
ExpiresActive Off
</FilesMatch>
</IfModule>
Before going any further
Unlike Drupal 7, cache is enable by default in Drupal8, so...
it is strongly recommended to disable it when coding
You just have to uncomment the following lines in settings.php
#Copy sites/example.settings.local.php to sites/default/settings.local.php
if (file_exists(__DIR__ . '/settings.local.php')) {
include __DIR__ . '/settings.local.php';
}
or use drupal console: drupal site:mode dev @see https://www.drupal.org/node/2598914
These cache metadata aggregate to form the whole page cache metadata
As seen before they are used to invalidate Dynamic Page Cache
Internal Page Cache is only invalidated by tags
External caches like Varnish could use X-Drupal-Cache-Tags HTTP headers
These headers are also useful for debugging
Here's a page with two blocks containing each a nodes list (cache tags are displayed between brackets, notice the bubbling)
Diagram by @berdir
Let's modify node n°5 and create a new sport node (n°7). These actions will invalidate cache tags (red)
Here in red all the content parts that should be rebuild, in green the ones that will come from Render caching
Code example: setting cache metadata on a Render Array
$config = \Drupal::config('system.site');
$current_user = \Drupal::currentUser();
$build = [
'#markup' => t('Hi, %name, welcome on @site!', [
'%name' => $current_user->getUsername(),
'@site' => $config->get('name'),
]),
'#cache' => [
'contexts' => [
'user', // So this block will be processed by #lazybuilding
],
'tags' => $config->getCacheTags(), // Same as 'tags' => ['config:system.site']
],
];
// Another way to add cache depency.
$renderer = \Drupal::service('renderer');
$renderer->addCacheableDependency(
$build,
\Drupal\user\Entity\User::load($current_user->id())
);
// Merge cache tags
$tags = Cache::mergeTags($conf_one->getCacheTags(),$conf_two->getCacheTags());
Objects that render content (like plugins) should implement
the CacheableDependencyInterface and its methods:
\Drupal\Core\Cache
public function getCacheContexts() {
return Cache::mergeContexts(
parent::getCacheContexts(),
['user.node_grants:view']
);
}
public function getCacheTags() {
return Cache::mergeTags(parent::getCacheTags(), ['node_list']);
}
public function getCacheMaxAge() {
return 0;
}
Drupal already handles all these cache mechanisms, so "everything is cool"
But you will certainly need to cache your own custom data, so here's the cache API
Static variables
Simple "caching" method using the fact that php static variables aren't destroyed at the end of a function execution
drupal_static() could still be used for procedural code
As for OO, don't forget that "services" are "singletons" and therefore their properties are persistents
Drupal cache Getter / Setter
function my_custom_data_processing();
// Define my cache key
$key = 'my_module' . ':' . __FUNCTION__;
// Does the cache exists ?
if ($cache = \Drupal::cache()->get($key)) {
$data = $cache->data;
}
// No cache: process the data and set the cache.
else {
$data = my_slow_data_process();
\Drupal::cache()->set($key, $data);
}
return $data;
}
// Add a cache lifetime to my cache (timestamp)
\Drupal::cache()->set($key, $data, REQUEST_TIME + 600);
Add tags
// Add tags to my cache
\Drupal::cache()->set(
$key,
$data,
Cache::PERMANENT,
[
'tag1',
'node:1',
'config:system.menu',
'config:my_module',
]
);
Get tags
// Get tags from an object that implements CacheableDependencyInterface:
$node->getCacheTags();
\Drupal\views\Entity\View::load('front')->getCacheTags();
// Get "List" cache tags associated with this entity type
// Will detects newly created entities
$em = \Drupal::entityTypeManager();
//config:taxonomy_vocabulary_list
$em->getDefinition('taxonomy_vocabulary')->getListCacheTags();
// taxonomy_term_list
$em->getDefinition('taxonomy_term')->getListCacheTags();
// Use redis by default.
$settings['cache']['default'] = 'cache.backend.redis';
// Use the null backend to disable caching for certain bins.
$settings['cache']['bins']['render'] = 'cache.backend.null';
Cache Backends
Where cache are actually stored
Core backends (core/core.services.yml):
Memory: not persisted across requests
Database: Default storage in the (SQL) database (invalidated, never deleted*)
APCu: Shared-Memory inside the PHP process, not shared with drush/CLI/multiple servers
Null: for disabling cache (dev)
Contributed backends:
Slushi Cache: A database backend with a configurable max lifetime
Memcache : RAM object database server cache.backend.memcache_storage
Redis: RAM Key/value database server cache.backend.redis
ChainedFast Backend (cache.backend.chainedfast) allow to "chained" a fast backend on top a slow but shared one.
