Alright, gather \u2019round, code wranglers! Let\u2019s talk about WordPress\u2019s internal caching mechanism\u00a0when it\u2019s flying solo, without any fancy external caching plugins. We\u2019re diving deep into wp_cache_get() and wp_cache_set(), the unsung heroes of WordPress performance when no other cache provider is configured.<\/p>\n
(Ahem, clears throat, adjusts imaginary glasses) Let\u2019s begin!<\/p>\n
The Stage: wp-includes\/cache.php<\/p>\n
This is where the magic happens, or rather, the basic magic happens. When you don\u2019t have Memcached, Redis, or some other caching system set up, WordPress relies on its own internal, in-memory object cache. This cache is held in a global variable, $wp_object_cache.<\/p>\n
The Players: wp_cache_get() and wp_cache_set()<\/p>\n
These two functions are the workhorses. wp_cache_get() retrieves data from the cache, and wp_cache_set() stores data into it.<\/p>\n
Scenario 1: No External Cache Provider<\/p>\n
If you haven\u2019t installed and activated a persistent object cache plugin (like Memcached Object Cache, Redis Object Cache, etc.), WordPress uses its default, non-persistent object cache. This means the cache exists only for the duration of a single request. Once the page is generated and sent to the user, the cache is wiped clean.<\/p>\n
Under the Hood: $wp_object_cache<\/p>\n
The $wp_object_cache variable is an instance of the WP_Object_Cache class. Let\u2019s take a look at its structure.<\/p>\n
\/**
\n * Core class used to implement an object cache.
\n *
\n * @since 2.0.0
\n *\/
\nclass WP_Object_Cache {<\/p>\n
\/**
\n * Holds the cached objects.
\n *
\n * @var array
\n *\/
\n private $cache = array();<\/p>\n
\/**
\n * The number of cache calls.
\n *
\n * @var int
\n *\/
\n public $cache_hits = 0;<\/p>\n
\/**
\n * Number of times cache missed.
\n *
\n * @var int
\n *\/
\n public $cache_misses = 0;<\/p>\n
\/**
\n * List of global groups.
\n *
\n * @var array
\n *\/
\n protected $global_groups = array();<\/p>\n
\/**
\n * List of non-persistent groups.
\n *
\n * @var array
\n *\/
\n protected $non_persistent_groups = array();<\/p>\n
\/**
\n * Holds the value if WordPress is running in network mode.
\n *
\n * @var bool
\n *\/
\n protected $multisite;<\/p>\n
\/**
\n * The blog ID.
\n *
\n * @var int
\n *\/
\n protected $blog_id;<\/p>\n
\/**
\n * Instantiate the cache.
\n *
\n * @since 2.0.0
\n *
\n * @global array $wp_db_versions
\n *\/
\n public function __construct() {
\n global $wp_db_versions;<\/p>\n
$this->multisite = is_multisite();
\n $this->blog_id = (int) get_current_blog_id();<\/p>\n
if ( function_exists( 'wp_cache_add_global_groups' ) ) {
\n wp_cache_add_global_groups( (array) $wp_db_versions );
\n }
\n }<\/p>\n
\/\/ … (Other methods will be discussed later) …
\n}<\/p>\n
global $wp_object_cache;<\/p>\n
if ( ! isset( $wp_object_cache ) ) {
\n $wp_object_cache = new WP_Object_Cache();
\n}<\/p>\n
Key things to note:<\/p>\n
Diving into wp_cache_get()<\/p>\n
Let\u2019s dissect the wp_cache_get() function.<\/p>\n
\/**
\n * Retrieves the cache contents, if it exists.
\n *
\n * The contents are first attempted to be retrieved from the cache. If the
\n * cache is empty, then the callback function will be called to generate
\n * the cache contents. The results of the callback function are stored in the
\n * cache using the cache key.
\n *
\n * @since 2.0.0
\n *
\n * @global WP_Object_Cache $wp_object_cache Object cache global instance.
\n *
\n * @param int|string $key Cache key.
\n * @param string $group Optional. Cache group. Default empty.
\n * @param bool $force Optional. Whether to force an update of the local
\n * cache from the persistent cache. Default false.
\n *
\n * @return mixed|false Cached data on success, false on failure.
\n *\/
\nfunction wp_cache_get( $key, $group = '', $force = false ) {
\n global $wp_object_cache;<\/p>\n
return $wp_object_cache->get( $key, $group, $force );
\n}<\/p>\n
It\u2019s a simple wrapper around the WP_Object_Cache::get() method. Let\u2019s look at that method:<\/p>\n
\/**
\n * Retrieves the cache contents, if it exists.
\n *
\n * @since 2.0.0
\n *
\n * @param int|string $key Cache key.
\n * @param string $group Optional. Cache group. Default empty.
\n * @param bool $force Optional. Whether to force an update of the local
\n * cache from the persistent cache. Default false.
\n *
\n * @return mixed|false Cached data on success, false on failure.
\n *\/
\npublic function get( $key, $group = '', $force = false ) {
\n $key = (string) $key;
\n $group = (string) $group;<\/p>\n
if ( isset( $this->cache[ $group ][ $key ] ) ) {
\n $this->cache_hits++;
\n if ( is_object( $this->cache[ $group ][ $key ] ) ) {
\n return clone $this->cache[ $group ][ $key ];
\n } else {
\n return $this->cache[ $group ][ $key ];
\n }
\n }<\/p>\n
$this->cache_misses++;
\n return false;
\n}<\/p>\n
Here\u2019s the breakdown:<\/p>\n
Example wp_cache_get() Usage:<\/p>\n
$my_data = wp_cache_get( 'my_unique_key', 'my_group' );<\/p>\n
if ( false === $my_data ) {
\n \/\/ Data not found in cache. Let's fetch it from the database or calculate it.
\n $my_data = expensive_operation(); \/\/ Replace with your actual data fetching code<\/p>\n
\/\/ Store the data in the cache for future use.
\n wp_cache_set( 'my_unique_key', $my_data, 'my_group' );
\n}<\/p>\n
\/\/ Now $my_data contains either the cached data or the newly fetched\/calculated data.
\necho "My data: " . $my_data;<\/p>\n
The Star of the Show: wp_cache_set()<\/p>\n
Now, let\u2019s explore wp_cache_set().<\/p>\n
\/**
\n * Sets the data contents into the cache.
\n *
\n * The cache key and group are used to name the cache and to group the cache
\n * contents.
\n *
\n * @since 2.0.0
\n *
\n * @global WP_Object_Cache $wp_object_cache Object cache global instance.
\n *
\n * @param int|string $key Cache key.
\n * @param mixed $data Data to store in the cache.
\n * @param string $group Optional. Cache group. Default empty.
\n * @param int $expire Optional. When to expire the cache contents, in seconds.
\n * Default 0 (no expiration).
\n *
\n * @return bool False if not an object. True on success.
\n *\/
\nfunction wp_cache_set( $key, $data, $group = '', $expire = 0 ) {
\n global $wp_object_cache;<\/p>\n
return $wp_object_cache->set( $key, $data, $group, $expire );
\n}<\/p>\n
Again, this is a wrapper for the WP_Object_Cache::set() method:<\/p>\n
\/**
\n * Sets the data contents into the cache.
\n *
\n * @since 2.0.0
\n *
\n * @param int|string $key Cache key.
\n * @param mixed $data Data to store in the cache.
\n * @param string $group Optional. Cache group. Default empty.
\n * @param int $expire Optional. When to expire the cache contents, in seconds.
\n * Default 0 (no expiration).
\n *
\n * @return bool False if not an object. True on success.
\n *\/
\npublic function set( $key, $data, $group = '', $expire = 0 ) {
\n $key = (string) $key;
\n $group = (string) $group;<\/p>\n
if ( is_object( $data ) ) {
\n $this->cache[ $group ][ $key ] = clone $data;
\n } else {
\n $this->cache[ $group ][ $key ] = $data;
\n }<\/p>\n
return true;
\n}<\/p>\n
The process:<\/p>\n
Important Considerations with the Internal Cache<\/p>\n
Global vs. Non-Persistent Groups<\/p>\n
Let\u2019s look at how $global_groups and $non_persistent_groups are used.<\/p>\n
\/**
\n * Adds a group to the list of global groups.
\n *
\n * @since 2.9.0
\n *
\n * @param string|array $groups A group or an array of groups to add.
\n *\/
\npublic function add_global_groups( $groups ) {
\n if ( ! is_array( $groups ) ) {
\n $groups = (array) $groups;
\n }<\/p>\n
$this->global_groups = array_merge( $this->global_groups, $groups );
\n $this->global_groups = array_unique( $this->global_groups );
\n}<\/p>\n
\/**
\n * Adds a group to the list of non-persistent groups.
\n *
\n * @since 3.5.0
\n *
\n * @param string|array $groups A group or an array of groups to add.
\n *\/
\npublic function add_non_persistent_groups( $groups ) {
\n if ( ! is_array( $groups ) ) {
\n $groups = (array) $groups;
\n }<\/p>\n
$this->non_persistent_groups = array_merge( $this->non_persistent_groups, $groups );
\n $this->non_persistent_groups = array_unique( $this->non_persistent_groups );
\n}<\/p>\n
\/**
\n * Resets internal cache keys and properties.
\n *
\n * @since 2.0.0
\n *\/
\npublic function reset() {
\n $this->cache = array();
\n $this->cache_hits = 0;
\n $this->cache_misses = 0;
\n}<\/p>\n
\/**
\n * Removes the contents of the cache key in the group.
\n *
\n * @since 2.0.0
\n *
\n * @param int|string $key What the key of the cache to delete.
\n * @param string $group Optional. Which group to delete from. Default empty.
\n *
\n * @return bool Always returns true.
\n *\/
\npublic function delete( $key, $group = '' ) {
\n $key = (string) $key;
\n $group = (string) $group;<\/p>\n
unset( $this->cache[ $group ][ $key ] );
\n return true;
\n}<\/p>\n
These functions help manage how the cache is handled, especially in a multisite environment or with persistent caching. add_global_groups ensures certain data is consistent across all sites in a network, while add_non_persistent_groups keeps data separate. reset clears the cache, and delete removes specific items.<\/p>\n
Why Use wp_cache_get() and wp_cache_set() Even Without a Persistent Cache?<\/p>\n
Even though the internal cache is short-lived, using wp_cache_get() and wp_cache_set() is still beneficial:<\/p>\n
Code Example: Optimizing a Loop<\/p>\n
Let\u2019s say you have a loop that needs to retrieve the same post meta data for each post.<\/p>\n
\/\/ Without caching
\n$posts = get_posts( array( 'numberposts' => 10 ) );
\nforeach ( $posts as $post ) {
\n $meta_value = get_post_meta( $post->ID, 'my_custom_field', true );
\n echo $meta_value . '<br>';
\n}<\/p>\n
\/\/ With caching
\n$posts = get_posts( array( 'numberposts' => 10 ) );
\nforeach ( $posts as $post ) {
\n $cache_key = 'post_meta_' . $post->ID . '_my_custom_field';
\n $meta_value = wp_cache_get( $cache_key, 'my_meta_group' );<\/p>\n
if ( false === $meta_value ) {
\n $meta_value = get_post_meta( $post->ID, 'my_custom_field', true );
\n wp_cache_set( $cache_key, $meta_value, 'my_meta_group' );
\n }<\/p>\n
echo $meta_value . '<br>';
\n}<\/p>\n
In the second example, the get_post_meta() function is only called once per post per request. Subsequent calls retrieve the data from the cache.<\/p>\n
When to Consider a Persistent Cache<\/p>\n
The internal cache is a good starting point, but for high-traffic sites, a persistent object cache (Memcached, Redis, etc.) is essential. Here\u2019s when you should consider upgrading:<\/p>\n
Troubleshooting<\/p>\n
If you\u2019re not seeing the expected caching behavior, here are some things to check:<\/p>\n
In Conclusion<\/p>\n
While not as powerful as persistent caching solutions, the internal WordPress object cache provides a basic level of caching functionality. Understanding how wp_cache_get() and wp_cache_set() work under the hood is crucial for optimizing your WordPress site\u2019s performance and preparing it for future scalability. Remember, caching is all about reducing redundant operations and serving data more efficiently. Use these functions wisely, and your WordPress site will thank you for it!<\/p>\n
Now, go forth and cache all the things! (Responsibly, of course.)<\/p>\n","protected":false},"excerpt":{"rendered":"
\u6587\u7ae0\u6d4f\u89c8\u9605\u8bfb479\u6b21\uff0c\u70b9\u8d5e12\u6b21\uff0c\u6536\u85cf15\u6b21\u3002\u3010\u4ee3\u7801\u3011\u8be6\u89e3 WordPress `wp_cache_get()` \u548c `wp_cache_set()` \u51fd\u6570\u7684\u6e90\u7801\uff1a\u5728\u6ca1\u6709\u5916\u90e8\u7f13\u5b58\u65f6\u7684\u5185\u90e8\u5de5\u4f5c\u673a\u5236\u3002<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[99,1301,190,398],"topic":[],"class_list":["post-54326","post","type-post","status-publish","format-standard","hentry","category-server","tag-java","tag-wordpress","tag-190","tag-398"],"yoast_head":"\n