实操指南：提升WordPress API接口响应性能的7个优化秘诀

引言：为什么WordPress API性能优化至关重要

在当今快速发展的数字世界中，API接口响应速度直接影响用户体验和系统效率。对于基于WordPress构建的网站和应用来说，API性能优化尤为关键。WordPress作为全球最流行的内容管理系统，其REST API为开发者提供了强大的扩展能力，但默认配置往往无法满足高性能需求。

据统计，网站加载时间每增加1秒，转化率可能下降7%，页面浏览量减少11%。对于依赖API的现代Web应用，响应延迟更是直接影响用户留存率。本文将从WordPress开发实践出发，为行业新人和程序员提供7个经过验证的API性能优化秘诀，帮助您构建更高效的WordPress应用。

秘诀一：优化数据库查询与索引策略

1.1 识别并优化慢查询

WordPress API性能瓶颈往往源于数据库查询。首先需要识别哪些查询最耗时：

// 启用WordPress查询监控
define('SAVEQUERIES', true);

// 在页面底部显示查询信息
if (current_user_can('administrator')) {
    global $wpdb;
    echo '<pre>';
    print_r($wpdb->queries);
    echo '</pre>';
}

1.2 添加适当的数据库索引

为常用的查询字段添加索引可以显著提升性能：

-- 为postmeta表添加复合索引
ALTER TABLE wp_postmeta ADD INDEX idx_post_meta_key (post_id, meta_key);

-- 为用户查询添加索引
ALTER TABLE wp_users ADD INDEX idx_user_login (user_login);
ALTER TABLE wp_users ADD INDEX idx_user_email (user_email);

1.3 使用高效的查询方法

避免在循环中进行数据库查询，使用WP_Query的meta_query参数批量获取数据：

// 不推荐的写法：循环中查询
$posts = get_posts(['numberposts' => 10]);
foreach ($posts as $post) {
    $meta_value = get_post_meta($post->ID, 'custom_field', true);
    // 处理逻辑
}

// 推荐的写法：批量查询
$args = [
    'numberposts' => 10,
    'meta_query' => [
        [
            'key' => 'custom_field',
            'compare' => 'EXISTS'
        ]
    ]
];
$posts = get_posts($args);

秘诀二：实施高效的数据缓存机制

2.1 WordPress对象缓存深度应用

WordPress内置对象缓存机制，但默认使用非持久化缓存。推荐使用Redis或Memcached：

// 在wp-config.php中配置Redis缓存
define('WP_REDIS_HOST', '127.0.0.1');
define('WP_REDIS_PORT', 6379);
define('WP_REDIS_TIMEOUT', 1);
define('WP_REDIS_READ_TIMEOUT', 1);

// 自定义API端点缓存示例
function get_cached_api_data($endpoint, $expiration = 3600) {
    $cache_key = 'api_data_' . md5($endpoint);
    $data = wp_cache_get($cache_key);
    
    if (false === $data) {
        $response = wp_remote_get($endpoint);
        $data = wp_remote_retrieve_body($response);
        wp_cache_set($cache_key, $data, '', $expiration);
    }
    
    return $data;
}

2.2 瞬态API的高级用法

对于需要过期时间的缓存，使用WordPress瞬态API：

// 设置带过期时间的缓存
function get_expensive_api_response($params) {
    $transient_key = 'api_res_' . md5(serialize($params));
    $result = get_transient($transient_key);
    
    if (false === $result) {
        $result = expensive_database_operation($params);
        // 缓存12小时
        set_transient($transient_key, $result, 12 * HOUR_IN_SECONDS);
    }
    
    return $result;
}

// 批量删除相关瞬态
function clear_api_transients($pattern) {
    global $wpdb;
    $wpdb->query(
        $wpdb->prepare(
            "DELETE FROM {$wpdb->options} WHERE option_name LIKE %s",
            '_transient_' . $pattern . '%'
        )
    );
}

秘诀三：精简API响应数据与字段选择

3.1 自定义REST API字段

默认WordPress REST API返回大量不必要的数据。通过注册自定义字段或修改响应结构来精简数据：

// 注册精简的用户端点
add_action('rest_api_init', function() {
    // 精简用户端点响应
    register_rest_route('custom/v1', '/users/minimal', [
        'methods' => 'GET',
        'callback' => 'get_minimal_users',
        'permission_callback' => '__return_true'
    ]);
    
    // 修改默认用户端点
    add_filter('rest_prepare_user', 'simplify_user_response', 10, 3);
});

function get_minimal_users() {
    $users = get_users(['number' => 50]);
    $result = [];
    
    foreach ($users as $user) {
        $result[] = [
            'id' => $user->ID,
            'name' => $user->display_name,
            'avatar' => get_avatar_url($user->ID)
        ];
    }
    
    return new WP_REST_Response($result, 200);
}

function simplify_user_response($response, $user, $request) {
    $data = $response->get_data();
    
    // 只保留必要字段
    $simplified = [
        'id' => $data['id'],
        'name' => $data['name'],
        'slug' => $data['slug'],
        'avatar' => get_avatar_url($data['id'])
    ];
    
    // 根据请求参数决定是否返回更多字段
    if ($request->get_param('full')) {
        $simplified['email'] = $data['email'];
        $simplified['registered'] = $data['registered_date'];
    }
    
    $response->set_data($simplified);
    return $response;
}

3.2 实现字段选择器

允许API消费者指定需要的字段，进一步减少数据传输量：

add_filter('rest_post_query', 'add_fields_parameter', 10, 2);

function add_fields_parameter($args, $request) {
    $fields = $request->get_param('fields');
    
    if ($fields) {
        add_filter('posts_pre_query', function($posts, $query) use ($fields) {
            // 修改查询只选择指定字段
            global $wpdb;
            $field_array = explode(',', $fields);
            $field_array = array_map('trim', $field_array);
            $field_array = array_filter($field_array);
            
            if (!empty($field_array)) {
                $query->query_fields = [];
                foreach ($field_array as $field) {
                    if (in_array($field, ['ID', 'post_title', 'post_name', 'post_date'])) {
                        $query->query_fields[] = $wpdb->posts . '.' . $field;
                    }
                }
                
                if (empty($query->query_fields)) {
                    $query->query_fields = [$wpdb->posts . '.ID'];
                }
            }
            
            return $posts;
        }, 10, 2);
    }
    
    return $args;
}

秘诀四：实施分页与延迟加载策略

4.1 智能分页实现

避免一次性加载大量数据，实现高效的分页机制：

// 自定义分页API端点
add_action('rest_api_init', function() {
    register_rest_route('optimized/v1', '/posts', [
        'methods' => 'GET',
        'callback' => 'get_paginated_posts',
        'args' => [
            'page' => [
                'default' => 1,
                'validate_callback' => function($param) {
                    return is_numeric($param) && $param > 0;
                }
            ],
            'per_page' => [
                'default' => 10,
                'validate_callback' => function($param) {
                    return is_numeric($param) && $param > 0 && $param <= 100;
                }
            ]
        ]
    ]);
});

function get_paginated_posts($request) {
    $page = $request->get_param('page');
    $per_page = $request->get_param('per_page');
    $offset = ($page - 1) * $per_page;
    
    $args = [
        'post_type' => 'post',
        'post_status' => 'publish',
        'posts_per_page' => $per_page,
        'offset' => $offset,
        'fields' => 'ids', // 先只获取ID
        'no_found_rows' => false, // 需要分页信息
    ];
    
    $query = new WP_Query($args);
    
    // 批量获取文章数据
    $posts_data = [];
    if ($query->have_posts()) {
        $post_ids = $query->posts;
        $posts_data = get_posts_data_batch($post_ids);
    }
    
    $total_posts = $query->found_posts;
    $total_pages = ceil($total_posts / $per_page);
    
    $response = new WP_REST_Response([
        'page' => $page,
        'per_page' => $per_page,
        'total_items' => $total_posts,
        'total_pages' => $total_pages,
        'data' => $posts_data
    ]);
    
    // 添加分页头信息
    $response->header('X-WP-Total', $total_posts);
    $response->header('X-WP-TotalPages', $total_pages);
    
    return $response;
}

function get_posts_data_batch($post_ids) {
    if (empty($post_ids)) return [];
    
    global $wpdb;
    $ids_string = implode(',', array_map('intval', $post_ids));
    
    // 批量查询文章数据
    $posts = $wpdb->get_results(
        "SELECT ID, post_title, post_excerpt, post_date 
         FROM {$wpdb->posts} 
         WHERE ID IN ({$ids_string}) 
         ORDER BY FIELD(ID, {$ids_string})"
    );
    
    // 批量查询meta数据
    $meta_data = $wpdb->get_results(
        "SELECT post_id, meta_key, meta_value 
         FROM {$wpdb->postmeta} 
         WHERE post_id IN ({$ids_string}) 
         AND meta_key IN ('_thumbnail_id', 'custom_field')"
    );
    
    // 组合数据
    $result = [];
    foreach ($posts as $post) {
        $post_data = [
            'id' => $post->ID,
            'title' => $post->post_title,
            'excerpt' => $post->post_excerpt,
            'date' => $post->post_date,
            'meta' => []
        ];
        
        // 添加meta数据
        foreach ($meta_data as $meta) {
            if ($meta->post_id == $post->ID) {
                $post_data['meta'][$meta->meta_key] = $meta->meta_value;
            }
        }
        
        $result[] = $post_data;
    }
    
    return $result;
}

秘诀五：优化图片与媒体处理

5.1 智能图片尺寸加载

避免在API响应中返回原始图片URL，根据客户端需求返回适当尺寸：

add_filter('rest_prepare_post', 'optimize_post_images', 10, 3);

function optimize_post_images($response, $post, $request) {
    $data = $response->get_data();
    
    // 检查客户端支持的图片尺寸
    $image_size = $request->get_param('image_size') ?: 'medium';
    
    // 优化特色图片
    if (has_post_thumbnail($post->ID)) {
        $thumbnail_id = get_post_thumbnail_id($post->ID);
        $data['featured_image'] = [
            'original' => wp_get_attachment_url($thumbnail_id),
            'optimized' => wp_get_attachment_image_src($thumbnail_id, $image_size)[0],
            'thumbnail' => wp_get_attachment_image_src($thumbnail_id, 'thumbnail')[0],
            'medium' => wp_get_attachment_image_src($thumbnail_id, 'medium')[0],
            'large' => wp_get_attachment_image_src($thumbnail_id, 'large')[0]
        ];
    }
    
    // 处理内容中的图片
    $content = $post->post_content;
    $data['content'] = optimize_content_images($content, $image_size);
    
    $response->set_data($data);
    return $response;
}

function optimize_content_images($content, $size = 'medium') {
    // 使用正则表达式查找并替换图片
    $pattern = '/<img[^>]+src="([^">]+)"[^>]*>/i';
    
    return preg_replace_callback($pattern, function($matches) use ($size) {
        $original_src = $matches[1];
        
        // 如果是WordPress媒体库图片
        $attachment_id = attachment_url_to_postid($original_src);
        
        if ($attachment_id) {
            $optimized_src = wp_get_attachment_image_src($attachment_id, $size);
            if ($optimized_src) {
                return str_replace($original_src, $optimized_src[0], $matches[0]);
            }
        }
        
        return $matches[0];
    }, $content);
}

5.2 实现图片懒加载API

// 图片懒加载API端点
add_action('rest_api_init', function() {
    register_rest_route('media/v1', '/lazy-load', [
        'methods' => 'POST',
        'callback' => 'handle_lazy_load',
        'permission_callback' => '__return_true'
    ]);
});

function handle_lazy_load($request) {
    $image_ids = $request->get_param('image_ids');
    $size = $request->get_param('size') ?: 'thumbnail';
    
    if (empty($image_ids) || !is_array($image_ids)) {
        return new WP_Error('invalid_params', 'Invalid image IDs', ['status' => 400]);
    }
    
    $results = [];
    foreach ($image_ids as $id) {
        $attachment_id = intval($id);
        
        if ($attachment_id) {
            $image_data = wp_get_attachment_image_src($attachment_id, $size);
            $image_meta = wp_get_attachment_metadata($attachment_id);
            
            if ($image_data) {
                $results[$attachment_id] = [
                    'url' => $image_data[0],
                    'width' => $image_data[1],
                    'height' => $image_data[2],
                    'alt' => get_post_meta($attachment_id, '_wp_attachment_image_alt', true),
                    'caption' => wp_get_attachment_caption($attachment_id)
                ];
            }
        }
    }
    
    return new WP_REST_Response($results, 200);
}

秘诀六：启用Gzip压缩与CDN加速

6.1 服务器层压缩配置

在.htaccess（Apache）或服务器配置中启用Gzip压缩：

# Apache .htaccess配置
<IfModule mod_deflate.c>
    # 启用压缩
    AddOutputFilterByType DEFLATE application/json
    AddOutputFilterByType DEFLATE application/javascript
    AddOutputFilterByType DEFLATE application/rss+xml
    AddOutputFilterByType DEFLATE application/vnd.ms-fontobject
    AddOutputFilterByType DEFLATE application/x-font
    AddOutputFilterByType DEFLATE application/x-font-opentype
    AddOutputFilterByType DEFLATE application/x-font-otf
    AddOutputFilterByType DEFLATE application/x-font-truetype
    AddOutputFilterByType DEFLATE application/x-font-ttf
    AddOutputFilterByType DEFLATE application/x-javascript
    AddOutputFilterByType DEFLATE application/xhtml+xml
    AddOutputFilterByType DEFLATE application/xml
    AddOutputFilterByType DEFLATE font/opentype
    AddOutputFilterByType DEFLATE font/otf
    AddOutputFilterByType DEFLATE font/ttf
    AddOutputFilterByType DEFLATE image/svg+xml
    AddOutputFilterByType DEFLATE image/x-icon
    AddOutputFilterByType DEFLATE text/css
    AddOutputFilterByType DEFLATE text/html
    AddOutputFilterByType DEFLATE text/javascript
    AddOutputFilterByType DEFLATE text/plain
    AddOutputFilterByType DEFLATE text/xml
</IfModule>

6.2 WordPress CDN集成

通过代码集成CDN，加速静态资源加载：

// 在functions.php中集成CDN
function configure_cdn_for_api() {
    // 只在API请求中启用CDN
    if (defined('REST_REQUEST') && REST_REQUEST) {
        add_filter('wp_get_attachment_url', 'replace_with_cdn_url', 10, 2);
        add_filter('stylesheet_uri', 'replace_with_cdn_url');
        add_filter('script_loader_src', 'replace_with_cdn_url');
        add_filter('style_loader_src', 'replace_with_cdn_url');
    }
}
add_action('init', 'configure_cdn_for_api');

function replace_with_cdn_url($url) {
    $cdn_domain = 'https://cdn.yourdomain.com';
    $site_domain = site_url();
    
    // 替换域名部分
    if (strpos($url, $site_domain) !== false) {
        $url = str_replace($site_domain, $cdn_domain, $url);
    }
    
    return $url;
}

// API响应中添加CDN头部信息
add_filter('rest_pre_serve_request', 'add_cdn_headers', 10, 4);

function add_cdn_headers($served, $result, $request, $server) {
    if (is_wp_error($result)) {
        return $served;
    }
    
    // 添加CDN缓存头

max-age=3600, s-maxage=7200');

header('CDN-Cache-Control: public, max-age=7200');
header('Vary: Accept-Encoding');

return $served;

}

## 秘诀七：监控、分析与持续优化

### 7.1 实施API性能监控

创建自定义的性能监控端点，收集关键指标：

// API性能监控端点
add_action('rest_api_init', function() {

register_rest_route('monitor/v1', '/performance', [
    'methods' => 'GET',
    'callback' => 'get_api_performance',
    'permission_callback' => function() {
        return current_user_can('manage_options'); // 仅管理员可访问
    }
]);

// 性能日志端点
register_rest_route('monitor/v1', '/log-performance', [
    'methods' => 'POST',
    'callback' => 'log_api_performance',
    'permission_callback' => '__return_true'
]);

});

function get_api_performance() {

global $wpdb;

// 获取最近24小时的性能数据
$results = $wpdb->get_results(
    $wpdb->prepare(
        "SELECT endpoint, 
                AVG(response_time) as avg_time,
                MIN(response_time) as min_time,
                MAX(response_time) as max_time,
                COUNT(*) as request_count,
                AVG(memory_used) as avg_memory
         FROM {$wpdb->prefix}api_performance_logs
         WHERE logged_at > DATE_SUB(NOW(), INTERVAL 24 HOUR)
         GROUP BY endpoint
         ORDER BY avg_time DESC
         LIMIT 20"
    )
);

// 获取慢查询统计
$slow_queries = $wpdb->get_results(
    "SELECT query, COUNT(*) as count, AVG(time) as avg_time
     FROM {$wpdb->prefix}slow_query_logs
     WHERE logged_at > DATE_SUB(NOW(), INTERVAL 24 HOUR)
     GROUP BY query
     HAVING avg_time > 0.5
     ORDER BY avg_time DESC
     LIMIT 10"
);

return new WP_REST_Response([
    'endpoint_performance' => $results,
    'slow_queries' => $slow_queries,
    'server_stats' => [
        'memory_usage' => memory_get_usage(true) / 1024 / 1024 . ' MB',
        'peak_memory' => memory_get_peak_usage(true) / 1024 / 1024 . ' MB',
        'load_average' => function_exists('sys_getloadavg') ? sys_getloadavg() : 'N/A'
    ]
], 200);

}

function log_api_performance($request) {

$data = $request->get_json_params();

global $wpdb;

$wpdb->insert(
    $wpdb->prefix . 'api_performance_logs',
    [
        'endpoint' => sanitize_text_field($data['endpoint']),
        'response_time' => floatval($data['response_time']),
        'memory_used' => intval($data['memory_used']),
        'http_status' => intval($data['http_status']),
        'user_agent' => sanitize_text_field($data['user_agent']),
        'logged_at' => current_time('mysql')
    ]
);

return new WP_REST_Response(['success' => true], 200);

}

// 创建性能监控表
function create_performance_tables() {

global $wpdb;

$charset_collate = $wpdb->get_charset_collate();

$sql1 = "CREATE TABLE IF NOT EXISTS {$wpdb->prefix}api_performance_logs (
    id bigint(20) NOT NULL AUTO_INCREMENT,
    endpoint varchar(500) NOT NULL,
    response_time float NOT NULL,
    memory_used int(11) NOT NULL,
    http_status int(11) NOT NULL,
    user_agent varchar(500),
    logged_at datetime NOT NULL,
    PRIMARY KEY (id),
    KEY idx_endpoint (endpoint(100)),
    KEY idx_logged_at (logged_at)
) $charset_collate;";

$sql2 = "CREATE TABLE IF NOT EXISTS {$wpdb->prefix}slow_query_logs (
    id bigint(20) NOT NULL AUTO_INCREMENT,
    query text NOT NULL,
    time float NOT NULL,
    backtrace text,
    logged_at datetime NOT NULL,
    PRIMARY KEY (id),
    KEY idx_logged_at (logged_at)
) $charset_collate;";

require_once(ABSPATH . 'wp-admin/includes/upgrade.php');
dbDelta($sql1);
dbDelta($sql2);

}
register_activation_hook(__FILE__, 'create_performance_tables');

### 7.2 自动化性能测试与警报

// 自动化性能测试
class API_Performance_Tester {

private $test_endpoints = [];

public function __construct() {
    $this->test_endpoints = [
        '/wp-json/wp/v2/posts' => ['per_page' => 10],
        '/wp-json/wp/v2/users' => ['per_page' => 5],
        // 添加更多测试端点
    ];
    
    // 每天凌晨运行性能测试
    if (!wp_next_scheduled('run_daily_performance_tests')) {
        wp_schedule_event(strtotime('02:00:00'), 'daily', 'run_daily_performance_tests');
    }
    
    add_action('run_daily_performance_tests', [$this, 'run_tests']);
}

public function run_tests() {
    $results = [];
    
    foreach ($this->test_endpoints as $endpoint => $params) {
        $url = home_url($endpoint);
        if (!empty($params)) {
            $url = add_query_arg($params, $url);
        }
        
        $start_time = microtime(true);
        $start_memory = memory_get_usage(true);
        
        $response = wp_remote_get($url, [
            'timeout' => 30,
            'headers' => [
                'User-Agent' => 'API Performance Tester/1.0'
            ]
        ]);
        
        $end_time = microtime(true);
        $end_memory = memory_get_usage(true);
        
        $response_time = round(($end_time - $start_time) * 1000, 2); // 毫秒
        $memory_used = $end_memory - $start_memory;
        
        $results[$endpoint] = [
            'response_time' => $response_time,
            'memory_used' => $memory_used,
            'success' => !is_wp_error($response) && wp_remote_retrieve_response_code($response) === 200,
            'timestamp' => current_time('mysql')
        ];
        
        // 如果响应时间超过阈值，发送警报
        if ($response_time > 1000) { // 1秒阈值
            $this->send_alert($endpoint, $response_time);
        }
        
        // 添加延迟避免服务器过载
        sleep(1);
    }
    
    // 保存测试结果
    $this->save_test_results($results);
}

private function send_alert($endpoint, $response_time) {
    $admin_email = get_option('admin_email');
    $subject = 'API性能警报: ' . $endpoint . ' 响应缓慢';
    $message = "端点: {$endpoint}n响应时间: {$response_time}msn时间: " . current_time('mysql');
    
    wp_mail($admin_email, $subject, $message);
}

private function save_test_results($results) {
    $history = get_option('api_performance_history', []);
    $history[date('Y-m-d')] = $results;
    
    // 只保留最近30天的记录
    if (count($history) > 30) {
        ksort($history);
        $history = array_slice($history, -30, 30, true);
    }
    
    update_option('api_performance_history', $history);
}

public function get_performance_report() {
    $history = get_option('api_performance_history', []);
    
    if (empty($history)) {
        return '暂无性能数据';
    }
    
    $report = [];
    foreach ($history as $date => $tests) {
        foreach ($tests as $endpoint => $data) {
            if (!isset($report[$endpoint])) {
                $report[$endpoint] = [];
            }
            $report[$endpoint][$date] = $data['response_time'];
        }
    }
    
    return $report;
}

}

// 初始化性能测试器
new API_Performance_Tester();

## 实战案例：综合优化WordPress电商API

### 案例背景与挑战

假设我们正在开发一个基于WordPress的电商平台，需要处理以下API性能挑战：
1. 商品列表API响应缓慢（超过3秒）
2. 搜索API在高并发下崩溃
3. 购物车API在促销期间响应延迟

### 综合优化方案

// 电商API综合优化类
class WooCommerce_API_Optimizer {

public function __construct() {
    // 优化商品查询
    add_filter('woocommerce_rest_product_object_query', [$this, 'optimize_product_query'], 10, 2);
    
    // 添加商品缓存
    add_filter('woocommerce_rest_prepare_product_object', [$this, 'cache_product_response'], 10, 3);
    
    // 优化订单查询
    add_action('rest_api_init', [$this, 'register_optimized_order_endpoints']);
    
    // 实施搜索优化
    add_filter('posts_search', [$this, 'optimize_product_search'], 10, 2);
}

public function optimize_product_query($args, $request) {
    // 只选择必要字段
    $args['fields'] = 'ids';
    
    // 添加查询缓存
    $cache_key = 'wc_products_' . md5(serialize($args));
    $cached_ids = wp_cache_get($cache_key, 'woocommerce');
    
    if (false !== $cached_ids) {
        $args['post__in'] = $cached_ids;
        $args['ignore_sticky_posts'] = true;
    } else {
        add_action('pre_get_posts', [$this, 'store_product_query_cache'], 999);
    }
    
    return $args;
}

public function store_product_query_cache($query) {
    if ($query->get('fields') === 'ids') {
        $cache_key = 'wc_products_' . md5(serialize($query->query_vars));
        wp_cache_set($cache_key, $query->posts, 'woocommerce', HOUR_IN_SECONDS);
    }
}

public function cache_product_response($response, $product, $request) {
    $product_id = $product->get_id();
    $cache_key = 'wc_product_full_' . $product_id;
    
    // 检查是否有缓存
    $cached = wp_cache_get($cache_key, 'woocommerce');
    
    if (false !== $cached) {
        return $cached;
    }
    
    $data = $response->get_data();
    
    // 精简响应数据
    $optimized_data = [
        'id' => $data['id'],
        'name' => $data['name'],
        'price' => $data['price'],
        'regular_price' => $data['regular_price'],
        'sale_price' => $data['sale_price'],
        'images' => array_slice($data['images'], 0, 3), // 只保留前3张图片
        'attributes' => $this->simplify_attributes($data['attributes']),
        'stock_status' => $data['stock_status'],
        'in_stock' => $data['in_stock']
    ];
    
    // 根据请求参数添加额外字段
    if ($request->get_param('full_details')) {
        $optimized_data['description'] = $data['description'];
        $optimized_data['short_description'] = $data['short_description'];
        $optimized_data['categories'] = $data['categories'];
        $optimized_data['tags'] = $data['tags'];
    }
    
    $response->set_data($optimized_data);
    
    // 缓存响应
    wp_cache_set($cache_key, $response, 'woocommerce', 15 * MINUTE_IN_SECONDS);
    
    return $response;
}

private function simplify_attributes($attributes) {
    $simplified = [];
    
    foreach ($attributes as $attribute) {
        $simplified[] = [
            'name' => $attribute['name'],
            'options' => array_slice($attribute['options'], 0, 5) // 只保留前5个选项
        ];
    }
    
    return $simplified;
}

public function register_optimized_order_endpoints() {
    // 注册优化的订单历史端点
    register_rest_route('wc-optimized/v1', '/orders/recent', [
        'methods' => 'GET',
        'callback' => [$this, 'get_recent_orders'],
        'permission_callback' => [$this, 'check_order_permissions']
    ]);
    
    // 批量订单状态更新
    register_rest_route('wc-optimized/v1', '/orders/bulk-update', [
        'methods' => 'POST',
        'callback' => [$this, 'bulk_update_orders'],
        'permission_callback' => [$this, 'check_order_permissions']
    ]);
}

public function get_recent_orders($request) {
    $user_id = get_current_user_id();
    $page = $request->get_param('page') ?: 1;
    $per_page = $request->get_param('per_page') ?: 10;
    
    $cache_key = 'user_orders_' . $user_id . '_' . $page . '_' . $per_page;
    $cached = wp_cache_get($cache_key, 'woocommerce');
    
    if (false !== $cached) {
        return $cached;
    }
    
    $args = [
        'customer_id' => $user_id,
        'limit' => $per_page,
        'page' => $page,
        'orderby' => 'date',
        'order' => 'DESC',
        'return' => 'ids'
    ];
    
    $order_ids = wc_get_orders($args);
    $orders_data = [];
    
    // 批量获取订单数据
    foreach ($order_ids as $order_id) {
        $order = wc_get_order($order_id);
        
        if ($order) {
            $orders_data[] = [
                'id' => $order_id,
                'date' => $order->get_date_created()->date('Y-m-d H:i:s'),
                'status' => $order->get_status(),
                'total' => $order->get_total(),
                'item_count' => $order->get_item_count(),
                'view_url' => $order->get_view_order_url()
            ];
        }
    }
    
    $response = new WP_REST_Response([
        'page' => $page,
        'per_page' => $per_page,
        'orders' => $orders_data
    ]);
    
    // 缓存5分钟
    wp_cache_set($cache_key, $response, 'woocommerce', 5 * MINUTE_IN_SECONDS);
    
    return $response;
}

public function optimize_product_search($search, $wp_query) {
    if (!is_admin() && $wp_query->is_search() && $wp_query->get('post_type') === 'product') {
        global $wpdb;
        
        // 使用更高效的搜索查询
        $search_terms = get_query_var('search_terms');
        
        if (!empty($search_terms)) {
            $search = '';
            
            foreach ($search_terms as $term) {
                if (!empty($search)) {
                    $search .= " OR ";
                }
                
                $term = esc_sql($wpdb->esc_like($term));
                
                // 搜索标题和SKU
                $search .= "(
                    ({$wpdb->posts}.post_title LIKE '%{$term}%')
                    OR EXISTS (
                        SELECT 1 FROM {$wpdb->postmeta}
                        WHERE {$wpdb->postmeta}.post_id = {$wpdb->posts}.ID
                        AND {$wpdb->postmeta}.meta_key = '_sku'
                        AND {$wpdb->postmeta}.meta_value LIKE '%{$term}%'
                    )
                )";
            }
            
            if (!empty($search)) {
                $search = " AND ({$search})";
            }
        }
    }
    
    return $search;
}

public function check_order_permissions() {
    return is_user_logged_in();
}

}

// 初始化电商优化器
new WooCommerce_API_Optimizer();

## 性能优化效果评估与持续改进

### 8.1 建立性能基准与KPI

// 性能基准测试类
class API_Benchmark {

private $baseline_metrics = [];

public function __construct() {
    $this->load_baseline();
    add_action('rest_api_init', [$this, 'register_benchmark_endpoints']);
}

public function register_benchmark_endpoints() {
    register_rest_route('benchmark/v1', '/run', [
        'methods' => 'POST',
        'callback' => [$this, 'run_benchmark'],
        'permission_callback' => function() {
            return current_user_can('manage_options');
        }
    ]);
    
    register_rest_route('benchmark/v1', '/compare', [
        'methods' => 'GET',
        'callback' => [$this, 'compare_with_baseline'],
        'permission_callback' => function() {
            return current_user_can('manage_options');
        }
    ]);
}

public function run_benchmark($request) {
    $endpoints = $request->get_param('endpoints') ?: $this->get_default_endpoints();
    $iterations = $request->get_param('iterations') ?: 10;
    $concurrent = $request->get_param('concurrent') ?: 3;
    
    $results = [];