实操指南：调试REST API接口错误的4个排查技巧

文章目录

在WordPress开发中，REST API已成为连接前端与后端、实现数据交互的核心桥梁。无论是开发自定义主题、插件，还是构建Headless WordPress应用，REST API都扮演着至关重要的角色。然而，对于行业新人和经验尚浅的程序员来说，当API接口出现错误时，往往感到无从下手。

调试REST API错误不仅需要理解HTTP协议的基本原理，还需要熟悉WordPress特有的API结构和错误处理机制。本文将基于WordPress开源系统的代码开发，分享四个实用的排查技巧，帮助开发者快速定位和解决REST API接口问题。

WordPress提供了强大的调试工具，但在生产环境中默认是关闭的。要开始调试API错误，首先需要启用调试模式。

// 在wp-config.php文件中添加或修改以下代码
define('WP_DEBUG', true);
define('WP_DEBUG_LOG', true);      // 将错误日志保存到wp-content/debug.log
define('WP_DEBUG_DISPLAY', false); // 不在页面上显示错误信息

启用调试模式后，WordPress会记录所有PHP错误、警告和通知。当REST API调用失败时，检查debug.log文件往往能找到问题的根源。

Query Monitor是WordPress开发者的必备工具之一，它提供了详细的数据库查询、API请求、钩子调用等信息。

安装并激活Query Monitor插件

访问网站时，页面底部会出现Query Monitor工具栏

点击"REST API"选项卡，查看所有API请求的详细信息

通过Query Monitor，你可以看到：

每个API端点的请求和响应

请求参数和响应数据

HTTP状态码和响应时间

可能出现的错误信息

对于复杂的API问题，可能需要更详细的日志记录。可以在自定义插件或主题的functions.php中添加以下代码：

add_action('rest_api_init', function() {
    // 记录所有REST API请求
    add_filter('rest_pre_dispatch', function($result, $server, $request) {
        $log_data = [
            'time' => current_time('mysql'),
            'method' => $request->get_method(),
            'route' => $request->get_route(),
            'params' => $request->get_params(),
            'headers' => $request->get_headers(),
        ];
        
        error_log('REST API Request: ' . print_r($log_data, true));
        
        return $result;
    }, 10, 3);
    
    // 记录所有REST API响应
    add_filter('rest_post_dispatch', function($response, $server, $request) {
        $log_data = [
            'time' => current_time('mysql'),
            'status' => $response->get_status(),
            'data' => $response->get_data(),
            'headers' => $response->get_headers(),
        ];
        
        error_log('REST API Response: ' . print_r($log_data, true));
        
        return $response;
    }, 10, 3);
});

REST API使用HTTP状态码来指示请求的结果。理解这些状态码是调试的第一步：

2xx 成功：请求已成功处理

200 OK：请求成功

201 Created：资源创建成功

204 No Content：请求成功，但无返回内容

4xx 客户端错误：请求有问题

400 Bad Request：请求语法错误

401 Unauthorized：需要身份验证

403 Forbidden：服务器理解请求但拒绝执行

404 Not Found：请求的资源不存在

405 Method Not Allowed：请求方法不被允许

5xx 服务器错误：服务器处理请求时出错

500 Internal Server Error：服务器内部错误

501 Not Implemented：服务器不支持请求的功能

WordPress REST API除了返回标准HTTP状态码外，还会返回包含详细错误信息的响应体：

{
    "code": "rest_no_route",
    "message": "未找到与URL和请求方法匹配的路由。",
    "data": {
        "status": 404
    }
}

常见的WordPress REST API错误代码包括：

rest_no_route：路由不存在
rest_forbidden：权限不足
rest_invalid_param：参数无效
rest_post_invalid_id：文章ID无效

当遇到API错误时，可以按照以下流程排查：

检查状态码：确定错误类型（客户端还是服务器端）
查看响应体：WordPress通常会提供详细的错误信息
验证端点URL：确保请求的端点路径正确
检查请求方法：GET、POST、PUT、DELETE是否使用正确

例如，如果收到403错误，可能是权限问题：

// 检查当前用户是否有权限访问API
add_filter('rest_authentication_errors', function($result) {
    // 如果已经有错误，直接返回
    if (!empty($result)) {
        return $result;
    }
    
    // 检查用户是否已登录
    if (!is_user_logged_in()) {
        return new WP_Error(
            'rest_not_logged_in',
            '您需要登录才能访问此API。',
            array('status' => 401)
        );
    }
    
    // 检查用户权限
    $current_user = wp_get_current_user();
    if (!in_array('editor', $current_user->roles)) {
        return new WP_Error(
            'rest_insufficient_permissions',
            '您没有足够的权限访问此API。',
            array('status' => 403)
        );
    }
    
    return $result;
});

不正确的请求参数是API错误的常见原因。WordPress提供了参数验证机制：

register_rest_route('myplugin/v1', '/resource/(?P<id>d+)', array(
    'methods' => 'GET',
    'callback' => 'my_get_resource',
    'args' => array(
        'id' => array(
            'validate_callback' => function($param, $request, $key) {
                // 验证ID是否为数字且大于0
                return is_numeric($param) && $param > 0;
            },
            'sanitize_callback' => 'absint', // 清理参数，确保为整数
            'required' => true,
            'description' => '资源ID，必须为正整数',
        ),
        'include_meta' => array(
            'validate_callback' => function($param, $request, $key) {
                // 验证是否为布尔值
                return is_bool($param) || in_array($param, array('true', 'false', '1', '0'));
            },
            'default' => false,
        ),
    ),
    'permission_callback' => function() {
        return current_user_can('read');
    }
));

确保API返回正确的数据格式同样重要。可以使用WordPress的rest_ensure_response函数：

function my_get_resource($request) {
    $id = $request->get_param('id');
    
    // 获取数据
    $post = get_post($id);
    
    if (!$post) {
        return new WP_Error(
            'rest_resource_not_found',
            '未找到指定的资源',
            array('status' => 404)
        );
    }
    
    // 准备响应数据
    $data = array(
        'id' => $post->ID,
        'title' => get_the_title($post),
        'content' => apply_filters('the_content', $post->post_content),
        'date' => $post->post_date,
    );
    
    // 确保响应格式正确
    $response = rest_ensure_response($data);
    
    // 添加自定义头部
    $response->header('X-Custom-Header', 'MyValue');
    
    return $response;
}

Postman是测试REST API的强大工具，可以：

发送各种HTTP请求：GET、POST、PUT、DELETE等

设置请求头：Content-Type、Authorization等

传递参数：查询参数、请求体参数

查看响应：状态码、响应头、响应体

自动化测试：创建测试集合和自动化脚本

调试WordPress REST API时，可以这样使用Postman：

设置请求URL：`http://yoursite.com/wp-json/wp/v2/posts`

添加认证头（如果需要）：`Authorization: Bearer YOUR_JWT_TOKEN`

发送请求并分析响应

如果遇到错误，查看响应体和状态码

现代浏览器的开发者工具也是调试API的好帮手：

网络面板：查看所有API请求和响应

控制台：查看JavaScript发起的API请求错误

存储面板：检查Cookie、LocalStorage等

在Chrome开发者工具中，可以：

过滤XHR请求，只看API调用

查看请求和响应的详细信息

复制请求为cURL命令，方便在终端重试

要调试WordPress REST API，需要了解其注册和路由机制：

// WordPress REST API的核心注册流程
add_action('rest_api_init', 'register_my_routes');

function register_my_routes() {
    // 注册命名空间
    register_rest_route(
        'myplugin/v1',  // 命名空间
        '/resource',     // 路由
        array(           // 端点配置
            array(
                'methods' => WP_REST_Server::READABLE,
                'callback' => 'get_resources',
                'permission_callback' => 'check_permissions',
            ),
            array(
                'methods' => WP_REST_Server::CREATABLE,
                'callback' => 'create_resource',
                'permission_callback' => 'check_permissions',
                'args' => $this->get_endpoint_args_for_item_schema(WP_REST_Server::CREATABLE),
            ),
        )
    );
}

WP-CLI是管理WordPress的命令行工具，也可以用于调试：

# 列出所有可用的REST API端点
wp rest route list

# 查看特定端点的详细信息
wp rest route get /wp/v2/posts

# 测试API端点
wp rest post /wp/v2/posts --title="测试文章" --content="测试内容" --status="draft"

# 检查REST API状态
wp rest check

当遇到难以解决的API错误时，可能需要深入WordPress核心代码：

查找相关钩子：使用grep搜索相关函数和过滤器
跟踪执行流程：了解请求从接收到响应的完整过程
检查权限系统：WordPress的能力（capabilities）和角色（roles）系统

例如，要了解权限检查如何工作：

// 在wp-includes/rest-api/class-wp-rest-server.php中
private function check_authentication() {
    // 检查是否有认证错误
    $result = apply_filters('rest_authentication_errors', null);
    
    if (!is_wp_error($result)) {
        // 检查是否明确允许
        $result = apply_filters('rest_authentication_required', $result, $this);
    }
    
    return $result;
}

对于复杂的调试场景，可以创建专门的调试端点：

add_action('rest_api_init', function() {
    register_rest_route('debug/v1', '/info', array(
        'methods' => 'GET',
        'callback' => 'get_debug_info',
        'permission_callback' => function() {
            // 仅管理员可访问
            return current_user_can('manage_options');
        }
    ));
});

function get_debug_info($request) {
    global $wpdb, $wp_rewrite;
    
    $info = array(
        'wordpress' => array(
            'version' => get_bloginfo('version'),
            'multisite' => is_multisite(),
            'debug_mode' => WP_DEBUG,
        ),
        'server' => array(
            'php_version' => phpversion(),
            'server_software' => $_SERVER['SERVER_SOFTWARE'],
        ),
        'rest_api' => array(
            'namespace' => $request->get_route(),
            'available_namespaces' => rest_get_server()->get_namespaces(),
        ),
        'database' => array(
            'charset' => $wpdb->charset,
            'collate' => $wpdb->collate,
        ),
        'rewrite' => array(
            'rules' => $wp_rewrite->wp_rewrite_rules(),
            'permalink_structure' => get_option('permalink_structure'),
        ),
    );
    
    return rest_ensure_response($info);
}

假设我们在开发一个WordPress插件，需要创建一个自定义REST API端点来获取用户数据。端点已经创建，但每次调用都返回500内部服务器错误。

启用调试模式：在wp-config.php中设置`WP_DEBUG`为true

检查错误日志：查看wp-content/debug.log文件

发现错误信息：日志显示"Call to undefined function get_user_data()"

定位问题：在回调函数中错误地调用了不存在的函数

修复代码：将`get_user_data()`改为正确的`get_userdata()`

测试验证：使用Postman重新测试API端点

// 修复前的错误代码
add_action('rest_api_init', function() {
    register_rest_route('myplugin/v1', '/user/(?P<id>d+)', array(
        'methods' => 'GET',
        'callback' => 'get_user_callback',
    ));
});

function get_user_callback($request) {
    $user_id = $request->get_param('id');
    $user_data = get_user_data($user_id); // 错误：函数不存在
    
    return rest_ensure_response($user_data);
}

// 修复后的正确代码
add_action('rest_api_init', function() {
    register_rest_route('myplugin/v1', '/user/(?P<id>d+)', array(
        'methods' => 'GET',
        'callback' => 'get_user_callback',
        'args' => array(
            'id' => array(
                'validate_callback' => 'is_numeric',
                'required' => true,
            ),
        ),
        'permission_callback' => function() {
            return current_user_can('list_users');
        }
    ));
});

function get_user_callback($request) {
    $user_id = intval($request->get_param('id'));
    $user = get_userdata($user_id); // 正确：使用WordPress内置函数
    
    if (!$user) {
        return new WP_Error(
            'rest_user_not_found',
            '用户不存在',
            array('status' => 404)
        );
    }
    
    // 只返回必要的数据，避免暴露敏感信息
    $data = array(
        'id' => $user->ID,
        'username' => $user->user_login,
        'display_name' => $user->display_name,
        'email' => $user->user_email,
        'roles' => $user->roles,
    );
    
    return rest_ensure_response($data);
}

调试REST API错误是一个系统性的过程，需要结合多种工具和方法。基于WordPress开发，我们总结了以下最佳实践：

始终启用调试模式：在开发环境中，保持WP_DEBUG开启

理解HTTP状态码：这是诊断问题的第一步

使用专业工具：Postman、Query Monitor等工具能极大提高效率

验证输入和输出：确保请求参数和响应数据都符合预期

深入核心代码：了解WordPress REST API的工作原理

编写可测试的代码：为API端点添加充分的验证和错误处理

记录详细的日志：在关键位置添加日志记录，方便追踪问题

保持代码简洁：复杂的回调函数更容易出错

记住，调试不仅是解决问题的过程，更是深入理解系统工作原理的机会。通过系统地应用这4个排查技巧，你将能够更高效地解决WordPress REST API开发中遇到的各种问题，提升开发效率和质量。

随着对WordPress REST API的深入理解，你不仅能够快速调试错误，还能设计出更健壮、更安全的API接口，为构建高质量的WordPress应用打下坚实基础。

WordPress REST API支持多种认证方式，理解这些机制对调试权限错误至关重要：

// 检查当前REST API请求的认证状态
add_action('rest_api_init', function() {
    // 添加调试端点，查看认证信息
    register_rest_route('debug/v1', '/auth-status', [
        'methods' => 'GET',
        'callback' => function($request) {
            $current_user = wp_get_current_user();
            $status = [
                'is_user_logged_in' => is_user_logged_in(),
                'user_id' => get_current_user_id(),
                'user_caps' => $current_user->allcaps,
                'auth_cookie' => isset($_COOKIE[LOGGED_IN_COOKIE]),
                'doing_ajax' => wp_doing_ajax(),
                'doing_cron' => wp_doing_cron(),
                'is_rest' => defined('REST_REQUEST') && REST_REQUEST,
            ];
            
            // 检查各种认证方式
            $status['auth_methods'] = [
                'cookie' => apply_filters('rest_cookie_check_errors', null),
                'application_passwords' => WP_Application_Passwords::is_in_use(),
                'jwt' => apply_filters('jwt_auth_token_before_dispatch', null),
            ];
            
            return rest_ensure_response($status);
        },
        'permission_callback' => '__return_true'
    ]);
});

WordPress 5.6+引入了应用密码功能，这是API认证的推荐方式：

# 使用WP-CLI创建应用密码
wp user application-password create 1 "My API App"

# 列出所有应用密码
wp user application-password list 1

# 测试应用密码认证
curl -X GET https://yoursite.com/wp-json/wp/v2/users/me 
  -H "Authorization: Basic $(echo -n 'username:password' | base64)"

调试应用密码认证问题：

// 监控应用密码认证过程
add_filter('application_password_is_api_request', function($is_api_request) {
    error_log('应用密码认证检查: ' . ($is_api_request ? '是API请求' : '不是API请求'));
    return $is_api_request;
});

add_action('wp_authenticate_application_password_errors', function($error, $user) {
    if (is_wp_error($error)) {
        error_log('应用密码认证错误: ' . $error->get_error_message());
    } else {
        error_log('应用密码认证成功，用户: ' . $user->user_login);
    }
}, 10, 2);

复杂的权限逻辑容易出错，需要系统化调试：

// 创建带详细日志的权限回调包装器
function debug_permission_callback($callback, $endpoint_name) {
    return function($request) use ($callback, $endpoint_name) {
        $start_time = microtime(true);
        $current_user = wp_get_current_user();
        
        error_log("[$endpoint_name] 权限检查开始 - 用户: {$current_user->ID}");
        error_log("[$endpoint_name] 请求方法: " . $request->get_method());
        error_log("[$endpoint_name] 请求参数: " . json_encode($request->get_params()));
        
        $result = call_user_func($callback, $request);
        
        $execution_time = microtime(true) - $start_time;
        
        if (is_wp_error($result)) {
            error_log("[$endpoint_name] 权限检查失败: " . $result->get_error_message());
            error_log("[$endpoint_name] 错误代码: " . $result->get_error_code());
        } else {
            error_log("[$endpoint_name] 权限检查通过，耗时: {$execution_time}秒");
        }
        
        return $result;
    };
}

// 使用示例
register_rest_route('myplugin/v1', '/protected-data', [
    'methods' => 'GET',
    'callback' => 'get_protected_data',
    'permission_callback' => debug_permission_callback(function($request) {
        // 复杂的权限逻辑
        if (!current_user_can('manage_options')) {
            // 检查特定条件
            $special_condition = check_special_condition($request);
            if (!$special_condition) {
                return new WP_Error(
                    'rest_forbidden',
                    '您没有访问此资源的权限',
                    ['status' => 403]
                );
            }
        }
        return true;
    }, 'protected-data-endpoint')
]);

低效的数据库查询是API性能问题的常见原因：

// 监控REST API中的数据库查询
add_action('rest_api_init', function() {
    // 保存原始查询日志
    global $wpdb;
    $original_queries = $wpdb->queries;
    $wpdb->queries = [];
    
    // 在API请求结束时记录查询
    add_action('rest_pre_serve_request', function() use (&$original_queries) {
        global $wpdb;
        
        $query_log = [
            'total_queries' => count($wpdb->queries),
            'queries' => [],
            'slow_queries' => []
        ];
        
        foreach ($wpdb->queries as $query) {
            list($sql, $time, $caller) = $query;
            
            $query_info = [
                'sql' => $sql,
                'time' => $time,
                'caller' => $caller
            ];
            
            $query_log['queries'][] = $query_info;
            
            // 标记慢查询（超过0.1秒）
            if ($time > 0.1) {
                $query_log['slow_queries'][] = $query_info;
            }
        }
        
        error_log('REST API数据库查询统计: ' . json_encode($query_log));
        
        // 恢复原始查询日志
        $wpdb->queries = $original_queries;
    });
});

对于不经常变化的数据，使用transients缓存可以显著提高性能：

// 带缓存的API端点实现
function get_cached_posts($request) {
    $page = $request->get_param('page') ?: 1;
    $per_page = $request->get_param('per_page') ?: 10;
    
    // 创建唯一的缓存键
    $cache_key = 'rest_posts_' . $page . '_' . $per_page . '_' . get_current_user_id();
    $cache_group = 'rest_api';
    $expiration = HOUR_IN_SECONDS; // 缓存1小时
    
    // 尝试从缓存获取
    $cached = wp_cache_get($cache_key, $cache_group);
    
    if (false !== $cached) {
        error_log("从缓存获取文章数据，键: $cache_key");
        return rest_ensure_response($cached);
    }
    
    // 缓存未命中，查询数据库
    error_log("缓存未命中，查询数据库获取文章，键: $cache_key");
    
    $args = [
        'post_type' => 'post',
        'post_status' => 'publish',
        'posts_per_page' => $per_page,
        'paged' => $page,
        'orderby' => 'date',
        'order' => 'DESC',
    ];
    
    $query = new WP_Query($args);
    $posts = [];
    
    while ($query->have_posts()) {
        $query->the_post();
        $post_id = get_the_ID();
        
        $posts[] = [
            'id' => $post_id,
            'title' => get_the_title(),
            'excerpt' => get_the_excerpt(),
            'date' => get_the_date('c'),
            'author' => get_the_author(),
            'featured_image' => get_the_post_thumbnail_url($post_id, 'medium'),
        ];
    }
    
    wp_reset_postdata();
    
    $response_data = [
        'page' => $page,
        'per_page' => $per_page,
        'total' => $query->found_posts,
        'total_pages' => $query->max_num_pages,
        'posts' => $posts,
    ];
    
    // 保存到缓存
    wp_cache_set($cache_key, $response_data, $cache_group, $expiration);
    
    // 添加缓存头，让客户端知道这是缓存数据
    $response = rest_ensure_response($response_data);
    $response->header('X-Cache', 'MISS');
    $response->header('X-Cache-Key', $cache_key);
    $response->header('X-Cache-Expires', $expiration);
    
    return $response;
}

// 清除特定缓存
function clear_posts_cache($page = null, $per_page = null) {
    if ($page) {
        $cache_key = 'rest_posts_' . $page . '_' . $per_page . '_*';
        // 这里需要实现通配符缓存清除逻辑
    } else {
        // 清除所有相关缓存
        wp_cache_flush_group('rest_api');
    }
}

// 在文章更新时清除缓存
add_action('save_post', function($post_id, $post, $update) {
    if ($post->post_type === 'post' && $post->post_status === 'publish') {
        clear_posts_cache();
    }
}, 10, 3);

对于复杂的API端点，需要更强大的验证机制：

// 创建验证器类
class REST_API_Validator {
    private $errors = [];
    
    public function validate($data, $rules) {
        foreach ($rules as $field => $rule) {
            if (!isset($data[$field]) && !empty($rule['required'])) {
                $this->add_error($field, "字段 {$field} 是必需的");
                continue;
            }
            
            $value = $data[$field] ?? null;
            
            // 执行验证规则
            foreach ($rule as $rule_name => $rule_value) {
                $method = "validate_{$rule_name}";
                if (method_exists($this, $method)) {
                    $this->$method($field, $value, $rule_value);
                }
            }
        }
        
        return empty($this->errors);
    }
    
    private function validate_email($field, $value, $rule_value) {
        if ($rule_value && !is_email($value)) {
            $this->add_error($field, "{$field} 必须是有效的邮箱地址");
        }
    }
    
    private function validate_min_length($field, $value, $min_length) {
        if (strlen($value) < $min_length) {
            $this->add_error($field, "{$field} 长度不能少于 {$min_length} 个字符");
        }
    }
    
    private function validate_regex($field, $value, $pattern) {
        if (!preg_match($pattern, $value)) {
            $this->add_error($field, "{$field} 格式不正确");
        }
    }
    
    private function validate_custom($field, $value, $callback) {
        if (is_callable($callback) && !$callback($value)) {
            $this->add_error($field, "{$field} 验证失败");
        }
    }
    
    private function add_error($field, $message) {
        $this->errors[$field] = $message;
    }
    
    public function get_errors() {
        return $this->errors;
    }
    
    public function get_wp_error() {
        if (empty($this->errors)) {
            return null;
        }
        
        $error = new WP_Error();
        foreach ($this->errors as $field => $message) {
            $error->add("invalid_{$field}", $message, ['field' => $field]);
        }
        
        return $error;
    }
}

// 在API端点中使用验证器
register_rest_route('myplugin/v1', '/user/register', [
    'methods' => 'POST',
    'callback' => function($request) {
        $data = $request->get_params();
        
        $validator = new REST_API_Validator();
        $rules = [
            'username' => [
                'required' => true,
                'min_length' => 3,
                'max_length' => 20,
                'regex' => '/^[a-zA-Z0-9_]+$/',
                'custom' => function($value) {
                    return !username_exists($value);
                }
            ],
            'email' => [
                'required' => true,
                'email' => true,
                'custom' => function($value) {
                    return !email_exists($value);
                }
            ],
            'password' => [
                'required' => true,
                'min_length' => 8,
                'custom' => function($value) {
                    // 密码强度检查
                    return preg_match('/[A-Z]/', $value) && 
                           preg_match('/[a-z]/', $value) && 
                           preg_match('/[0-9]/', $value);
                }
            ]
        ];
        
        if (!$validator->validate($data, $rules)) {
            return $validator->get_wp_error();
        }
        
        // 创建用户
        $user_id = wp_create_user(
            $data['username'],
            $data['password'],
            $data['email']
        );
        
        if (is_wp_error($user_id)) {
            return $user_id;
        }
        
        return rest_ensure_response([
            'success' => true,
            'user_id' => $user_id,
            'message' => '用户注册成功'
        ]);
    },
    'permission_callback' => '__return_true'
]);

确保API数据安全是至关重要的：

// 安全的数据处理函数
function safe_api_response($data) {
    if (is_array($data)) {
        return array_map('safe_api_response', $data);
    }
    
    if (is_object($data)) {
        $object_vars = get_object_vars($data);
        foreach ($object_vars as $key => $value) {
            $data->$key = safe_api_response($value);
        }
        return $data;
    }
    
    if (is_string($data)) {
        // 根据上下文决定转义方式
        if (is_html_context($data)) {
            return wp_kses_post($data);
        } else {
            return esc_html($data);
        }
    }
    
    return $data;
}

// 判断字符串是否包含HTML
function is_html_context($string) {
    return $string !== strip_tags($string);
}

// 在API响应中使用
function get_safe_post_data($post_id) {
    $post = get_post($post_id);
    
    if (!$post) {
        return null;
    }
    
    $data = [
        'id' => (int) $post->ID,
        'title' => $post->post_title,
        'content' => apply_filters('the_content', $post->post_content),
        'excerpt' => $post->post_excerpt,
        'date' => $post->post_date,
        'modified' => $post->post_modified,
        'author' => [
            'id' => (int) $post->post_author,
            'name' => get_the_author_meta('display_name', $post->post_author),
        ],
        'meta' => get_post_meta($post_id),
    ];
    
    // 清理所有数据
    return safe_api_response($data);
}

对于需要长时间处理的任务，应该使用异步处理：

// 异步任务处理系统
class Async_API_Handler {
    private static $instance = null;
    private $background_processor;
    
    public static function get_instance() {
        if (null === self::$instance) {
            self::$instance = new self();
        }
        return self::$instance;
    }
    
    private function __construct() {
        // 初始化后台处理器
        add_action('init', [$this, 'init_background_processor']);
        
        // 注册REST API端点
        add_action('rest_api_init', [$this, 'register_routes']);
        
        // 计划任务清理
        add_action('async_api_cleanup', [$this, 'cleanup_old_tasks']);
    }
    
    public function init_background_processor() {
        if (!class_exists('WP_Background_Process')) {
            require_once plugin_dir_path(__FILE__) . 'lib/wp-background-process.php';
        }
        
        require_once plugin_dir_path(__FILE__) . 'class-async-task-processor.php';
        $this->background_processor = new Async_Task_Processor();
    }
    
    public function register_routes() {
        // 提交异步任务
        register_rest_route('async/v1', '/task', [
            'methods' => 'POST',
            'callback' => [$this, 'submit_task'],
            'args' => [
                'type' => [
                    'required' => true,
                    'validate_callback' => function($param) {
                        return in_array($param, ['export', 'import', 'process', 'generate']);
                    }
                ],
                'data' => [
                    'required' => true,
                    'validate_callback' => function($param) {
                        return is_array($param);
                    }
                ]
            ],
            'permission_callback' => function() {
                return current_user_can('manage_options');
            }
        ]);
        
        // 检查任务状态
        register_rest_route('async/v1', '/task/(?P<task_id>[a-f0-9-]+)', [
            'methods' => 'GET',
            'callback' => [$this, 'check_task_status'],
            'args' => [
                'task_id' => [
                    'required' => true,
                    'validate_callback' => function($param) {
                        return preg_match('/^[a-f0-9-]{36}$/', $param);
                    }
                ]
            ],
            'permission_callback' => '__return_true'

实操指南：调试REST API接口错误的4个排查技巧

假设我们在开发一个WordPress插件，需要创建一个自定义REST API端点来获取用户数据。端点已经创建，但每次调用都返回500内部服务器错误。

溯源库®作者

联系我们

微信扫一扫关注我们

假设我们在开发一个WordPress插件，需要创建一个自定义REST API端点来获取用户数据。端点已经创建，但每次调用都返回500内部服务器错误。

相关文章：

溯源库®作者

为您推荐

一人公司突围利器：漳州柔性供应链的小批量定制全链路支持

AI赋能一人公司：漳州柔性供应链打造小批量定制新范式

4个阶段利用软件实现商品主图的智能优化

5步轻松管理跨境电商的轻量级内容日历

联系我们

微信扫一扫关注我们