发布于 由admin

WordPress wp_count_comments函数在大数据评论表中的性能优化思路

WordPress wp_count_comments 函数在大数据评论表中的性能优化

大家好，今天我们来深入探讨一下 WordPress 中 wp_count_comments 函数在大数据评论表下的性能优化。wp_count_comments 是一个核心函数，用于统计文章的评论数量，包括不同状态的评论（例如：待审核、已批准、垃圾评论等）。 当评论数量巨大时，这个函数的性能会成为一个瓶颈，直接影响网站的加载速度和用户体验。 本次讲座将从 wp_count_comments 的源码分析入手，逐步讲解优化思路，并提供相应的代码示例。

1. wp_count_comments 函数源码分析

首先，我们来了解一下 wp_count_comments 函数的源码，以便更好地理解其运作方式和潜在的性能问题。 以下是简化后的核心代码（基于 WordPress 6.4.3）：

function wp_count_comments( $post_id = 0 ) {
    global $wpdb;

    $post_id = absint( $post_id );

    $stats = wp_cache_get( "comments-{$post_id}", 'counts' );

    if ( false !== $stats ) {
        /** This filter is documented in wp-includes/comment.php */
        return apply_filters( 'wp_count_comments', $stats, $post_id );
    }

    $where = 'WHERE comment_approved != %s';
    $where_args = array( 'spam' );

    if ( $post_id > 0 ) {
        $where .= ' AND comment_post_ID = %d';
        $where_args[] = $post_id;
    }

    $counts = (array) $wpdb->get_results( $wpdb->prepare(
        "SELECT comment_approved, COUNT(comment_ID) AS num_comments FROM {$wpdb->comments} {$where} GROUP BY comment_approved",
        $where_args
    ), ARRAY_A );

    $approved = 0;
    $awaiting_moderation = 0;
    $spam = 0;
    $trash = 0;

    foreach ( $counts as $row ) {
        switch ( $row['comment_approved'] ) {
            case 'trash':
                $trash = (int) $row['num_comments'];
                break;
            case 'spam':
                $spam = (int) $row['num_comments'];
                break;
            case '1':
                $approved = (int) $row['num_comments'];
                break;
            case '0':
                $awaiting_moderation = (int) $row['num_comments'];
                break;
            default:
                $approved = (int) $row['num_comments'];
        }
    }

    $stats = (object) array(
        'approved'            => $approved,
        'awaiting_moderation' => $awaiting_moderation,
        'spam'                => $spam,
        'trash'               => $trash,
        'total_comments'      => $approved + $awaiting_moderation + $spam + $trash,
    );

    wp_cache_set( "comments-{$post_id}", $stats, 'counts' );

    /** This filter is documented in wp-includes/comment.php */
    return apply_filters( 'wp_count_comments', $stats, $post_id );
}

关键点分析：

  • 缓存机制: 函数首先尝试从 wp_cache 中获取评论统计数据。 如果缓存命中，则直接返回缓存数据，这是最快的路径。
  • SQL 查询: 如果缓存未命中，则执行 SQL 查询从 wp_comments 表中统计评论数量。 查询会根据 comment_approved 字段进行分组，统计不同状态的评论数量。
  • 数据处理: 将 SQL 查询结果处理成包含 approved, awaiting_moderation, spam, trash 和 total_comments 属性的对象。
  • 缓存更新: 将统计结果缓存到 wp_cache 中，以便下次使用。

性能瓶颈分析：

  • 缓存失效： 如果缓存失效频繁，每次都需要执行 SQL 查询，导致性能下降。 例如，评论审核操作、批量评论管理等都会导致缓存失效。
  • 大数据量 SQL 查询： 当 wp_comments 表中的数据量非常大时，SQL 查询的执行时间会显著增加。 GROUP BY 操作在大数据量下尤其耗时。
  • 缺乏索引： 如果 wp_comments 表缺少必要的索引，SQL 查询的性能会进一步下降。 特别是 comment_post_ID 和 comment_approved 字段。

2. 优化思路

针对上述性能瓶颈，我们可以采取以下优化思路：

  1. 优化缓存策略： 尽量减少缓存失效的次数，提高缓存命中率。
  2. 优化 SQL 查询： 减少查询的数据量，优化查询语句，利用索引。
  3. 异步处理： 将评论统计任务异步处理，避免阻塞主请求。
  4. 数据表结构优化： 考虑分表等策略，降低单表的数据量。

3. 具体优化措施

下面我们来详细介绍具体的优化措施，并提供相应的代码示例。

3.1 优化缓存策略

  • 延长缓存时间： 适当延长缓存时间，减少缓存失效的频率。 但需要注意，缓存时间过长可能会导致数据不准确。
  • 细粒度缓存控制： 只在必要时才刷新缓存。 例如，只在特定文章的评论发生变化时才刷新该文章的评论统计缓存。 避免全局刷新缓存。
  • 使用更高效的缓存后端： 如果条件允许，可以使用 Redis 或 Memcached 等更高效的缓存后端，提高缓存的读写速度。

代码示例 (延长缓存时间)：

可以通过 wp_cache_set 函数设置缓存过期时间。 默认情况下，wp_cache_set 使用默认的缓存组（通常是 default），并设置一个相对较短的过期时间（例如几分钟）。 我们可以通过自定义函数来包装 wp_cache_set，并设置更长的过期时间。

function my_wp_cache_set( $key, $data, $group = 'default', $expire = 3600 ) { // 缓存 1 小时
    wp_cache_set( $key, $data, $group, $expire );
}

// 在 wp_count_comments 函数中，替换 wp_cache_set 函数调用：
my_wp_cache_set( "comments-{$post_id}", $stats, 'counts' );

代码示例 (细粒度缓存控制)：

可以使用 WordPress 的 update_post_meta 函数来存储每篇文章的评论更新时间。 当评论发生变化时，更新该文章的评论更新时间。 在 wp_count_comments 函数中，只有当评论更新时间发生变化时才刷新缓存。

// 在评论更新时，更新文章的评论更新时间：
add_action( 'comment_post', 'my_update_comment_timestamp' );
add_action( 'edit_comment', 'my_update_comment_timestamp' );
add_action( 'delete_comment', 'my_update_comment_timestamp' );

function my_update_comment_timestamp( $comment_id ) {
    $comment = get_comment( $comment_id );
    if ( $comment ) {
        update_post_meta( $comment->comment_post_ID, '_comment_last_updated', time() );
    }
}

// 在 wp_count_comments 函数中，增加缓存检查：
function wp_count_comments( $post_id = 0 ) {
    global $wpdb;

    $post_id = absint( $post_id );

    $last_updated = get_post_meta( $post_id, '_comment_last_updated', true );
    $cache_key = "comments-{$post_id}-{$last_updated}"; // 将更新时间加入缓存Key

    $stats = wp_cache_get( $cache_key, 'counts' );

    if ( false !== $stats ) {
        /** This filter is documented in wp-includes/comment.php */
        return apply_filters( 'wp_count_comments', $stats, $post_id );
    }

    // ... (SQL 查询和数据处理代码) ...

    wp_cache_set( $cache_key, $stats, 'counts' );

    /** This filter is documented in wp-includes/comment.php */
    return apply_filters( 'wp_count_comments', $stats, $post_id );
}

3.2 优化 SQL 查询

  • 添加索引： 在 wp_comments 表的 comment_post_ID 和 comment_approved 字段上添加索引。 这是最基本也是最有效的优化措施。 可以使用 ALTER TABLE 语句添加索引。
  • *避免 `SELECT ：** 只选择需要的字段，避免不必要的数据传输。 在wp_count_comments函数中，只需要comment_approved和COUNT(comment_ID)` 字段。
  • 优化 WHERE 子句： 尽量使用索引字段进行查询。 避免在 WHERE 子句中使用函数或表达式，这会导致索引失效。
  • 考虑使用预聚合表： 如果评论统计数据更新不频繁，可以考虑创建一个预聚合表，定期计算评论统计数据，并在 wp_count_comments 函数中直接从预聚合表中读取数据。

代码示例 (添加索引)：

ALTER TABLE wp_comments ADD INDEX comment_post_ID (comment_post_ID);
ALTER TABLE wp_comments ADD INDEX comment_approved (comment_approved);
ALTER TABLE wp_comments ADD INDEX comment_post_ID_approved (comment_post_ID, comment_approved); -- 组合索引

代码示例 (优化 SQL 查询语句)：

function wp_count_comments( $post_id = 0 ) {
    global $wpdb;

    $post_id = absint( $post_id );

    $stats = wp_cache_get( "comments-{$post_id}", 'counts' );

    if ( false !== $stats ) {
        /** This filter is documented in wp-includes/comment.php */
        return apply_filters( 'wp_count_comments', $stats, $post_id );
    }

    $where = 'WHERE comment_approved != %s';
    $where_args = array( 'spam' );

    if ( $post_id > 0 ) {
        $where .= ' AND comment_post_ID = %d';
        $where_args[] = $post_id;
    }

    //  优化后的 SQL 查询
    $counts = (array) $wpdb->get_results( $wpdb->prepare(
        "SELECT comment_approved, COUNT(comment_ID) AS num_comments FROM {$wpdb->comments} {$where} GROUP BY comment_approved",
        $where_args
    ), ARRAY_A );

    // ... (数据处理和缓存更新代码) ...
}

代码示例 (使用预聚合表)：

首先，创建一个预聚合表 wp_comment_counts:

CREATE TABLE `wp_comment_counts` (
  `post_id` bigint(20) unsigned NOT NULL,
  `approved` int(11) NOT NULL DEFAULT '0',
  `awaiting_moderation` int(11) NOT NULL DEFAULT '0',
  `spam` int(11) NOT NULL DEFAULT '0',
  `trash` int(11) NOT NULL DEFAULT '0',
  `total_comments` int(11) NOT NULL DEFAULT '0',
  `last_calculated` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (`post_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

然后，创建一个函数来更新预聚合表：

function my_update_comment_counts( $post_id ) {
    global $wpdb;

    $approved = $wpdb->get_var( $wpdb->prepare( "SELECT COUNT(*) FROM {$wpdb->comments} WHERE comment_post_ID = %d AND comment_approved = '1'", $post_id ) );
    $awaiting_moderation = $wpdb->get_var( $wpdb->prepare( "SELECT COUNT(*) FROM {$wpdb->comments} WHERE comment_post_ID = %d AND comment_approved = '0'", $post_id ) );
    $spam = $wpdb->get_var( $wpdb->prepare( "SELECT COUNT(*) FROM {$wpdb->comments} WHERE comment_post_ID = %d AND comment_approved = 'spam'", $post_id ) );
    $trash = $wpdb->get_var( $wpdb->prepare( "SELECT COUNT(*) FROM {$wpdb->comments} WHERE comment_post_ID = %d AND comment_approved = 'trash'", $post_id ) );
    $total_comments = $approved + $awaiting_moderation + $spam + $trash;

    $wpdb->replace(
        'wp_comment_counts',
        array(
            'post_id'             => $post_id,
            'approved'            => $approved,
            'awaiting_moderation' => $awaiting_moderation,
            'spam'                => $spam,
            'trash'               => $trash,
            'total_comments'      => $total_comments,
        ),
        array( '%d', '%d', '%d', '%d', '%d', '%d' )
    );
}

// 在评论更新时，更新预聚合表：
add_action( 'comment_post', 'my_update_comment_counts_action' );
add_action( 'edit_comment', 'my_update_comment_counts_action' );
add_action( 'delete_comment', 'my_update_comment_counts_action' );

function my_update_comment_counts_action( $comment_id ) {
    $comment = get_comment( $comment_id );
    if ( $comment ) {
        my_update_comment_counts( $comment->comment_post_ID );
    }
}

修改 wp_count_comments 函数，从预聚合表中读取数据：

function wp_count_comments( $post_id = 0 ) {
    global $wpdb;

    $post_id = absint( $post_id );

    $stats = wp_cache_get( "comments-{$post_id}", 'counts' );

    if ( false !== $stats ) {
        /** This filter is documented in wp-includes/comment.php */
        return apply_filters( 'wp_count_comments', $stats, $post_id );
    }

    // 从预聚合表中读取数据
    $comment_counts = $wpdb->get_row( $wpdb->prepare( "SELECT approved, awaiting_moderation, spam, trash, total_comments FROM wp_comment_counts WHERE post_id = %d", $post_id ) );

    if ( $comment_counts ) {
        $stats = (object) array(
            'approved'            => (int) $comment_counts->approved,
            'awaiting_moderation' => (int) $comment_counts->awaiting_moderation,
            'spam'                => (int) $comment_counts->spam,
            'trash'               => (int) $comment_counts->trash,
            'total_comments'      => (int) $comment_counts->total_comments,
        );
    } else {
        // 如果预聚合表中没有数据，则执行原始的 SQL 查询
        $where = 'WHERE comment_approved != %s';
        $where_args = array( 'spam' );

        if ( $post_id > 0 ) {
            $where .= ' AND comment_post_ID = %d';
            $where_args[] = $post_id;
        }

        $counts = (array) $wpdb->get_results( $wpdb->prepare(
            "SELECT comment_approved, COUNT(comment_ID) AS num_comments FROM {$wpdb->comments} {$where} GROUP BY comment_approved",
            $where_args
        ), ARRAY_A );

        $approved = 0;
        $awaiting_moderation = 0;
        $spam = 0;
        $trash = 0;

        foreach ( $counts as $row ) {
            switch ( $row['comment_approved'] ) {
                case 'trash':
                    $trash = (int) $row['num_comments'];
                    break;
                case 'spam':
                    $spam = (int) $row['num_comments'];
                    break;
                case '1':
                    $approved = (int) $row['num_comments'];
                    break;
                case '0':
                    $awaiting_moderation = (int) $row['num_comments'];
                    break;
                default:
                    $approved = (int) $row['num_comments'];
            }
        }

        $stats = (object) array(
            'approved'            => $approved,
            'awaiting_moderation' => $awaiting_moderation,
            'spam'                => $spam,
            'trash'               => $trash,
            'total_comments'      => $approved + $awaiting_moderation + $spam + $trash,
        );

        // 更新预聚合表
        my_update_comment_counts( $post_id );
    }

    wp_cache_set( "comments-{$post_id}", $stats, 'counts' );

    /** This filter is documented in wp-includes/comment.php */
    return apply_filters( 'wp_count_comments', $stats, $post_id );
}

3.3 异步处理

  • 使用 WP-Cron： 将评论统计任务添加到 WP-Cron 中，定期异步执行。 避免在主请求中执行耗时的 SQL 查询。
  • 使用消息队列： 可以使用消息队列（例如：RabbitMQ, Redis List）来异步处理评论统计任务。 当评论发生变化时，将任务添加到消息队列中，由消费者进程异步处理。

代码示例 (使用 WP-Cron)：

// 注册 WP-Cron 事件
add_action( 'wp', 'my_schedule_comment_count_update' );

function my_schedule_comment_count_update() {
    if ( ! wp_next_scheduled( 'my_update_all_comment_counts' ) ) {
        wp_schedule_event( time(), 'hourly', 'my_update_all_comment_counts' ); // 每小时执行一次
    }
}

// 定义 WP-Cron 事件处理函数
add_action( 'my_update_all_comment_counts', 'my_update_all_comment_counts_callback' );

function my_update_all_comment_counts_callback() {
    global $wpdb;

    // 获取所有文章 ID
    $post_ids = $wpdb->get_col( "SELECT ID FROM {$wpdb->posts} WHERE post_status = 'publish' AND post_type = 'post'" );

    // 循环更新每篇文章的评论统计数据
    foreach ( $post_ids as $post_id ) {
        my_update_comment_counts( $post_id );
        wp_cache_delete( "comments-{$post_id}", 'counts' ); // 清除缓存，下次访问时重新生成
    }
}

3.4 数据表结构优化

  • 分表： 如果 wp_comments 表的数据量非常大，可以考虑将评论数据按照时间或文章 ID 进行分表。 例如，可以按照年份创建 wp_comments_2023, wp_comments_2024 等表。
  • 垂直拆分： 将 wp_comments 表中不常用的字段拆分到另一个表中，减少主表的数据量。
  • 数据归档： 将历史评论数据归档到另一个表中，只保留最近的评论数据在主表中。

分表实现思路

分表需要在查询和写入的时候都做相应的逻辑调整。由于 wp_count_comments 主要负责查询，我们需要修改函数，使其能够根据文章的发布时间，查询对应的分表。 写入操作（例如发布评论、审核评论）也需要根据评论的时间，写入到对应的分表中。

代码示例 (分表查询)：

以下代码仅仅是示例， 实际应用中需要考虑更多细节，例如如何确定分表规则，如何处理跨表查询等。

function wp_count_comments( $post_id = 0 ) {
    global $wpdb;

    $post_id = absint( $post_id );

    $stats = wp_cache_get( "comments-{$post_id}", 'counts' );

    if ( false !== $stats ) {
        /** This filter is documented in wp-includes/comment.php */
        return apply_filters( 'wp_count_comments', $stats, $post_id );
    }

    // 获取文章的发布年份
    $post_year = $wpdb->get_var( $wpdb->prepare( "SELECT YEAR(post_date) FROM {$wpdb->posts} WHERE ID = %d", $post_id ) );

    // 确定分表名称
    $comment_table = "wp_comments_" . $post_year;

    // 检查分表是否存在
    $table_exists = $wpdb->get_var( $wpdb->prepare( "SHOW TABLES LIKE %s", $comment_table ) );

    if ( $table_exists != $comment_table ) {
        // 如果分表不存在，则使用默认的 wp_comments 表
        $comment_table = $wpdb->comments;
    }

    $where = 'WHERE comment_approved != %s';
    $where_args = array( 'spam' );

    if ( $post_id > 0 ) {
        $where .= ' AND comment_post_ID = %d';
        $where_args[] = $post_id;
    }

    //  优化后的 SQL 查询
    $counts = (array) $wpdb->get_results( $wpdb->prepare(
        "SELECT comment_approved, COUNT(comment_ID) AS num_comments FROM {$comment_table} {$where} GROUP BY comment_approved",
        $where_args
    ), ARRAY_A );

    // ... (数据处理和缓存更新代码) ...
}

4. 其他优化建议

  • 监控数据库性能： 使用数据库性能监控工具，定期检查数据库的性能指标，例如 CPU 使用率、内存使用率、磁盘 I/O 等。 根据监控结果，及时调整优化策略。
  • 使用 CDN： 将静态资源（例如：图片、CSS、JavaScript 文件）缓存到 CDN 中，减少服务器的负载。
  • 优化 WordPress 配置： 禁用不必要的插件，优化 WordPress 的配置选项，提高网站的整体性能。

5. 优化效果评估

优化完成后，需要对优化效果进行评估，以确保优化措施 действительно 提升了性能。 可以使用以下方法进行评估：

  • 使用 WordPress 性能测试工具： 例如 Query Monitor, New Relic 等工具，可以监控 SQL 查询的执行时间、内存使用情况等。
  • 使用 WebPageTest 或 PageSpeed Insights： 测试网站的加载速度，评估优化效果。
  • 观察服务器的 CPU 使用率、内存使用率、磁盘 I/O 等指标： 在高负载情况下，观察服务器的性能指标是否有所改善。

对缓存策略，SQL查询，异步处理，数据表结构进行适当优化

结论

wp_count_comments 函数的性能优化是一个复杂的过程，需要根据实际情况选择合适的优化策略。 通过优化缓存策略、SQL 查询、异步处理和数据表结构，可以有效地提高 wp_count_comments 函数的性能，从而提升 WordPress 网站的整体性能和用户体验。

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注