Page Caching in Drupal 9: Modifying Cache Behavior with Cookie Values
Introduction
Efficient page caching is crucial for optimizing website performance in Drupal 9. However, in some cases, default caching behavior may not be suitable, especially when content needs to be personalized based on cookies. To modify page caching, it is essential to understand core concepts like internal caching mechanisms, content negotiation, and session handling.
This guide will walk you through altering page caching based on cookie values, enabling more dynamic and personalized web experiences. We will also demonstrate how to extend the Drupal 9 page caching system using StackPHP middlewares and a custom Service Provider.
Understanding Page Caching in Drupal 9
1. Internal Page Cache
Drupal’s internal page caching stores the full HTML output of rendered pages, reducing processing time and enhancing load speed. However, it can cause issues when caching prevents dynamic content updates based on user-specific data, such as cookies.
2. Content Negotiation in Caching
Content negotiation allows Drupal to deliver responses in the preferred format requested by the client—whether HTML, JSON, or XML. When altering page caching, it is crucial to ensure that caching mechanisms correctly interpret these formats.
3. Session Handling and Caching
Session handling stores and maintains user-specific information, such as authentication data and preferences. Since page caches typically serve the same content to all users, modifying cache behavior ensures that different sessions receive customized content based on cookies.
Example Scenario: Altering Page Caching with Cookie Values
Problem:
A view page is getting cached, even when using cookies as contextual filters.
Solution:
We will add cookies based on user location (e.g., Mumbai, Delhi) and alter page caching accordingly. To achieve this, we need to:
- Create a custom Service Provider to modify the page cache.
- Develop a middleware that fetches cookie values and alters the cache ID dynamically.
Step 1: Creating a Custom Service Provider
To modify page caching, we must extend Drupal’s internal caching class. Before doing this, create a custom Service Provider by extending the Drupal Core Service Provider Base class.
Service Provider Implementation
We begin by extending the Internal page cache class and using its predefined methods as needed. Before extending the Page Cache class, you need to create a custom service provider by extending the Drupal Core Service Provider Base class and Service Provider Interface in your custom module.
Drupal automatically discovers only one service provider per module. Implement a class extending ServiceProviderBase and the alter() method to modify existing services. The naming convention for the service provider PHP class is camel-cased Drupal module name plus ServiceProvider.php. For instance, we will create a file named customCommonServiceProvider.php in our custom module, located at /web/modules/custom/customCommon/src/.
Here’s the code to get started:
“`php
$definition = $container->getDefinition(‘http_middleware.page_cache’);
$definition->setClass(‘Drupal\customCommon\StackMiddleware\AlterPageCache’);
}
}
}
“`
In the above code, we extend the ServiceProviderBase core class and the ServiceProviderInterface. We call the alter method with ContainerBuilder as an argument. In the container, we check the middleware page cache definition’s existence. If it exists, we get and set our AlterPageCache class in it.
Step 2: Creating the AlterPageCache Class
Next, we need to create a StackMiddleware folder in the src folder of our custom module. Inside this folder, create an AlterPageCache.php file. The final path for this file will be /web/modules/custom/customCommon/src/StackMiddleware/AlterPageCache.php.
Here’s the code for the AlterPageCache class:
“`php
if (!isset($this->cid)) {
$cidParts = [
$request->getSchemeAndHttpHost() . $request->getRequestUri(),
$request->getRequestFormat(NULL),
$cookiesCache,
];
$this->cid = implode(‘:’, $cidParts);
}
return $this->cid;
}
}
“`
In this file, we extend the internal page cache class and override its getCacheId method to include the cookies retrieved from the request and return the cache ID.
Conclusion
By following these steps, you can successfully modify page caching in Drupal 9, ensuring that dynamic content updates correctly based on cookie values. Integrating Enhanced Secure Session Management in JavaScript Web Applications allows for even better handling of personalized content and session-based data caching.
In summary, page caching plays a crucial role in performance optimization, but modifying it based on cookie values is essential for personalized experiences. Implementing a custom Service Provider and middleware ensures that cached content remains dynamic while maintaining efficiency.
Do you like to read more educational content? Read our blogs at Cloudastra Technologies or contact us for business enquiry at Cloudastra Contact Us.