发布于 由admin

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

呦，各位观众老爷们，晚上好！ 今天咱们来聊聊 WordPress 里面一个挺实在的函数：get_adjacent_post()，就是获取相邻文章的函数。 这玩意儿看似简单，但要真想把它摸透，还得撸起袖子，看看它的“内裤”才行。 别怕，今天我就带大家深入源码，把这函数的底裤扒个精光，顺便聊聊它的性能问题，看看它是不是个“绣花枕头”。

开场白：相邻文章是个啥？

简单来说，相邻文章就是和你当前文章在时间上挨着的两篇文章：上一篇和下一篇。 这个功能在很多博客上都有，方便读者顺着时间线，一篇一篇地往下看。 WordPress 默认就提供了这个功能，通过 get_adjacent_post() 函数来实现。

正文：源码剖析，一层一层扒！

get_adjacent_post() 函数的源码位于 wp-includes/link-template.php 文件中。 我们先来看看它的基本用法：

<?php
$previous_post = get_adjacent_post( false, '', true ); // 获取上一篇文章
$next_post     = get_adjacent_post( false, '', false ); // 获取下一篇文章

if ( ! empty( $previous_post ) ) {
    echo '<a href="' . get_permalink( $previous_post->ID ) . '">' . get_the_title( $previous_post->ID ) . '</a>';
}

if ( ! empty( $next_post ) ) {
    echo '<a href="' . get_permalink( $next_post->ID ) . '">' . get_the_title( $next_post->ID ) . '</a>';
}
?>

这段代码很简单，就是获取上一篇和下一篇文章，然后输出它们的链接和标题。 关键在于 get_adjacent_post() 函数的参数：

  • $in_same_term (bool, 可选): 是否限制在同一分类、标签或自定义分类法中。 默认为 false。
  • $excluded_terms (string|array, 可选): 要排除的分类、标签或自定义分类法的 ID 或 slug。
  • $previous (bool, 可选): true 获取上一篇文章， false 获取下一篇文章。 默认为 true。
  • $taxonomy (string, 可选): 当 $in_same_term 为 true 时，指定要使用的分类法。 默认为 ‘category’。

接下来，咱们直接进入源码，看看 get_adjacent_post() 函数是怎么实现的：

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

    if ( is_a( $post, 'WP_Post' ) ) {
        $current_post = $post;
    } else {
        return null; // 没有当前文章，直接返回 null
    }

    $adjacent = $previous ? 'previous' : 'next';

    $join = '';
    $where = '';

    if ( $in_same_term && ! empty( $taxonomy ) ) {
        if ( ! taxonomy_exists( $taxonomy ) ) {
            return null;
        }

        $term_object = get_term( $current_post->ID, $taxonomy );
        if ( is_wp_error( $term_object ) ) {
            return null;
        }

        $term_id = intval( $term_object->term_id );

        if ( ! empty( $excluded_terms ) ) {
            $exclude_terms = wp_parse_id_list( $excluded_terms );
            $exclude_string = implode( ',', $exclude_terms );
            $where .= " AND tt.term_id NOT IN ($exclude_string)";
        }

        $join .= " INNER JOIN wp_term_relationships AS tr ON p.ID = tr.object_id INNER JOIN wp_term_taxonomy AS tt ON tr.term_taxonomy_id = tt.term_taxonomy_id INNER JOIN wp_terms AS t ON tt.term_id = t.term_id";
        $where .= " AND tt.taxonomy = '$taxonomy' AND t.term_id = $term_id";
    }

    if ( is_singular() ) {
        $current_post_date = $current_post->post_date;
    } else {
        $current_post_date = current_time( 'mysql' );
    }

    $op = $previous ? '<' : '>';
    $order = $previous ? 'DESC' : 'ASC';

    $where .= " AND p.post_date $op '$current_post_date'";
    $where .= " AND p.post_type = '$current_post->post_type'";
    $where .= " AND p.post_status = 'publish'";

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

    $query = "SELECT p.ID FROM wp_posts AS p $join WHERE 1=1 $where $sort";

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

    if ( ! empty( $adjacent_post_id ) ) {
        return get_post( $adjacent_post_id );
    } else {
        return null;
    }
}

咱们来分段解读一下：

  1. 参数处理和初始化：

    • 首先，函数会检查全局变量 $post 是否存在，并且是一个 WP_Post 对象。 如果不存在，说明没有当前文章，直接返回 null。
    • 然后，根据 $previous 参数，确定是获取上一篇还是下一篇文章。
    • 初始化 $join 和 $where 变量，用于构建 SQL 查询。

  2. 处理同一分类/标签的限制：

    • 如果 $in_same_term 为 true，表示需要限制在同一分类、标签或自定义分类法中。
    • 函数会检查指定的分类法 $taxonomy 是否存在。
    • 获取当前文章的分类/标签信息。
    • 如果 $excluded_terms 不为空，则从查询中排除指定的分类/标签。
    • 构建 $join 和 $where 语句，用于在 SQL 查询中连接 wp_term_relationships、wp_term_taxonomy 和 wp_terms 表，并添加分类/标签的限制条件。

  3. 构建 SQL 查询：

    • 获取当前文章的发布日期。 如果是单篇文章页面，则使用文章的 post_date，否则使用当前时间。
    • 根据 $previous 参数，确定比较操作符 $op ( < 或 > ) 和排序方式 $order ( DESC 或 ASC )。
    • 构建 $where 语句，添加日期、文章类型和文章状态的限制条件。
    • 构建 $sort 语句，指定排序方式和限制返回结果的数量为 1。
    • 构建完整的 SQL 查询语句。

  4. 执行 SQL 查询并返回结果：

    • 使用 $wpdb->get_var() 函数执行 SQL 查询，获取相邻文章的 ID。
    • 如果找到了相邻文章的 ID，则使用 get_post() 函数获取文章对象，并返回。
    • 如果没有找到相邻文章，则返回 null。

核心 SQL 查询语句：

咱们把核心的 SQL 查询语句拎出来，仔细瞧瞧：

SELECT p.ID
FROM wp_posts AS p
$join
WHERE 1=1
$where
$sort
  • SELECT p.ID: 查询文章的 ID。
  • FROM wp_posts AS p: 从 wp_posts 表中查询，并使用别名 p。
  • $join: 根据 $in_same_term 参数，可能包含连接 wp_term_relationships、wp_term_taxonomy 和 wp_terms 表的语句。
  • WHERE 1=1: 一个永远为真的条件，用于方便添加其他的 WHERE 子句。
  • $where: 包含日期、文章类型、文章状态和分类/标签的限制条件。
  • $sort: 指定排序方式和限制返回结果的数量为 1。

性能分析：这玩意儿快不快？

get_adjacent_post() 函数的性能取决于多个因素：

  • 数据量： 文章数量越多，查询所需的时间就越长。
  • 索引： wp_posts 表的 post_date 和 post_type 字段上应该有索引，以便加快查询速度。
  • $in_same_term 参数： 如果 $in_same_term 为 true，则需要连接更多的表，查询复杂度会增加。
  • 缓存： WordPress 有缓存机制，可以缓存查询结果，减少数据库查询的次数。
参数 性能影响
数据量 数据量越大，查询越慢
索引 缺少索引会导致全表扫描，查询速度大大降低
$in_same_term=true 需要连接更多表，查询复杂度增加，性能下降
缓存 缓存可以减少数据库查询次数，提高性能
$excluded_terms 如果排除的分类/标签数量很多，会增加查询复杂度

优化建议：让它跑得更快！

  • 确保必要的索引存在： 检查 wp_posts 表的 post_date 和 post_type 字段上是否有索引。 如果没有，可以手动添加索引。
  • 谨慎使用 $in_same_term 参数： 如果不需要限制在同一分类/标签中，尽量将 $in_same_term 设置为 false。
  • 使用对象缓存： WordPress 的对象缓存可以缓存查询结果，减少数据库查询的次数。 确保你的 WordPress 站点启用了对象缓存。
  • 考虑使用插件： 有一些插件可以优化相邻文章的查询，例如使用缓存、自定义查询等。
  • 自定义 SQL 查询： 如果 get_adjacent_post() 函数的性能无法满足你的需求，可以考虑自定义 SQL 查询。 但是，需要小心处理 SQL 注入等安全问题。

举个例子：优化 $in_same_term 为 true 的情况

当 $in_same_term 为 true 时，查询会变得比较复杂。 如果你只需要在同一分类中查找相邻文章，可以考虑使用以下方法进行优化：

  1. 手动编写 SQL 查询： 可以手动编写 SQL 查询，只连接必要的表，并使用索引进行优化。
  2. 使用 WordPress 的缓存 API： 将查询结果缓存起来，下次直接从缓存中获取。

例如，以下代码演示了如何手动编写 SQL 查询，并在同一分类中查找相邻文章：

<?php
global $wpdb, $post;

$taxonomy = 'category'; // 分类法
$term_ids = wp_get_post_terms( $post->ID, $taxonomy, array( 'fields' => 'ids' ) ); // 获取当前文章的分类 ID

if ( ! empty( $term_ids ) ) {
    $term_id = intval( $term_ids[0] ); // 获取第一个分类 ID

    $previous = true; // 获取上一篇文章
    $op = $previous ? '<' : '>';
    $order = $previous ? 'DESC' : 'ASC';

    $query = $wpdb->prepare(
        "SELECT p.ID
        FROM wp_posts AS p
        INNER JOIN wp_term_relationships AS tr ON p.ID = tr.object_id
        INNER JOIN wp_term_taxonomy AS tt ON tr.term_taxonomy_id = tt.term_taxonomy_id
        WHERE p.post_type = %s
        AND p.post_status = %s
        AND tt.taxonomy = %s
        AND tt.term_id = %d
        AND p.post_date %s %s
        ORDER BY p.post_date %s
        LIMIT 1",
        $post->post_type,
        'publish',
        $taxonomy,
        $term_id,
        $op,
        $post->post_date,
        $order
    );

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

    if ( ! empty( $adjacent_post_id ) ) {
        $adjacent_post = get_post( $adjacent_post_id );
        echo '<a href="' . get_permalink( $adjacent_post->ID ) . '">' . get_the_title( $adjacent_post->ID ) . '</a>';
    }
}
?>

这段代码使用了 $wpdb->prepare() 函数来防止 SQL 注入，并手动构建了 SQL 查询。 这样做可以更精确地控制查询过程，并进行针对性的优化。

总结：理解原理，灵活运用！

get_adjacent_post() 函数是一个方便的函数，可以用于获取相邻文章。 但是，它的性能可能会受到多种因素的影响。 通过理解其源码和性能特点，我们可以更好地使用它，并进行针对性的优化。 记住，没有万能的解决方案，只有最适合你的方案！

希望今天的讲座对大家有所帮助！ 如果有什么问题，欢迎提问！ 咱们下期再见！

发表回复

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