最近发现一个问题就是，wp 的后台打开速度越来越慢了，不过用屁股想想也能猜到肯定是 wp 后台的各种更新检查导致的。
网上通用的办法是直接禁用掉各种更新检查，但是鉴于安全问题其实我并不想直接这么干。现在各种漏洞扫描利用太频繁了，新版本能一定程度上降低被利用的风险。
wp 的更新的代码，本质上是有缓存机制的：
function _maybe_update_core() {
$current = get_site_transient( 'update_core' );
if ( isset( $current->last_checked, $current->version_checked )
&& 12 * HOUR_IN_SECONDS > ( time() - $current->last_checked )
&& wp_get_wp_version() === $current->version_checked
) {
return;
}
wp_version_check();
}
检查更新的时候会判断是否在 12 小时内已经执行过，然而，这个破玩儿的问题在于，写入transient的时候不知道为什么失败了，于是每次进入后台都看到一堆 http 请求。
这 tm 就贼啦智障了，多的时候七八个请求，一个请求一秒钟，全部请求完都十几秒了。
所以，我直接基于 redis 做了个缓存机制，避免重复请求。在 24 小时内请求过就不会再次请求了。直接对请求进行拦截。
既避免了无法检查更新，也解决了每次都检查更新的问题。
代码如下：
<?php
/**
* 使用 Redis 缓存控制所有 WordPress 更新检查
*
* 控制以下更新检查的频率：
* 1. wp_version_check() - WordPress 核心版本检查
* 2. wp_update_themes() - 主题更新检查
* 3. wp_update_plugins() - 插件更新检查
* 4. wp_check_browser_version() - 浏览器版本检查
* 5. wp_check_php_version() - PHP 版本检查
*
* 不依赖 WordPress 的 transient，直接使用 Redis 缓存
* 如果 24 小时内更新过，跳过更新检查
*
* 使用方法：
* 将此代码添加到主题的 functions.php 文件末尾
* 或添加到插件的初始化函数中
* https://h4ck.org.cn/wp-admin/index.php?debug_all_checks=1#qm-overview
*/
// ==========================================
// 配置项
// ==========================================
// 缓存键名
define('WP_CORE_UPDATE_CHECK_KEY', 'wp_core_update_check_time');
define('WP_THEMES_UPDATE_CHECK_KEY', 'wp_themes_update_check_time');
define('WP_PLUGINS_UPDATE_CHECK_KEY', 'wp_plugins_update_check_time');
define('WP_BROWSER_VERSION_CHECK_KEY', 'wp_browser_version_check_time');
define('WP_PHP_VERSION_CHECK_KEY', 'wp_php_version_check_time');
// 缓存有效期（24 小时）
define('WP_UPDATE_CHECK_EXPIRATION', DAY_IN_SECONDS);
// ==========================================
// 1. WordPress 核心版本检查 (wp_version_check)
// ==========================================
/**
* 拦截 _maybe_update_core 函数
* 在 admin_init 优先级 0 中移除 _maybe_update_core，使用 Redis 缓存控制
*/
add_action('admin_init', function() {
// 移除 WordPress 原来的 _maybe_update_core 钩子
remove_action('admin_init', '_maybe_update_core', 1);
// 检查 Redis 缓存，看是否在 24 小时内更新过
$last_check_time = wp_cache_get(WP_CORE_UPDATE_CHECK_KEY);
if ($last_check_time !== false && is_numeric($last_check_time)) {
$time_since_check = time() - $last_check_time;
// 如果在 24 小时内，直接 return，跳过更新检查
if ($time_since_check < WP_UPDATE_CHECK_EXPIRATION) {
error_log('[Redis Core Check] 跳过核心版本检查 - 距离上次检查: ' . human_time_diff($last_check_time, time()));
return; // 直接返回，不执行更新检查
}
}
// 如果缓存过期或不存在，执行原来的更新检查逻辑
_maybe_update_core();
}, 0); // 优先级 0，在 _maybe_update_core (优先级 1) 之前执行
/**
* 监控 wp_version_check 的执行，设置 Redis 缓存
* 注意：只有在缓存不存在时才设置，避免频繁刷新时重置缓存时间
*/
add_action('wp_version_check', function() {
$existing_cache = wp_cache_get(WP_CORE_UPDATE_CHECK_KEY);
if ($existing_cache === false) {
wp_cache_set(
WP_CORE_UPDATE_CHECK_KEY,
time(),
'',
WP_UPDATE_CHECK_EXPIRATION
);
error_log('[Redis Core Check] wp_version_check 执行，已设置 Redis 缓存');
}
}, 10);
/**
* 通过过滤器拦截 update_core transient 设置，设置 Redis 缓存
* 注意：只有在缓存不存在时才设置，避免频繁刷新时重置缓存时间
*/
add_filter('pre_set_site_transient_update_core', function($value, $transient_name) {
$existing_cache = wp_cache_get(WP_CORE_UPDATE_CHECK_KEY);
if ($existing_cache === false) {
wp_cache_set(
WP_CORE_UPDATE_CHECK_KEY,
time(),
'',
WP_UPDATE_CHECK_EXPIRATION
);
}
return $value;
}, 999, 2);
// ==========================================
// 2. 主题更新检查 (wp_update_themes)
// ==========================================
/**
* 拦截 _maybe_update_themes 函数
* 在 admin_init 优先级 0 中移除 _maybe_update_themes，使用 Redis 缓存控制
*/
add_action('admin_init', function() {
// 移除 WordPress 原来的 _maybe_update_themes 钩子
remove_action('admin_init', '_maybe_update_themes', 1);
// 检查 Redis 缓存，看是否在 24 小时内更新过
$last_check_time = wp_cache_get(WP_THEMES_UPDATE_CHECK_KEY);
if ($last_check_time !== false && is_numeric($last_check_time)) {
$time_since_check = time() - $last_check_time;
// 如果在 24 小时内，直接 return，跳过更新检查
if ($time_since_check < WP_UPDATE_CHECK_EXPIRATION) {
error_log('[Redis Themes Check] 跳过主题更新检查 - 距离上次检查: ' . human_time_diff($last_check_time, time()));
return; // 直接返回，不执行更新检查
}
}
// 如果缓存过期或不存在，执行原来的更新检查逻辑
_maybe_update_themes();
}, 0); // 优先级 0，在 _maybe_update_themes (优先级 1) 之前执行
/**
* 监控 wp_update_themes 的执行，设置 Redis 缓存
* 注意：只有在缓存不存在时才设置，避免频繁刷新时重置缓存时间
*/
add_action('wp_update_themes', function() {
$existing_cache = wp_cache_get(WP_THEMES_UPDATE_CHECK_KEY);
if ($existing_cache === false) {
wp_cache_set(
WP_THEMES_UPDATE_CHECK_KEY,
time(),
'',
WP_UPDATE_CHECK_EXPIRATION
);
error_log('[Redis Themes Check] wp_update_themes 执行，已设置 Redis 缓存');
}
}, 10);
/**
* 通过过滤器拦截 update_themes transient 设置，设置 Redis 缓存
* 注意：只有在缓存不存在时才设置，避免频繁刷新时重置缓存时间
*/
add_filter('pre_set_site_transient_update_themes', function($value, $transient_name) {
$existing_cache = wp_cache_get(WP_THEMES_UPDATE_CHECK_KEY);
if ($existing_cache === false) {
wp_cache_set(
WP_THEMES_UPDATE_CHECK_KEY,
time(),
'',
WP_UPDATE_CHECK_EXPIRATION
);
}
return $value;
}, 999, 2);
// ==========================================
// 3. 插件更新检查 (wp_update_plugins)
// ==========================================
/**
* 方法1：在 HTTP 请求级别拦截插件更新 API
* 直接拦截到 api.wordpress.org/plugins/update-check/ 的请求
*/
add_filter('pre_http_request', function($preempt, $args, $url) {
// 检查是否是插件更新检查的 API 请求
if (strpos($url, 'api.wordpress.org/plugins/update-check/') !== false) {
// 检查 Redis 缓存，看是否在 24 小时内更新过
$last_check_time = wp_cache_get(WP_PLUGINS_UPDATE_CHECK_KEY);
if ($last_check_time !== false && is_numeric($last_check_time)) {
$time_since_check = time() - $last_check_time;
// 如果在 24 小时内，返回假数据，跳过 API 请求
if ($time_since_check < WP_UPDATE_CHECK_EXPIRATION) {
error_log('[Redis Plugins Check] 跳过插件更新检查 API 请求 - 距离上次检查: ' . human_time_diff($last_check_time, time()));
// 返回一个符合 WordPress API 格式的响应
// WordPress 期望的完整格式：
// - plugins: 需要更新的插件数组
// - no_update: 不需要更新的插件数组（必需！）
// - translations: 翻译更新数组
$fake_response_data = array(
'plugins' => array(), // 需要更新的插件（空数组表示没有更新）
'no_update' => array(), // 不需要更新的插件（必需字段）
'translations' => array() // 翻译更新（空数组表示没有更新）
);
// 编码为 JSON，确保是数组格式
$fake_response = json_encode($fake_response_data, JSON_UNESCAPED_SLASHES);
// 验证 JSON 编码是否成功
if ($fake_response === false || json_last_error() !== JSON_ERROR_NONE) {
error_log('[Redis Plugins Check] JSON 编码失败: ' . json_last_error_msg());
// 如果编码失败，返回一个包含所有必需字段的简单有效 JSON
$fake_response = '{"plugins":[],"no_update":[],"translations":[]}';
}
return array(
'body' => $fake_response,
'response' => array('code' => 200, 'message' => 'OK'),
'headers' => array('Content-Type' => 'application/json; charset=UTF-8'),
);
}
}
}
return $preempt;
}, 5, 3); // 提高优先级，确保在其他过滤器之前执行
/**
* 方法2：拦截 _maybe_update_plugins 函数
* 在 admin_init 优先级 0 中移除 _maybe_update_plugins，使用 Redis 缓存控制
*/
add_action('admin_init', function() {
// 移除 WordPress 原来的 _maybe_update_plugins 钩子
remove_action('admin_init', '_maybe_update_plugins', 1);
// 检查 Redis 缓存，看是否在 24 小时内更新过
$last_check_time = wp_cache_get(WP_PLUGINS_UPDATE_CHECK_KEY);
if ($last_check_time !== false && is_numeric($last_check_time)) {
$time_since_check = time() - $last_check_time;
// 如果在 24 小时内，直接 return，跳过更新检查
if ($time_since_check < WP_UPDATE_CHECK_EXPIRATION) {
error_log('[Redis Plugins Check] 跳过插件更新检查 - 距离上次检查: ' . human_time_diff($last_check_time, time()));
return; // 直接返回，不执行更新检查
}
}
// 如果缓存过期或不存在，执行原来的更新检查逻辑
_maybe_update_plugins();
}, 0); // 优先级 0，在 _maybe_update_plugins (优先级 1) 之前执行
/**
* 在 HTTP 响应时设置 Redis 缓存（插件检查）
* 只有在实际执行了 API 请求并成功获取响应后，才设置缓存
* 同时确保响应格式正确
*/
add_filter('http_response', function($response, $args, $url) {
// 只有在缓存不存在或已过期时，才设置缓存
// 这样可以避免频繁刷新时不断重置缓存时间
$existing_cache = wp_cache_get(WP_PLUGINS_UPDATE_CHECK_KEY);
if ($existing_cache === false) {
// 缓存不存在，说明这是真正的更新检查，设置缓存
wp_cache_set(
WP_PLUGINS_UPDATE_CHECK_KEY,
time(),
'',
WP_UPDATE_CHECK_EXPIRATION
);
error_log('[Redis Plugins Check] 插件更新检查 API 请求完成，已设置 Redis 缓存');
} else {
error_log('[Redis Plugins Check] 缓存已存在，不更新缓存时间');
}
// 检查是否是插件更新检查的 API 请求
if (strpos($url, 'api.wordpress.org/plugins/update-check/') !== false) {
if (!is_wp_error($response)) {
// 确保响应体格式正确
$body = wp_remote_retrieve_body($response);
if (!empty($body)) {
$decoded = json_decode($body, true);
// 如果解析失败或格式不正确，修复它
if (!is_array($decoded)) {
error_log('[Redis Plugins Check] JSON 解析失败，创建默认响应');
$decoded = array();
}
// 确保所有必需字段存在且是正确的类型
if (!isset($decoded['plugins']) || !is_array($decoded['plugins'])) {
$decoded['plugins'] = array();
}
if (!isset($decoded['no_update']) || !is_array($decoded['no_update'])) {
$decoded['no_update'] = array();
}
if (!isset($decoded['translations']) || !is_array($decoded['translations'])) {
$decoded['translations'] = array();
}
// 重新编码响应体（只有在需要修复时才重新编码）
$response['body'] = json_encode($decoded, JSON_UNESCAPED_SLASHES);
}
}
}
return $response;
}, 10, 3);
/**
* 监控 wp_update_plugins 的执行，设置 Redis 缓存
* 注意：只有在缓存不存在时才设置，避免频繁刷新时重置缓存时间
*/
add_action('wp_update_plugins', function() {
// 只有在缓存不存在时，才设置缓存
// 这样可以避免在缓存有效期内不断重置缓存时间
$existing_cache = wp_cache_get(WP_PLUGINS_UPDATE_CHECK_KEY);
if ($existing_cache === false) {
wp_cache_set(
WP_PLUGINS_UPDATE_CHECK_KEY,
time(),
'',
WP_UPDATE_CHECK_EXPIRATION
);
error_log('[Redis Plugins Check] wp_update_plugins 执行，已设置 Redis 缓存');
}
}, 10);
/**
* 通过过滤器拦截 update_plugins transient 设置，设置 Redis 缓存
* 同时确保 transient 数据格式正确
* 注意：只有在缓存不存在时才设置，避免频繁刷新时重置缓存时间
*/
add_filter('pre_set_site_transient_update_plugins', function($value, $transient_name) {
// 确保格式正确
if ($value && is_object($value)) {
// 确保 response 是数组
if (isset($value->response) && !is_array($value->response)) {
error_log('[Redis Plugins Check] 修复 response 格式，从 ' . gettype($value->response) . ' 转换为数组');
$value->response = is_array($value->response) ? $value->response : array();
}
// 确保 translations 是数组
if (isset($value->translations) && !is_array($value->translations)) {
$value->translations = is_array($value->translations) ? $value->translations : array();
}
// 确保 checked 是数组
if (isset($value->checked) && !is_array($value->checked)) {
$value->checked = is_array($value->checked) ? $value->checked : array();
}
}
// 只有在缓存不存在时，才设置 Redis 缓存
// 这样可以避免在缓存有效期内不断重置缓存时间
$existing_cache = wp_cache_get(WP_PLUGINS_UPDATE_CHECK_KEY);
if ($existing_cache === false) {
wp_cache_set(
WP_PLUGINS_UPDATE_CHECK_KEY,
time(),
'',
WP_UPDATE_CHECK_EXPIRATION
);
error_log('[Redis Plugins Check] transient 设置，已设置 Redis 缓存');
}
return $value;
}, 999, 2);
// ==========================================
// 4. 浏览器版本检查 (wp_check_browser_version)
// ==========================================
/**
* 拦截 wp_check_browser_version 函数
* 这个函数通过 HTTP 请求到 api.wordpress.org/core/browse-happy/
* 我们使用过滤器拦截 HTTP 请求
*/
add_filter('pre_http_request', function($preempt, $args, $url) {
// 检查是否是浏览器版本检查的 API 请求
if (strpos($url, 'api.wordpress.org/core/browse-happy/') !== false) {
// 检查 Redis 缓存，看是否在 24 小时内更新过
$last_check_time = wp_cache_get(WP_BROWSER_VERSION_CHECK_KEY);
if ($last_check_time !== false && is_numeric($last_check_time)) {
$time_since_check = time() - $last_check_time;
// 如果在 24 小时内，返回假数据，跳过 API 请求
if ($time_since_check < WP_UPDATE_CHECK_EXPIRATION) {
error_log('[Redis Browser Check] 跳过浏览器版本检查 - 距离上次检查: ' . human_time_diff($last_check_time, time()));
// 返回一个成功的响应（避免重复请求）
return array(
'body' => '{"success":true}',
'response' => array('code' => 200, 'message' => 'OK'),
'headers' => array(),
);
}
}
}
return $preempt;
}, 10, 3);
/**
* 在 HTTP 响应时设置 Redis 缓存（浏览器检查）
* 注意：只有在缓存不存在时才设置，避免频繁刷新时重置缓存时间
*/
add_filter('http_response', function($response, $args, $url) {
// 检查是否是浏览器版本检查的 API 请求
if (strpos($url, 'api.wordpress.org/core/browse-happy/') !== false && !is_wp_error($response)) {
$existing_cache = wp_cache_get(WP_BROWSER_VERSION_CHECK_KEY);
if ($existing_cache === false) {
wp_cache_set(
WP_BROWSER_VERSION_CHECK_KEY,
time(),
'',
WP_UPDATE_CHECK_EXPIRATION
);
error_log('[Redis Browser Check] wp_check_browser_version 执行，已设置 Redis 缓存');
}
}
return $response;
}, 10, 3);
/**
* 监控 wp_check_browser_version 的执行，设置 Redis 缓存
* 作为备用方案，通过动作钩子捕获
* 注意：只有在缓存不存在时才设置，避免频繁刷新时重置缓存时间
*/
add_action('wp_check_browser_version', function() {
$existing_cache = wp_cache_get(WP_BROWSER_VERSION_CHECK_KEY);
if ($existing_cache === false) {
wp_cache_set(
WP_BROWSER_VERSION_CHECK_KEY,
time(),
'',
WP_UPDATE_CHECK_EXPIRATION
);
error_log('[Redis Browser Check] wp_check_browser_version 执行，已设置 Redis 缓存');
}
}, 10);
// ==========================================
// 5. PHP 版本检查 (wp_check_php_version)
// ==========================================
/**
* 拦截 wp_check_php_version 函数
* 这个函数通过 HTTP 请求到 api.wordpress.org/core/serve-happy/
* 我们使用过滤器拦截 HTTP 请求
*/
add_filter('pre_http_request', function($preempt, $args, $url) {
// 检查是否是 PHP 版本检查的 API 请求
if (strpos($url, 'api.wordpress.org/core/serve-happy/') !== false) {
// 检查 Redis 缓存，看是否在 24 小时内更新过
$last_check_time = wp_cache_get(WP_PHP_VERSION_CHECK_KEY);
if ($last_check_time !== false && is_numeric($last_check_time)) {
$time_since_check = time() - $last_check_time;
// 如果在 24 小时内，返回假数据，跳过 API 请求
if ($time_since_check < WP_UPDATE_CHECK_EXPIRATION) {
error_log('[Redis PHP Check] 跳过 PHP 版本检查 - 距离上次检查: ' . human_time_diff($last_check_time, time()));
// 返回一个成功的响应（避免重复请求）
return array(
'body' => '{"success":true}',
'response' => array('code' => 200, 'message' => 'OK'),
'headers' => array(),
);
}
}
}
return $preempt;
}, 10, 3);
/**
* 在 HTTP 响应时设置 Redis 缓存（PHP 检查）
* 注意：只有在缓存不存在时才设置，避免频繁刷新时重置缓存时间
*/
add_filter('http_response', function($response, $args, $url) {
// 检查是否是 PHP 版本检查的 API 请求
if (strpos($url, 'api.wordpress.org/core/serve-happy/') !== false && !is_wp_error($response)) {
$existing_cache = wp_cache_get(WP_PHP_VERSION_CHECK_KEY);
if ($existing_cache === false) {
wp_cache_set(
WP_PHP_VERSION_CHECK_KEY,
time(),
'',
WP_UPDATE_CHECK_EXPIRATION
);
error_log('[Redis PHP Check] wp_check_php_version 执行，已设置 Redis 缓存');
}
}
return $response;
}, 10, 3);
/**
* 监控 wp_check_php_version 的执行，设置 Redis 缓存
* 作为备用方案，通过动作钩子捕获
* 注意：只有在缓存不存在时才设置，避免频繁刷新时重置缓存时间
*/
add_action('wp_check_php_version', function() {
$existing_cache = wp_cache_get(WP_PHP_VERSION_CHECK_KEY);
if ($existing_cache === false) {
wp_cache_set(
WP_PHP_VERSION_CHECK_KEY,
time(),
'',
WP_UPDATE_CHECK_EXPIRATION
);
error_log('[Redis PHP Check] wp_check_php_version 执行，已设置 Redis 缓存');
}
}, 10);
// ==========================================
// 兜底方案：在 shutdown 时检查并设置缓存
// ==========================================
/**
* 在页面加载结束时检查
* 如果更新检查执行了但没有设置缓存，在这里设置
*/
add_action('shutdown', function() {
// 检查核心更新
$core_transient = get_site_transient('update_core');
if ($core_transient && is_object($core_transient)) {
$last_check = wp_cache_get(WP_CORE_UPDATE_CHECK_KEY);
if ($last_check === false && isset($core_transient->last_checked)) {
wp_cache_set(
WP_CORE_UPDATE_CHECK_KEY,
$core_transient->last_checked,
'',
WP_UPDATE_CHECK_EXPIRATION
);
}
}
// 检查主题更新
$themes_transient = get_site_transient('update_themes');
if ($themes_transient && is_object($themes_transient)) {
$last_check = wp_cache_get(WP_THEMES_UPDATE_CHECK_KEY);
if ($last_check === false && isset($themes_transient->last_checked)) {
wp_cache_set(
WP_THEMES_UPDATE_CHECK_KEY,
$themes_transient->last_checked,
'',
WP_UPDATE_CHECK_EXPIRATION
);
}
}
// 检查插件更新
$plugins_transient = get_site_transient('update_plugins');
if ($plugins_transient && is_object($plugins_transient)) {
$last_check = wp_cache_get(WP_PLUGINS_UPDATE_CHECK_KEY);
if ($last_check === false && isset($plugins_transient->last_checked)) {
wp_cache_set(
WP_PLUGINS_UPDATE_CHECK_KEY,
$plugins_transient->last_checked,
'',
WP_UPDATE_CHECK_EXPIRATION
);
}
}
// 浏览器和 PHP 检查可能没有标准的 transient，使用当前时间
// 但这里我们已经在动作钩子中处理了
}, 999);
// ==========================================
// 在后台显示状态（可选，用于调试）
// ==========================================
add_action('admin_notices', function() {
// 只在管理员权限时显示
if (!current_user_can('manage_options')) {
return;
}
// 只在 URL 参数包含 debug_all_checks 时显示
// 或者在后台任何页面都显示（方便调试）
$show_debug = isset($_GET['debug_all_checks']) ||
(defined('WP_DEBUG') && WP_DEBUG && defined('WP_DEBUG_DISPLAY') && WP_DEBUG_DISPLAY);
if (!$show_debug) {
return;
}
// 确保常量已定义
if (!defined('WP_CORE_UPDATE_CHECK_KEY')) {
return;
}
$checks = array(
'WordPress 核心版本检查' => WP_CORE_UPDATE_CHECK_KEY,
'主题更新检查' => WP_THEMES_UPDATE_CHECK_KEY,
'插件更新检查' => WP_PLUGINS_UPDATE_CHECK_KEY,
'浏览器版本检查' => WP_BROWSER_VERSION_CHECK_KEY,
'PHP 版本检查' => WP_PHP_VERSION_CHECK_KEY,
);
echo '<div class="notice notice-info is-dismissible">';
echo '<p><strong>Redis 更新检查状态：</strong></p>';
echo '<ul style="margin-left: 20px;">';
foreach ($checks as $name => $key) {
$last_check = wp_cache_get($key);
if ($last_check !== false && is_numeric($last_check)) {
$time_since = time() - $last_check;
$hours_remaining = (WP_UPDATE_CHECK_EXPIRATION - $time_since) / 3600;
echo '<li><strong>' . esc_html($name) . '：</strong>';
echo '上次检查：' . date('Y-m-d H:i:s', $last_check) . ' | ';
echo '距离现在：' . human_time_diff($last_check, time()) . ' | ';
if ($hours_remaining > 0) {
echo '剩余时间：' . number_format($hours_remaining, 1) . ' 小时 | ';
} else {
echo '已过期 | ';
}
echo '下次检查：' . date('Y-m-d H:i:s', $last_check + WP_UPDATE_CHECK_EXPIRATION);
echo '</li>';
} else {
echo '<li><strong>' . esc_html($name) . '：</strong>未设置缓存，下次访问后台将执行检查。</li>';
}
}
echo '</ul>';
echo '<p><small>提示：访问 <code>?debug_all_checks=1</code> 可查看此状态，或启用 WP_DEBUG 模式</small></p>';
echo '</div>';
}, 10); // 使用优先级 10，确保在 admin_init 之后执行
// ==========================================
// 工具函数：手动清除所有缓存（用于测试）
// ==========================================
/**
* 手动清除所有 Redis 缓存，强制下次检查更新
* 访问：/?clear_all_check_cache=1
*/
add_action('init', function() {
if (isset($_GET['clear_all_check_cache']) && current_user_can('manage_options')) {
wp_cache_delete(WP_CORE_UPDATE_CHECK_KEY);
wp_cache_delete(WP_THEMES_UPDATE_CHECK_KEY);
wp_cache_delete(WP_PLUGINS_UPDATE_CHECK_KEY);
wp_cache_delete(WP_BROWSER_VERSION_CHECK_KEY);
wp_cache_delete(WP_PHP_VERSION_CHECK_KEY);
wp_die('所有 Redis 缓存已清除，下次访问后台将执行更新检查。', '缓存已清除', array('back_link' => true));
}
}, 1);
也可以直接用插件，插件地址：
https://github.com/obaby/baby-wp-update-config-tool
重要提示
在使用本插件之前，您需要首先配置 WordPress 的 Redis 缓存功能。
本插件依赖于 Redis 缓存系统来存储更新检查的时间戳。如果您的 WordPress 站点未配置 Redis 缓存，插件将无法正常工作。请确保：
- 已安装并配置 Redis 服务器
- 已安装 WordPress Redis 缓存插件（如 Redis Object Cache、WP Redis 等）
- Redis 缓存功能已正常启用并运行
如果 Redis 缓存未配置，插件在初始化时会记录警告信息，但不会阻止插件运行。
登录
