WordPress教程，集成网站内容自动备份与恢复工具

在当今数字化时代，网站已成为企业、个人展示和运营的重要平台。WordPress作为全球最受欢迎的内容管理系统，驱动着超过40%的网站。然而，随着网站功能的日益复杂和数据量的不断增长，网站安全、数据保护和功能扩展成为每个WordPress管理员必须面对的核心挑战。

数据丢失可能源于多种因素：服务器故障、黑客攻击、插件冲突、人为操作失误，甚至是更新过程中的意外错误。据行业统计，超过60%的小型网站在遭遇数据丢失后无法完全恢复，导致业务中断、品牌声誉受损和直接经济损失。与此同时，用户对网站功能的需求也日益多样化，从简单的社交分享到复杂的数据展示，传统插件往往无法完全满足个性化需求。

本教程将深入探讨如何通过WordPress代码二次开发，构建一个集自动化备份恢复与实用小工具于一体的综合解决方案。这不仅能够提升网站的数据安全性，还能通过定制化工具增强网站功能，减少对第三方插件的依赖，提高网站性能和可维护性。

要构建有效的备份系统，首先需要全面理解WordPress的数据架构。WordPress数据主要分为两大类别：

数据库内容：

• 核心数据表（wp_posts, wp_postmeta, wp_users等）
• 选项设置（wp_options）
• 评论数据（wp_comments）
• 用户关系数据（wp_usermeta）

文件系统内容：

• 主题文件（/wp-content/themes/）
• 插件文件（/wp-content/plugins/）
• 上传文件（/wp-content/uploads/）
• WordPress核心文件（/wp-admin/, /wp-includes/）
• 配置文件（wp-config.php）

一个完整的备份方案必须同时涵盖数据库和文件系统，并考虑它们之间的关联性。例如，媒体库中的文件在数据库中有关联记录，备份时需要保持这种关联的完整性。

大多数WordPress用户依赖以下几种备份方式：

1. 手动备份：通过phpMyAdmin导出数据库，通过FTP下载文件
2. 插件备份：使用UpdraftPlus、BackupBuddy等插件
3. 主机商备份：依赖主机提供的备份服务

这些方法各有局限：手动备份效率低下且容易遗漏；插件备份可能增加服务器负载，且与某些主题/插件存在兼容性问题；主机商备份通常不提供细粒度恢复选项，且恢复时间无法保证。

基于以上分析，一个理想的自动化备份系统应遵循以下设计原则：

• 完整性：备份所有必要数据，无遗漏
• 增量性：支持增量备份，减少存储空间和服务器负载
• 可恢复性：确保备份数据能够顺利恢复
• 安全性：备份数据加密存储，防止未授权访问
• 监控性：提供备份状态监控和失败告警
• 效率性：优化备份过程，减少对网站性能的影响

我们的自动化备份系统将采用模块化设计，包含以下核心组件：

1. 备份调度器：基于WordPress Cron系统管理备份计划
2. 数据库备份模块：处理MySQL/MariaDB数据库的导出和优化
3. 文件系统备份模块：处理文件和目录的增量备份
4. 压缩加密模块：对备份数据进行压缩和加密
5. 存储管理模块：支持本地、FTP、云存储等多种存储后端
6. 监控通知模块：监控备份状态并发送通知

复制

class WP_Auto_Backup_Scheduler {
    private $backup_intervals;
    
    public function __construct() {
        $this->backup_intervals = array(
            'daily' => 86400,
            'twicedaily' => 43200,
            'hourly' => 3600,
            'weekly' => 604800,
        );
        
        add_filter('cron_schedules', array($this, 'add_custom_schedules'));
        add_action('wp_auto_backup_event', array($this, 'execute_backup'));
    }
    
    public function add_custom_schedules($schedules) {
        foreach ($this->backup_intervals as $key => $interval) {
            if (!isset($schedules[$key])) {
                $schedules[$key] = array(
                    'interval' => $interval,
                    'display' => ucfirst($key) . ' Backup'
                );
            }
        }
        return $schedules;
    }
    
    public function schedule_backup($interval = 'daily') {
        if (!wp_next_scheduled('wp_auto_backup_event')) {
            wp_schedule_event(time(), $interval, 'wp_auto_backup_event');
        }
    }
    
    public function execute_backup() {
        $backup_manager = new WP_Backup_Manager();
        $result = $backup_manager->perform_complete_backup();
        
        if ($result['status'] === 'success') {
            $this->log_backup($result);
            $this->send_notification('备份成功', $result);
        } else {
            $this->log_error($result);
            $this->send_notification('备份失败', $result, 'error');
        }
    }
}

复制

class WP_Database_Backup {
    private $db_connection;
    private $backup_path;
    
    public function __construct() {
        $this->backup_path = WP_CONTENT_DIR . '/backups/database/';
        $this->ensure_directory_exists($this->backup_path);
    }
    
    public function backup_database($incremental = false) {
        global $wpdb;
        
        $tables = $wpdb->get_col("SHOW TABLES LIKE '" . $wpdb->prefix . "%'");
        $backup_file = $this->backup_path . 'db_backup_' . date('Y-m-d_H-i-s') . '.sql';
        
        $sql_dump = "";
        
        // 获取表结构
        foreach ($tables as $table) {
            $create_table = $wpdb->get_row("SHOW CREATE TABLE `$table`", ARRAY_N);
            $sql_dump .= "nn" . $create_table[1] . ";nn";
            
            // 获取表数据
            $rows = $wpdb->get_results("SELECT * FROM `$table`", ARRAY_A);
            
            if ($rows) {
                foreach ($rows as $row) {
                    $values = array_map(array($wpdb, '_real_escape'), $row);
                    $sql_dump .= "INSERT INTO `$table` VALUES('" . implode("', '", $values) . "');n";
                }
            }
        }
        
        // 增量备份处理
        if ($incremental) {
            $sql_dump = $this->extract_incremental_changes($sql_dump);
        }
        
        // 写入文件
        if (file_put_contents($backup_file, $sql_dump)) {
            return array(
                'status' => 'success',
                'file' => $backup_file,
                'size' => filesize($backup_file),
                'tables' => count($tables)
            );
        }
        
        return array('status' => 'error', 'message' => '无法写入备份文件');
    }
    
    private function extract_incremental_changes($full_dump) {
        // 实现增量备份逻辑
        // 比较上次备份与当前数据库的差异
        // 只备份发生变化的数据
        return $full_dump; // 简化示例
    }
}

复制

class WP_Filesystem_Backup {
    private $backup_path;
    private $excluded_patterns;
    
    public function __construct() {
        $this->backup_path = WP_CONTENT_DIR . '/backups/filesystem/';
        $this->excluded_patterns = array(
            '/.git/',
            '/.svn/',
            '/.DS_Store/',
            '/backups/',
            '/cache/',
            '/logs/'
        );
        $this->ensure_directory_exists($this->backup_path);
    }
    
    public function backup_filesystem($incremental = false) {
        $backup_file = $this->backup_path . 'fs_backup_' . date('Y-m-d_H-i-s') . '.zip';
        
        $zip = new ZipArchive();
        if ($zip->open($backup_file, ZipArchive::CREATE) !== TRUE) {
            return array('status' => 'error', 'message' => '无法创建ZIP文件');
        }
        
        // 备份WordPress根目录
        $this->add_directory_to_zip(ABSPATH, $zip, '', $incremental);
        
        // 备份wp-content目录
        $this->add_directory_to_zip(WP_CONTENT_DIR, $zip, 'wp-content', $incremental);
        
        $zip->close();
        
        return array(
            'status' => 'success',
            'file' => $backup_file,
            'size' => filesize($backup_file),
            'compression_ratio' => $this->calculate_compression_ratio($backup_file)
        );
    }
    
    private function add_directory_to_zip($directory, $zip, $base_path = '', $incremental = false) {
        $files = new RecursiveIteratorIterator(
            new RecursiveDirectoryIterator($directory),
            RecursiveIteratorIterator::LEAVES_ONLY
        );
        
        $last_backup_time = $this->get_last_backup_time();
        
        foreach ($files as $name => $file) {
            if (!$file->isDir()) {
                $file_path = $file->getRealPath();
                $relative_path = substr($file_path, strlen($directory) + 1);
                
                // 检查是否在排除列表中
                if ($this->is_excluded($file_path)) {
                    continue;
                }
                
                // 增量备份检查
                if ($incremental && filemtime($file_path) < $last_backup_time) {
                    continue;
                }
                
                $zip_path = $base_path ? $base_path . '/' . $relative_path : $relative_path;
                $zip->addFile($file_path, $zip_path);
            }
        }
    }
}

复制

class WP_Backup_Storage {
    private $storage_engines = array();
    
    public function __construct() {
        // 注册存储引擎
        $this->register_storage_engine('local', new Local_Storage());
        $this->register_storage_engine('ftp', new FTP_Storage());
        $this->register_storage_engine('s3', new S3_Storage());
        $this->register_storage_engine('google_drive', new Google_Drive_Storage());
    }
    
    public function store_backup($backup_file, $engine_type, $options = array()) {
        if (!isset($this->storage_engines[$engine_type])) {
            return array('status' => 'error', 'message' => '不支持的存储引擎');
        }
        
        $engine = $this->storage_engines[$engine_type];
        
        // 加密备份文件
        $encrypted_file = $this->encrypt_backup($backup_file);
        
        // 存储到指定引擎
        $result = $engine->store($encrypted_file, $options);
        
        // 清理临时加密文件
        unlink($encrypted_file);
        
        return $result;
    }
    
    private function encrypt_backup($file_path) {
        $encryption_key = defined('WP_BACKUP_ENCRYPTION_KEY') 
            ? WP_BACKUP_ENCRYPTION_KEY 
            : $this->generate_encryption_key();
        
        $encrypted_file = $file_path . '.enc';
        
        $iv = openssl_random_pseudo_bytes(openssl_cipher_iv_length('aes-256-cbc'));
        $encrypted_data = openssl_encrypt(
            file_get_contents($file_path),
            'aes-256-cbc',
            $encryption_key,
            0,
            $iv
        );
        
        file_put_contents($encrypted_file, $iv . $encrypted_data);
        
        return $encrypted_file;
    }
}

复制

class S3_Storage {
    private $s3_client;
    
    public function __construct() {
        $this->s3_client = new AwsS3S3Client([
            'version' => 'latest',
            'region'  => get_option('wp_backup_s3_region', 'us-east-1'),
            'credentials' => [
                'key'    => get_option('wp_backup_s3_key'),
                'secret' => get_option('wp_backup_s3_secret'),
            ]
        ]);
    }
    
    public function store($file_path, $options = array()) {
        $bucket = $options['bucket'] ?? get_option('wp_backup_s3_bucket');
        $key = 'backups/' . basename($file_path);
        
        try {
            $result = $this->s3_client->putObject([
                'Bucket' => $bucket,
                'Key'    => $key,
                'SourceFile' => $file_path,
                'StorageClass' => 'STANDARD_IA' // 低频访问存储，降低成本
            ]);
            
            return array(
                'status' => 'success',
                'url' => $result['ObjectURL'],
                'storage_class' => 'S3',
                'expiration' => date('Y-m-d H:i:s', time() + 365*24*60*60) // 1年后过期
            );
        } catch (AwsS3ExceptionS3Exception $e) {
            return array(
                'status' => 'error',
                'message' => $e->getMessage()
            );
        }
    }
}

复制

class WP_Backup_Monitor {
    public function check_backup_health() {
        $health_status = array(
            'last_backup' => $this->get_last_backup_time(),
            'backup_size' => $this->get_total_backup_size(),
            'storage_status' => $this->check_storage_availability(),
            'integrity_checks' => $this->verify_backup_integrity()
        );
        
        return $health_status;
    }
    
    public function send_notification($type, $data, $priority = 'normal') {
        $notification_methods = get_option('wp_backup_notification_methods', array('email'));
        
        foreach ($notification_methods as $method) {
            switch ($method) {
                case 'email':
                    $this->send_email_notification($type, $data, $priority);
                    break;
                case 'slack':
                    $this->send_slack_notification($type, $data, $priority);
                    break;
                case 'webhook':
                    $this->send_webhook_notification($type, $data, $priority);
                    break;
            }
        }
    }
    
    private function send_email_notification($type, $data, $priority) {
        $to = get_option('admin_email');
        $subject = $this->get_notification_subject($type, $priority);
        $message = $this->generate_notification_message($type, $data);
        
        wp_mail($to, $subject, $message, array('Content-Type: text/html; charset=UTF-8'));
    }
}

一个可靠的恢复系统应该支持多种恢复场景：

1. 完整恢复：从完整备份恢复整个网站
2. 部分恢复：仅恢复数据库或特定文件
3. 时间点恢复：恢复到特定时间点的状态
4. 迁移恢复：将备份恢复到不同的服务器或域名

复制

class WP_OneClick_Restore {
    public function restore_from_backup($backup_id, $options = array()) {
        // 进入维护模式
        $this->enable_maintenance_mode();
        
        try {
            // 步骤1：验证备份文件完整性
            if (!$this->verify_backup_integrity($backup_id)) {
                throw new Exception('备份文件完整性验证失败');
            }
            
            // 步骤2：下载备份文件
            $backup_files = $this->download_backup_files($backup_id);
            
            // 步骤3：恢复数据库
            if (in_array('database', $options['components'])) {
                $this->restore_database($backup_files['database']);
            }
            
            // 步骤4：恢复文件系统
            if (in_array('filesystem', $options['components'])) {
                $this->restore_filesystem($backup_files['filesystem']);
            }
            
            // 步骤5：更新配置（如域名变更）
            if (isset($options['new_domain'])) {
                $this->update_site_url($options['new_domain']);
            }
            
            // 步骤6：清理缓存
            $this->clear_all_caches();
            
            // 步骤7：退出维护模式
            $this->disable_maintenance_mode();
            
            return array(
                'status' => 'success',
                'message' => '恢复完成',
                'restored_at' => current_time('mysql')
            );
            
        } catch (Exception $e) {
            // 恢复失败，尝试回滚
            $this->attempt_rollback();
            $this->disable_maintenance_mode();
            
            return array(
                'status' => 'error',
                'message' => '恢复失败: ' . $e->getMessage()
            );
        }
    }
    
    private function restore_database($database_file) {
        global $wpdb;
        
        // 临时禁用外键检查

复制

    private function restore_database($database_file) {
        global $wpdb;
        
        // 临时禁用外键检查
        $wpdb->query('SET FOREIGN_KEY_CHECKS = 0');
        
        // 读取SQL文件
        $sql_content = file_get_contents($database_file);
        $queries = $this->split_sql_queries($sql_content);
        
        // 执行每个查询
        foreach ($queries as $query) {
            if (trim($query) !== '') {
                $wpdb->query($query);
            }
        }
        
        // 重新启用外键检查
        $wpdb->query('SET FOREIGN_KEY_CHECKS = 1');
        
        // 更新数据库版本
        update_option('db_version', get_option('db_version') + 1);
    }
    
    private function restore_filesystem($filesystem_backup) {
        $backup_dir = WP_CONTENT_DIR . '/temp_restore/';
        $this->ensure_directory_exists($backup_dir);
        
        // 解压备份文件
        $zip = new ZipArchive();
        if ($zip->open($filesystem_backup) === TRUE) {
            $zip->extractTo($backup_dir);
            $zip->close();
        } else {
            throw new Exception('无法解压备份文件');
        }
        
        // 恢复WordPress核心文件
        $this->restore_directory($backup_dir . 'wordpress/', ABSPATH);
        
        // 恢复wp-content目录
        $this->restore_directory($backup_dir . 'wp-content/', WP_CONTENT_DIR);
        
        // 清理临时文件
        $this->delete_directory($backup_dir);
    }
    
    private function restore_directory($source, $destination) {
        $files = new RecursiveIteratorIterator(
            new RecursiveDirectoryIterator($source, RecursiveDirectoryIterator::SKIP_DOTS),
            RecursiveIteratorIterator::SELF_FIRST
        );
        
        foreach ($files as $file) {
            $target = $destination . DIRECTORY_SEPARATOR . $files->getSubPathName();
            
            if ($file->isDir()) {
                if (!is_dir($target)) {
                    mkdir($target, 0755, true);
                }
            } else {
                copy($file, $target);
                chmod($target, 0644);
            }
        }
    }
    
    private function enable_maintenance_mode() {
        $maintenance_file = ABSPATH . '.maintenance';
        $content = '<?php $upgrading = ' . time() . '; ?>';
        file_put_contents($maintenance_file, $content);
    }
    
    private function disable_maintenance_mode() {
        $maintenance_file = ABSPATH . '.maintenance';
        if (file_exists($maintenance_file)) {
            unlink($maintenance_file);
        }
    }
}

复制

class WP_Selective_Restore {
    public function restore_specific_tables($tables, $backup_id) {
        global $wpdb;
        
        $backup_file = $this->get_backup_file($backup_id, 'database');
        $sql_content = file_get_contents($backup_file);
        
        // 提取特定表的SQL
        $table_queries = $this->extract_table_queries($sql_content, $tables);
        
        // 备份当前表数据
        $this->backup_current_tables($tables);
        
        try {
            // 清空目标表
            foreach ($tables as $table) {
                $wpdb->query("TRUNCATE TABLE `$table`");
            }
            
            // 恢复表数据
            foreach ($table_queries as $query) {
                $wpdb->query($query);
            }
            
            return array('status' => 'success', 'restored_tables' => $tables);
            
        } catch (Exception $e) {
            // 恢复失败，回滚
            $this->restore_from_backup($tables, 'pre_restore_backup');
            throw $e;
        }
    }
    
    public function restore_media_by_date($start_date, $end_date) {
        // 恢复特定时间段的媒体文件
        $backup_files = $this->get_backup_files_in_range($start_date, $end_date);
        
        $restored_media = array();
        foreach ($backup_files as $backup) {
            $media_files = $this->extract_media_from_backup($backup, $start_date, $end_date);
            $this->restore_files($media_files, WP_CONTENT_DIR . '/uploads/');
            $restored_media = array_merge($restored_media, $media_files);
        }
        
        // 更新数据库中的媒体记录
        $this->update_media_records($restored_media);
        
        return array(
            'status' => 'success',
            'restored_count' => count($restored_media),
            'files' => $restored_media
        );
    }
}

我们将创建一个模块化的小工具系统，支持以下功能：

1. 社交分享工具
2. 内容推荐引擎
3. 用户反馈系统
4. 数据统计面板
5. SEO优化工具
6. 性能监控工具

复制

class WP_Toolkit_Manager {
    private $tools = array();
    
    public function __construct() {
        $this->register_core_tools();
        add_action('init', array($this, 'init_tools'));
    }
    
    private function register_core_tools() {
        $this->register_tool('social_share', new Social_Share_Tool());
        $this->register_tool('content_recommend', new Content_Recommend_Tool());
        $this->register_tool('user_feedback', new User_Feedback_Tool());
        $this->register_tool('analytics', new Analytics_Tool());
        $this->register_tool('seo_optimizer', new SEO_Optimizer_Tool());
        $this->register_tool('performance_monitor', new Performance_Monitor_Tool());
    }
    
    public function register_tool($slug, $tool_instance) {
        $this->tools[$slug] = $tool_instance;
    }
    
    public function init_tools() {
        foreach ($this->tools as $tool) {
            if (method_exists($tool, 'init')) {
                $tool->init();
            }
        }
    }
    
    public function get_tool($slug) {
        return isset($this->tools[$slug]) ? $this->tools[$slug] : null;
    }
}

复制

class Social_Share_Tool {
    private $platforms = array(
        'facebook' => array(
            'name' => 'Facebook',
            'icon' => 'fab fa-facebook-f',
            'color' => '#1877F2',
            'api_endpoint' => 'https://www.facebook.com/sharer/sharer.php'
        ),
        'twitter' => array(
            'name' => 'Twitter',
            'icon' => 'fab fa-twitter',
            'color' => '#1DA1F2',
            'api_endpoint' => 'https://twitter.com/intent/tweet'
        ),
        'linkedin' => array(
            'name' => 'LinkedIn',
            'icon' => 'fab fa-linkedin-in',
            'color' => '#0A66C2',
            'api_endpoint' => 'https://www.linkedin.com/sharing/share-offsite/'
        ),
        'wechat' => array(
            'name' => '微信',
            'icon' => 'fab fa-weixin',
            'color' => '#07C160',
            'api_endpoint' => 'javascript:'
        )
    );
    
    public function init() {
        add_action('wp_enqueue_scripts', array($this, 'enqueue_assets'));
        add_filter('the_content', array($this, 'add_share_buttons'), 99);
        add_action('wp_ajax_track_share', array($this, 'track_share'));
        add_action('wp_ajax_nopriv_track_share', array($this, 'track_share'));
    }
    
    public function enqueue_assets() {
        wp_enqueue_style('social-share-tool', plugin_dir_url(__FILE__) . 'css/social-share.css');
        wp_enqueue_script('social-share-tool', plugin_dir_url(__FILE__) . 'js/social-share.js', array('jquery'), '1.0', true);
        
        wp_localize_script('social-share-tool', 'social_share_data', array(
            'ajax_url' => admin_url('admin-ajax.php'),
            'nonce' => wp_create_nonce('social_share_nonce')
        ));
    }
    
    public function add_share_buttons($content) {
        if (is_single() && $this->should_display_buttons()) {
            $buttons_html = $this->generate_share_buttons();
            $content .= '<div class="social-share-container">' . $buttons_html . '</div>';
        }
        return $content;
    }
    
    private function generate_share_buttons() {
        global $post;
        
        $post_url = urlencode(get_permalink($post->ID));
        $post_title = urlencode(get_the_title($post->ID));
        $post_excerpt = urlencode(wp_trim_words(get_the_excerpt($post), 20));
        
        $buttons = array();
        
        foreach ($this->platforms as $slug => $platform) {
            $share_url = $this->generate_share_url($slug, $post_url, $post_title, $post_excerpt);
            
            $buttons[] = sprintf(
                '<a href="%s" class="social-share-btn share-%s" data-platform="%s" data-post-id="%d" title="分享到%s">' .
                '<i class="%s"></i><span class="share-text">%s</span>' .
                '</a>',
                esc_url($share_url),
                esc_attr($slug),
                esc_attr($slug),
                $post->ID,
                esc_attr($platform['name']),
                esc_attr($platform['icon']),
                esc_html($platform['name'])
            );
        }
        
        // 添加微信二维码分享
        $buttons[] = $this->generate_wechat_qrcode();
        
        return '<div class="social-share-buttons">' . implode('', $buttons) . '</div>';
    }
    
    private function generate_share_url($platform, $url, $title, $excerpt) {
        switch ($platform) {
            case 'facebook':
                return $this->platforms[$platform]['api_endpoint'] . '?u=' . $url;
            case 'twitter':
                return $this->platforms[$platform]['api_endpoint'] . '?text=' . $title . '&url=' . $url;
            case 'linkedin':
                return $this->platforms[$platform]['api_endpoint'] . '?url=' . $url;
            case 'wechat':
                return 'javascript:void(0);';
            default:
                return '#';
        }
    }
    
    private function generate_wechat_qrcode() {
        global $post;
        
        $qrcode_url = add_query_arg(array(
            'action' => 'generate_wechat_qrcode',
            'url' => urlencode(get_permalink($post->ID)),
            'nonce' => wp_create_nonce('wechat_qrcode_nonce')
        ), admin_url('admin-ajax.php'));
        
        return sprintf(
            '<div class="wechat-share-container">' .
            '<a href="javascript:void(0);" class="social-share-btn share-wechat" title="微信分享">' .
            '<i class="fab fa-weixin"></i><span class="share-text">微信</span>' .
            '</a>' .
            '<div class="wechat-qrcode-popup">' .
            '<div class="qrcode-title">扫描二维码分享</div>' .
            '<img src="%s" alt="微信分享二维码" class="wechat-qrcode">' .
            '<div class="qrcode-tip">打开微信，扫描二维码分享给好友</div>' .
            '</div>' .
            '</div>',
            esc_url($qrcode_url)
        );
    }
    
    public function track_share() {
        check_ajax_referer('social_share_nonce', 'nonce');
        
        $platform = sanitize_text_field($_POST['platform']);
        $post_id = intval($_POST['post_id']);
        $user_ip = $this->get_user_ip();
        
        // 记录分享数据
        $share_data = array(
            'post_id' => $post_id,
            'platform' => $platform,
            'user_ip' => $user_ip,
            'user_agent' => $_SERVER['HTTP_USER_AGENT'],
            'timestamp' => current_time('mysql')
        );
        
        $this->save_share_analytics($share_data);
        
        // 更新文章分享计数
        $this->update_post_share_count($post_id, $platform);
        
        wp_send_json_success(array('message' => '分享已记录'));
    }
    
    private function save_share_analytics($data) {
        global $wpdb;
        
        $table_name = $wpdb->prefix . 'social_share_analytics';
        
        $wpdb->insert($table_name, $data);
    }
    
    private function update_post_share_count($post_id, $platform) {
        $current_count = get_post_meta($post_id, '_share_count_' . $platform, true);
        $current_count = $current_count ? intval($current_count) : 0;
        
        update_post_meta($post_id, '_share_count_' . $platform, $current_count + 1);
        
        // 更新总分享数
        $total_count = get_post_meta($post_id, '_total_share_count', true);
        $total_count = $total_count ? intval($total_count) : 0;
        update_post_meta($post_id, '_total_share_count', $total_count + 1);
    }
}

复制

class Content_Recommend_Tool {
    private $recommendation_strategies = array(
        'related_by_tags',
        'related_by_category',
        'popular_posts',
        'recently_viewed',
        'user_based_collaborative'
    );
    
    public function init() {
        add_action('wp_enqueue_scripts', array($this, 'enqueue_assets'));
        add_filter('the_content', array($this, 'add_recommendations'), 100);
        add_action('wp_ajax_get_recommendations', array($this, 'ajax_get_recommendations'));
        add_action('wp_ajax_nopriv_get_recommendations', array($this, 'ajax_get_recommendations'));
        add_action('wp_footer', array($this, 'track_user_behavior'));
    }
    
    public function get_recommendations($post_id = null, $limit = 6) {
        if (!$post_id) {
            global $post;
            $post_id = $post->ID;
        }
        
        $recommendations = array();
        $strategy_weights = $this->get_strategy_weights();
        
        foreach ($this->recommendation_strategies as $strategy) {
            if ($strategy_weights[$strategy] > 0) {
                $strategy_recommendations = call_user_func(
                    array($this, 'get_' . $strategy . '_recommendations'),
                    $post_id,
                    ceil($limit * $strategy_weights[$strategy])
                );
                
                $recommendations = array_merge($recommendations, $strategy_recommendations);
            }
        }
        
        // 去重和排序
        $recommendations = $this->deduplicate_and_sort($recommendations, $limit);
        
        return $recommendations;
    }
    
    private function get_related_by_tags_recommendations($post_id, $limit) {
        $tags = wp_get_post_tags($post_id, array('fields' => 'ids'));
        
        if (empty($tags)) {
            return array();
        }
        
        $args = array(
            'post_type' => 'post',
            'post__not_in' => array($post_id),
            'tag__in' => $tags,
            'posts_per_page' => $limit,
            'orderby' => 'relevance',
            'meta_query' => array(
                array(
                    'key' => '_thumbnail_id',
                    'compare' => 'EXISTS'
                )
            )
        );
        
        $query = new WP_Query($args);
        
        return $this->format_recommendations($query->posts, 'tag_based');
    }
    
    private function get_popular_posts_recommendations($post_id, $limit) {
        $args = array(
            'post_type' => 'post',
            'post__not_in' => array($post_id),
            'posts_per_page' => $limit,
            'meta_key' => '_total_share_count',
            'orderby' => 'meta_value_num',
            'order' => 'DESC',
            'date_query' => array(
                array(
                    'after' => '30 days ago'
                )
            )
        );
        
        $query = new WP_Query($args);
        
        return $this->format_recommendations($query->posts, 'popular');
    }
    
    private function get_user_based_collaborative_recommendations($post_id, $limit) {
        // 基于用户行为的协同过滤推荐
        $current_user_id = get_current_user_id();
        
        if (!$current_user_id) {
            return array();
        }
        
        // 获取当前用户的阅读历史
        $user_history = $this->get_user_read_history($current_user_id);
        
        if (empty($user_history)) {
            return array();
        }
        
        // 找到有相似阅读历史的用户