发布于 由admin

分析 WordPress `get_adjacent_post()` 函数的源码：如何查询相邻文章的 ID，并解释其性能。

咳咳，各位观众老爷们，晚上好！我是今晚的讲师，咱们今天来聊聊WordPress里一个看似简单，实则暗藏玄机的函数：get_adjacent_post()。 别看它名字普通，想把它扒个底朝天，可得费点功夫。今天咱们就来一起解剖一下它的源码，看看它是怎么找到相邻文章的，顺便也聊聊它的性能问题。

开场白：谁是我的邻居？

在WordPress的世界里，文章就像一个个小房子，排布在时间的河流里。get_adjacent_post() 函数，就是用来寻找当前文章的左邻右舍的：比我早发布的文章（上一篇）和比我晚发布的文章（下一篇）。

正文：源码大冒险

我们先来看看 get_adjacent_post() 的函数签名：

<?php
function get_adjacent_post( $in_same_term = false, $excluded_terms = '', $previous = true, $taxonomy = 'category' ) {
    global $post;

    if ( empty( $post ) ) {
        return null;
    }

    return _get_adjacent_post( $in_same_term, $excluded_terms, $previous, $taxonomy, $post );
}

是不是很简单？它只是个“皮包公司”，真正干活的是 _get_adjacent_post()。 让我们深入到 _get_adjacent_post() 函数里去一探究竟。

<?php
function _get_adjacent_post( $in_same_term = false, $excluded_terms = '', $previous = true, $taxonomy = 'category', $post = null ) {
    global $wpdb;

    if ( empty( $post ) ) {
        return null;
    }

    $current_post_date = $post->post_date;
    $join = '';
    $where = '';

    if ( $in_same_term ) {
        $term_array = wp_get_object_terms( $post->ID, $taxonomy, array( 'fields' => 'ids' ) );

        if ( ! is_wp_error( $term_array ) && ! empty( $term_array ) ) {
            $term_ids = implode( ',', array_map( 'intval', $term_array ) );
            $join  = " INNER JOIN {$wpdb->term_relationships} AS tr ON p.ID = tr.object_id INNER JOIN {$wpdb->term_taxonomy} AS tt ON tr.term_taxonomy_id = tt.term_taxonomy_id";
            $where = "AND tt.taxonomy = '$taxonomy' AND tt.term_id IN ($term_ids)";
        }
    }

    if ( ! empty( $excluded_terms ) ) {
        $exclude_terms = wp_parse_id_list( $excluded_terms );
        $excluded_terms_string = implode( ',', array_map( 'intval', $exclude_terms ) );
        $join  .= " INNER JOIN {$wpdb->term_relationships} AS tr ON p.ID = tr.object_id INNER JOIN {$wpdb->term_taxonomy} AS tt ON tr.term_taxonomy_id = tt.term_taxonomy_id";
        $where .= " AND tt.term_id NOT IN ($excluded_terms_string)";
    }

    if ( $previous ) {
        $op  = '<';
        $order = 'DESC';
    } else {
        $op  = '>';
        $order = 'ASC';
    }

    $where .= $wpdb->prepare( " AND p.post_type = %s AND p.post_status = 'publish' AND p.post_date $op %s", $post->post_type, $current_post_date );

    $sort  = "ORDER BY p.post_date $order LIMIT 1";

    $query = "SELECT p.ID FROM {$wpdb->posts} AS p $join WHERE 1=1 $where $sort";
    $query = apply_filters( 'get_adjacent_post_where', $query, $in_same_term, $excluded_terms, $previous, $taxonomy, $post );
    $query = apply_filters( 'get_adjacent_post_sort', $query );

    $adjacent_post_id = $wpdb->get_var( $query );

    if ( ! $adjacent_post_id ) {
        return null;
    }

    $adjacent_post = get_post( $adjacent_post_id );

    if ( ! $adjacent_post ) {
        return null;
    }

    return $adjacent_post;
}

这段代码看起来有点长，我们把它分解成几个部分来看：

  1. 参数处理与初始化：

    • $in_same_term: 布尔值，是否限制在同一分类/标签下查找。
    • $excluded_terms: 排除的分类/标签 ID，多个 ID 用逗号分隔。
    • $previous: 布尔值，true 表示查找上一篇文章，false 表示查找下一篇文章。
    • $taxonomy: 分类法名称，默认为 category。
    • $post: 当前文章对象。
    • 获取当前文章的发布时间 $current_post_date。
    • 初始化 $join 和 $where 变量，用于构建 SQL 查询。

  2. 构建 SQL 查询 (核心部分)：

    • 同分类/标签限制 ($in_same_term):
      如果 $in_same_term 为 true，则：

      • 使用 wp_get_object_terms() 获取当前文章所属的指定分类法的 Term ID。
      • 构建 JOIN 子句，连接 wp_term_relationships 和 wp_term_taxonomy 表。
      • 构建 WHERE 子句，限制结果在同一分类/标签下。
    • 排除分类/标签 ($excluded_terms):
      如果 $excluded_terms 不为空，则：

      • 使用 wp_parse_id_list() 将逗号分隔的 ID 字符串转换为 ID 数组。
      • 构建 JOIN 子句，连接 wp_term_relationships 和 wp_term_taxonomy 表。
      • 构建 WHERE 子句，排除指定的分类/标签。
    • 方向 ($previous):
      根据 $previous 的值，确定查找方向：

      • true (上一篇): $op = '<' (小于), $order = 'DESC' (降序)。
      • false (下一篇): $op = '>' (大于), $order = 'ASC' (升序)。
    • 构建最终 WHERE 子句:
      添加文章类型 (post_type)、文章状态 (post_status) 和日期比较 (post_date) 的条件。
      使用 $wpdb->prepare() 安全地处理 SQL 查询参数，防止 SQL 注入。
    • 构建排序和限制子句:
      使用 ORDER BY p.post_date $order LIMIT 1 按照发布日期排序，并限制只返回一条结果。
    • 组装完整的 SQL 查询:
      将各个部分拼接成最终的 SQL 查询语句。

      SELECT p.ID FROM {$wpdb->posts} AS p $join WHERE 1=1 $where $sort

  3. 执行查询并返回结果：

    • 使用 $wpdb->get_var() 执行 SQL 查询，获取相邻文章的 ID。
    • 如果未找到相邻文章，则返回 null。
    • 使用 get_post() 函数根据 ID 获取完整的文章对象。
    • 如果 get_post() 返回 null (例如，文章不存在或用户没有权限访问)，则返回 null。
    • 返回相邻的文章对象。

代码示例：来点实际的

假设我们想获取当前文章的下一篇文章，并且限制在同一分类下：

<?php
$next_post = get_adjacent_post( true, '', false );

if ( $next_post ) {
    echo '<a href="' . get_permalink( $next_post ) . '">' . $next_post->post_title . '</a>';
} else {
    echo '没有了';
}

这段代码会输出下一篇文章的链接，如果不存在下一篇文章，则输出“没有了”。

性能分析：是骡子是马拉出来溜溜

get_adjacent_post() 的性能瓶颈主要在于 SQL 查询。 以下是一些影响性能的关键因素：

  • $in_same_term 参数： 如果 $in_same_term 为 true，则会增加 SQL 查询的复杂度，需要 JOIN 额外的表，性能会下降。分类/标签越多，性能下降越明显。
  • $excluded_terms 参数： 类似于 $in_same_term，排除的分类/标签越多，性能越差。
  • 数据量： 文章数量越多，查询时间越长。
  • 数据库索引： 如果 wp_posts 表的 post_date 和 post_type 字段没有索引，查询速度会很慢。

优化建议：给蜗牛装个涡轮增压

  • 慎用 $in_same_term 和 $excluded_terms： 除非绝对必要，尽量避免使用这两个参数。 如果必须使用，尽量减少分类/标签的数量。

  • 添加数据库索引： 确保 wp_posts 表的 post_date 和 post_type 字段有索引。 可以通过 phpMyAdmin 或者 SQL 客户端执行以下语句添加索引：

    ALTER TABLE wp_posts ADD INDEX post_date (post_date);
ALTER TABLE wp_posts ADD INDEX post_type (post_type);

  • 使用缓存： 对于访问量大的网站，可以使用缓存插件或者手动缓存 get_adjacent_post() 的结果。 可以使用 WordPress 的 Transient API 来实现缓存。

    <?php
function get_cached_adjacent_post( $in_same_term = false, $excluded_terms = '', $previous = true, $taxonomy = 'category' ) {
    global $post;
    $cache_key = 'adjacent_post_' . md5( serialize( array( $post->ID, $in_same_term, $excluded_terms, $previous, $taxonomy ) ) );
    $cached_post = get_transient( $cache_key );

    if ( false === $cached_post ) {
        $cached_post = get_adjacent_post( $in_same_term, $excluded_terms, $previous, $taxonomy );
        set_transient( $cache_key, $cached_post, HOUR_IN_SECONDS ); // 缓存 1 小时
    }

    return $cached_post;
}

    使用 get_cached_adjacent_post() 函数代替 get_adjacent_post()。

  • 自定义 SQL 查询： 如果对 SQL 比较熟悉，可以自定义 SQL 查询来获取相邻文章。 这样可以更灵活地控制查询条件，并进行更精细的优化。 但是，自定义 SQL 查询需要注意安全问题，防止 SQL 注入。

总结：知己知彼，百战不殆

get_adjacent_post() 函数虽然简单，但其性能受到多种因素的影响。 理解其源码和性能特点，才能更好地优化它，避免成为网站的性能瓶颈。 记住，没有银弹，只有不断地测试和优化。

彩蛋：一些额外的思考

  • 文章发布时间相同的情况： 如果两篇文章的发布时间相同，get_adjacent_post() 的结果是不确定的。 可以通过添加额外的排序条件（例如，文章 ID）来解决这个问题。
  • 草稿文章： get_adjacent_post() 默认只查找已发布的文章。 如果需要查找草稿文章，需要修改 SQL 查询的 WHERE 子句。
  • 多站点： 在 WordPress 多站点环境中，get_adjacent_post() 默认只查找当前站点的文章。 如果需要查找所有站点的文章，需要修改 SQL 查询的 FROM 子句。

好了，今天的讲座就到这里。希望大家有所收获，下次再见！ 记得回去好好消化一下，不然下次见面我可要考你们的！ 溜了溜了~

发表回复

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