（原创）B站视频获取和管理（无须工具和浏览器组件）：构建通用的智能视频缓存与发布系统（PHP）

引言

在内容创作日益多元化的今天，视频已成为信息传播的重要载体。无论是个人博客、内容管理系统，还是自建的视频分享平台，如何高效地集成B站视频、解决视频链接过期问题，都是开发者面临的共同挑战。

本文将深入解析一套完整的B站视频管理工具的实现方案，该方案不仅实现了视频链接的智能解析和缓存管理，更通过创新的缓存策略和自动刷新机制，解决了视频链接时效性的痛点。这套方案不依赖特定CMS系统，可作为通用组件集成到任何PHP项目中。

一、系统架构设计

1.1 整体架构

该工具采用模块化设计，核心组件包括：

bilibili-video-manager/
├── class/               # 核心类库
│   ├── BilibiliParser.php    # 视频解析
│   ├── VideoCache.php        # 缓存管理
│   ├── DatabaseManager.php   # 数据库抽象层
│   ├── ConfigManager.php     # 配置管理
│   └── Logger.php            # 日志记录
├── api/                 # API接口
│   ├── publish.php           # 发布接口
│   ├── refresh_video.php     # 刷新接口
│   ├── delete.php            # 删除接口
│   └── batch_update.php      # 批量更新
├── cache/               # 缓存目录
└── examples/            # 使用示例
    ├── typecho_integration.php  # Typecho集成示例
    ├── wordpress_integration.php # WordPress集成示例
    └── custom_integration.php    # 自定义集成示例

1.2 技术栈

• 后端语言：PHP 7.4+（可扩展至其他语言）
• 数据存储：支持MySQL、SQLite、文件存储等多种方式
• 缓存机制：文件缓存 + 内存缓存双架构
• 前端：原生JavaScript，无框架依赖
• API集成：B站开放API

二、核心功能实现

2.1 视频解析模块

BilibiliParser类是系统的核心，负责解析B站视频链接，获取视频信息和播放地址。该模块完全独立，不依赖任何外部框架。

<?php
/**
 * B站视频解析类 - 完全独立，可集成到任何PHP项目
 */
namespace BilibiliVideoManager;

class BilibiliParser {
    private $apiUrl = 'https://api.bilibili.com/x/web-interface/view';
    private $playUrl = 'https://api.bilibili.com/x/player/playurl';
    private $cache;
    private $curlHandle = null;
    private $maxRetries = 3;
    private $retryDelay = 1;

    public function __construct($cacheDir = null) {
        $this->cache = new VideoCache($cacheDir);
    }
    
    /**
     * 解析视频链接 - 入口方法
     * @param string $url B站视频链接
     * @return array 视频信息
     */
    public function parseUrl($url) {
        // 1. 提取BV号
        $bvid = $this->extractBVid($url);
        if (!$bvid) {
            return ['success' => false, 'message' => '无法提取BV号'];
        }
        
        // 2. 获取视频信息
        $videoInfo = $this->getVideoInfo($bvid);
        if (!$videoInfo['success']) {
            return $videoInfo;
        }
        
        // 3. 获取视频下载地址
        $playCount = $videoInfo['data']['view'] ?? 0;
        $videoUrl = $this->getVideoUrl(
            $bvid, 
            $videoInfo['data']['cid'], 
            80, 
            true, 
            $playCount
        );
        
        if ($videoUrl['success']) {
            $videoInfo['data']['video_url'] = $videoUrl['data']['url'];
        }
        
        return $videoInfo;
    }
    
    /**
     * 提取BV号 - 支持多种URL格式
     */
    private function extractBVid($url) {
        // 匹配BV号: BV开头 + 字母数字组合
        if (preg_match('/BV[0-9A-Za-z]+/', $url, $matches)) {
            return $matches[0];
        }
        
        // 支持av号转换
        if (preg_match('/av(\d+)/', $url, $matches)) {
            return $this->avToBv($matches[1]);
        }
        
        return false;
    }
    
    /**
     * 获取视频信息
     */
    public function getVideoInfo($bvid) {
        $url = $this->apiUrl . '?bvid=' . $bvid;
        $response = $this->curlRequest($url);
        
        if (!$response) {
            return ['success' => false, 'message' => 'API请求失败'];
        }
        
        $data = json_decode($response, true);
        if (!isset($data['code']) || $data['code'] != 0) {
            return ['success' => false, 'message' => $data['message'] ?? '获取失败'];
        }
        
        $videoData = $data['data'];
        return [
            'success' => true,
            'data' => [
                'bvid' => $bvid,
                'aid' => $videoData['aid'],
                'cid' => $videoData['cid'],
                'title' => $videoData['title'],
                'desc' => $videoData['desc'],
                'pic' => $videoData['pic'],
                'author' => $videoData['owner']['name'],
                'view' => $videoData['stat']['view'],
                'danmaku' => $videoData['stat']['danmaku'],
                'like' => $videoData['stat']['like']
            ]
        ];
    }
    
    /**
     * 获取视频播放地址 - 核心方法
     * @param string $bvid BV号
     * @param int $cid 视频分P编号
     * @param int $quality 视频质量 80=1080P, 64=720P, 32=480P
     * @param bool $useCache 是否使用缓存
     * @param int $playCount 播放次数(用于缓存策略)
     */
    public function getVideoUrl($bvid, $cid, $quality = 80, $useCache = true, $playCount = 0) {
        // 智能缓存判断
        if ($useCache) {
            $cachedUrl = $this->cache->get($bvid, $playCount);
            
            if ($cachedUrl) {
                // 检查缓存是否需要自动刷新
                if (isset($cachedUrl['needs_refresh']) && $cachedUrl['needs_refresh']) {
                    // 缓存超过一半时间，自动刷新
                    return $this->fetchNewUrl($bvid, $cid, $quality);
                }
                
                // 缓存有效，直接返回
                return [
                    'success' => true,
                    'data' => [
                        'url' => $cachedUrl['url'],
                        'quality' => $quality,
                        'from_cache' => true,
                        'cache_age' => $cachedUrl['cache_age']
                    ]
                ];
            }
        }
        
        // 从B站API获取新链接
        return $this->fetchNewUrl($bvid, $cid, $quality);
    }
    
    /**
     * 从B站API获取新链接
     */
    private function fetchNewUrl($bvid, $cid, $quality) {
        $url = $this->playUrl . '?bvid=' . $bvid . '&cid=' . $cid . '&qn=' . $quality . 
               '&type=&otype=json&platform=html5&high_quality=1&fnval=4048&fourk=1';
        
        $response = $this->curlRequest($url);
        
        if (!$response) {
            return ['success' => false, 'message' => 'API请求失败'];
        }
        
        $data = json_decode($response, true);
        if (!isset($data['code']) || $data['code'] != 0) {
            return ['success' => false, 'message' => $data['message'] ?? '获取地址失败'];
        }
        
        // 解析dash格式
        if (isset($data['data']['dash']['video']) && !empty($data['data']['dash']['video'])) {
            $bestVideo = $this->getBestQualityVideo($data['data']['dash']['video']);
            if ($bestVideo) {
                // CDN域名优化
                $videoUrl = str_replace('upos-sz-estgoss', 'upos-sz-mirrorcos', $bestVideo['baseUrl']);
                
                // 保存到缓存
                $this->cache->set($bvid, $videoUrl);
                
                return [
                    'success' => true,
                    'data' => [
                        'url' => $videoUrl,
                        'size' => $bestVideo['size'] ?? 0,
                        'quality' => $quality,
                        'from_cache' => false
                    ]
                ];
            }
        }
        
        // fallback到durl格式
        if (isset($data['data']['durl']) && !empty($data['data']['durl'])) {
            $videoUrl = str_replace('upos-sz-estgoss', 'upos-sz-mirrorcos', $data['data']['durl'][0]['url']);
            $this->cache->set($bvid, $videoUrl);
            
            return [
                'success' => true,
                'data' => [
                    'url' => $videoUrl,
                    'size' => $data['data']['durl'][0]['size'] ?? 0,
                    'quality' => $quality,
                    'from_cache' => false
                ]
            ];
        }
        
        return ['success' => false, 'message' => '无法获取视频地址'];
    }
    
    /**
     * 带重试机制的cURL请求
     */
    private function curlRequest($url, $options = []) {
        $retryCount = 0;
        $ch = $this->getCurlHandle();
        
        while ($retryCount < $this->maxRetries) {
            curl_setopt($ch, CURLOPT_URL, $url);
            
            foreach ($options as $key => $value) {
                curl_setopt($ch, $key, $value);
            }
            
            $result = curl_exec($ch);
            
            if ($result !== false) {
                return $result;
            }
            
            $retryCount++;
            if ($retryCount < $this->maxRetries) {
                sleep($this->retryDelay * $retryCount);
            }
        }
        
        return false;
    }
}

关键技术点：

• 独立设计：无任何外部依赖，可嵌入任何PHP项目
• 智能提取：支持BV号、av号、完整URL等多种格式
• CDN优化：自动替换为国内访问更快的mirrorcos域名
• 重试机制：失败自动重试，提高成功率

2.2 智能缓存策略

VideoCache类实现了基于视频热度的分级缓存策略，这是本方案的核心创新点。

<?php
/**
 * 视频链接缓存类 - 通用缓存解决方案
 */
namespace BilibiliVideoManager;

class VideoCache {
    private $cacheDir;
    private $memoryCache = [];
    private $memoryCacheTTL = 300; // 内存缓存5分钟
    
    // 缓存统计
    private $cacheStats = [
        'hits' => 0,
        'misses' => 0,
        'writes' => 0
    ];

    // 缓存时间配置（秒）- 可根据实际需求调整
    private $cacheTimes = [
        'hot' => 86400,     // 热门视频24小时
        'normal' => 21600,  // 普通视频6小时
        'cold' => 3600      // 冷门视频1小时
    ];

    public function __construct($cacheDir = null) {
        $this->cacheDir = $cacheDir ?? dirname(__FILE__) . '/../cache';
        $this->init();
    }

    /**
     * 初始化缓存目录
     */
    private function init() {
        if (!is_dir($this->cacheDir)) {
            mkdir($this->cacheDir, 0755, true);
        }
        
        // 清理过期缓存（后台任务，不影响主流程）
        $this->cleanExpiredCache();
    }

    /**
     * 获取缓存 - 核心方法
     * @param string $key 缓存键(BV号)
     * @param int $playCount 播放次数(用于动态缓存时间)
     * @return array|null 缓存数据
     */
    public function get($key, $playCount = 0) {
        // 1. 检查内存缓存
        if (isset($this->memoryCache[$key])) {
            $memoryCache = $this->memoryCache[$key];
            if (time() - $memoryCache['timestamp'] < $this->memoryCacheTTL) {
                $this->cacheStats['hits']++;
                return $this->enrichCacheData($memoryCache);
            } else {
                // 内存缓存过期，删除
                unset($this->memoryCache[$key]);
            }
        }

        // 2. 检查文件缓存
        $cacheFile = $this->getCacheFilePath($key);
        if (!file_exists($cacheFile)) {
            $this->cacheStats['misses']++;
            return null;
        }

        $content = file_get_contents($cacheFile);
        $cached = json_decode($content, true) ?: null;

        if (!$cached) {
            $this->cacheStats['misses']++;
            return null;
        }

        // 3. 根据播放次数计算缓存有效期
        $cacheTTL = $this->getCacheTTLByPlayCount($playCount);
        $cacheAge = time() - $cached['timestamp'];

        // 4. 检查是否过期
        if ($cacheAge >= $cacheTTL) {
            $this->cacheStats['misses']++;
            unlink($cacheFile); // 删除过期文件
            return null;
        }

        // 5. 更新内存缓存
        $this->memoryCache[$key] = $cached;
        $this->cacheStats['hits']++;

        return $this->enrichCacheData($cached, $cacheAge, $cacheTTL);
    }

    /**
     * 丰富缓存数据，添加辅助信息
     */
    private function enrichCacheData($cached, $cacheAge = null, $cacheTTL = null) {
        if ($cacheAge === null) {
            $cacheAge = time() - $cached['timestamp'];
            $cacheTTL = $this->getCacheTTLByPlayCount(0);
        }
        
        return [
            'url' => $cached['url'],
            'timestamp' => $cached['timestamp'],
            'cache_age' => $cacheAge,
            'needs_refresh' => $cacheAge >= $cacheTTL * 0.5, // 超过一半时间需要刷新
            'expires_in' => $cacheTTL - $cacheAge
        ];
    }

    /**
     * 设置缓存
     */
    public function set($key, $value, $extraData = []) {
        $cacheData = [
            'url' => $value,
            'timestamp' => time(),
            'extra' => $extraData
        ];

        // 更新内存缓存
        $this->memoryCache[$key] = $cacheData;

        // 保存到文件
        $cacheFile = $this->getCacheFilePath($key);
        file_put_contents(
            $cacheFile,
            json_encode($cacheData, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE),
            LOCK_EX
        );

        $this->cacheStats['writes']++;
    }

    /**
     * 根据播放次数动态获取缓存时间
     * @param int $playCount 视频播放次数
     * @return int 缓存时间(秒)
     */
    private function getCacheTTLByPlayCount($playCount) {
        if ($playCount > 100) {
            return $this->cacheTimes['hot'];
        } elseif ($playCount < 10) {
            return $this->cacheTimes['cold'];
        } else {
            return $this->cacheTimes['normal'];
        }
    }

    /**
     * 清理过期缓存
     * @return int 删除的文件数
     */
    public function cleanExpiredCache() {
        $files = glob($this->cacheDir . '/*.json');
        $now = time();
        $deleted = 0;

        foreach ($files as $file) {
            $content = file_get_contents($file);
            $cached = json_decode($content, true) ?: null;
            
            if ($cached && isset($cached['timestamp'])) {
                // 保守估计，使用最长缓存时间检查
                if ($now - $cached['timestamp'] >= $this->cacheTimes['hot']) {
                    unlink($file);
                    $deleted++;
                }
            } else {
                // 无效缓存文件
                unlink($file);
                $deleted++;
            }
        }

        return $deleted;
    }

    /**
     * 获取缓存统计信息
     */
    public function getStats() {
        $files = glob($this->cacheDir . '/*.json');
        $now = time();
        $valid = 0;
        $expired = 0;

        foreach ($files as $file) {
            $content = file_get_contents($file);
            $cached = json_decode($content, true) ?: null;
            
            if ($cached && isset($cached['timestamp'])) {
                if ($now - $cached['timestamp'] < $this->cacheTimes['hot']) {
                    $valid++;
                } else {
                    $expired++;
                }
            }
        }

        return [
            'total' => count($files),
            'valid' => $valid,
            'expired' => $expired,
            'memory_cache' => count($this->memoryCache),
            'hits' => $this->cacheStats['hits'],
            'misses' => $this->cacheStats['misses'],
            'writes' => $this->cacheStats['writes'],
            'hit_rate' => $this->cacheStats['hits'] + $this->cacheStats['misses'] > 0 
                ? round($this->cacheStats['hits'] / ($this->cacheStats['hits'] + $this->cacheStats['misses']) * 100, 2) 
                : 0
        ];
    }

    private function getCacheFilePath($key) {
        $safeKey = preg_replace('/[^a-zA-Z0-9]/', '_', $key);
        return $this->cacheDir . '/' . $safeKey . '.json';
    }
}

缓存策略解析：

双缓存机制优势：

1. 内存缓存：毫秒级访问，适合高频请求
2. 文件缓存：持久化存储，支持跨请求共享
3. 智能刷新：超过50%生命周期即触发刷新
4. 统计监控：实时掌握缓存命中率

2.3 数据库抽象层

为实现通用性，设计了数据库抽象层，支持多种存储方式。

<?php
/**
 * 数据库抽象层 - 支持多种数据库和存储方式
 */
namespace BilibiliVideoManager;

interface StorageInterface {
    public function save($data);
    public function update($id, $data);
    public function delete($id);
    public function find($id);
    public function findAll($conditions = []);
}

/**
 * MySQL存储实现
 */
class MySQLStorage implements StorageInterface {
    private $pdo;
    private $table;
    
    public function __construct($config, $table = 'videos') {
        $dsn = "mysql:host={$config['host']};dbname={$config['dbname']};charset={$config['charset']}";
        $this->pdo = new \PDO($dsn, $config['user'], $config['password']);
        $this->table = $table;
    }
    
    public function save($data) {
        $fields = implode(', ', array_keys($data));
        $placeholders = ':' . implode(', :', array_keys($data));
        
        $sql = "INSERT INTO {$this->table} ({$fields}) VALUES ({$placeholders})";
        $stmt = $this->pdo->prepare($sql);
        $stmt->execute($data);
        
        return $this->pdo->lastInsertId();
    }
    
    public function update($id, $data) {
        $setParts = [];
        foreach (array_keys($data) as $field) {
            $setParts[] = "{$field} = :{$field}";
        }
        $setClause = implode(', ', $setParts);
        
        $sql = "UPDATE {$this->table} SET {$setClause} WHERE id = :id";
        $data['id'] = $id;
        $stmt = $this->pdo->prepare($sql);
        return $stmt->execute($data);
    }
    
    public function delete($id) {
        $sql = "DELETE FROM {$this->table} WHERE id = :id";
        $stmt = $this->pdo->prepare($sql);
        return $stmt->execute(['id' => $id]);
    }
    
    public function find($id) {
        $sql = "SELECT * FROM {$this->table} WHERE id = :id";
        $stmt = $this->pdo->prepare($sql);
        $stmt->execute(['id' => $id]);
        return $stmt->fetch(\PDO::FETCH_ASSOC);
    }
    
    public function findAll($conditions = []) {
        $sql = "SELECT * FROM {$this->table}";
        $params = [];
        
        if (!empty($conditions)) {
            $whereParts = [];
            foreach ($conditions as $field => $value) {
                $whereParts[] = "{$field} = :{$field}";
                $params[$field] = $value;
            }
            $sql .= " WHERE " . implode(' AND ', $whereParts);
        }
        
        $sql .= " ORDER BY created_at DESC";
        
        $stmt = $this->pdo->prepare($sql);
        $stmt->execute($params);
        return $stmt->fetchAll(\PDO::FETCH_ASSOC);
    }
}

/**
 * SQLite存储实现
 */
class SQLiteStorage implements StorageInterface {
    private $pdo;
    private $table;
    
    public function __construct($dbPath, $table = 'videos') {
        $this->pdo = new \PDO("sqlite:{$dbPath}");
        $this->table = $table;
        $this->initTable();
    }
    
    private function initTable() {
        $sql = "CREATE TABLE IF NOT EXISTS {$this->table} (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            bvid TEXT UNIQUE,
            title TEXT,
            cover TEXT,
            video_url TEXT,
            author TEXT,
            play_count INTEGER DEFAULT 0,
            created_at INTEGER,
            updated_at INTEGER
        )";
        $this->pdo->exec($sql);
    }
    
    // 实现StorageInterface的所有方法...
}

/**
 * JSON文件存储实现
 */
class JsonStorage implements StorageInterface {
    private $filePath;
    private $data = [];
    
    public function __construct($filePath) {
        $this->filePath = $filePath;
        $this->load();
    }
    
    private function load() {
        if (file_exists($this->filePath)) {
            $content = file_get_contents($this->filePath);
            $this->data = json_decode($content, true) ?: [];
        }
    }
    
    private function save() {
        file_put_contents(
            $this->filePath,
            json_encode($this->data, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE)
        );
    }
    
    // 实现StorageInterface的所有方法...
}

2.4 自动刷新机制

当视频链接过期时，系统能够自动检测并刷新，确保用户始终能观看视频。

前端自动检测

/**
 * 通用视频播放器脚本 - 可集成到任何前端页面
 */
class VideoPlayerManager {
    constructor(videoElement, refreshButton) {
        this.video = videoElement;
        this.refreshBtn = refreshButton;
        this.bvid = this.refreshBtn?.dataset.bvid;
        this.cid = this.refreshBtn?.dataset.cid;
        this.apiEndpoint = this.refreshBtn?.dataset.apiEndpoint || '/api/refresh_video.php';
        
        this.init();
    }
    
    init() {
        // 监听播放错误
        if (this.video) {
            this.video.addEventListener('error', () => {
                console.log('视频播放失败，尝试自动刷新...');
                this.refreshVideo();
            });
        }
        
        // 绑定手动刷新按钮
        if (this.refreshBtn) {
            this.refreshBtn.addEventListener('click', (e) => {
                e.preventDefault();
                if (confirm('确定要刷新视频链接吗？')) {
                    this.refreshVideo();
                }
            });
        }
    }
    
    refreshVideo() {
        if (!this.bvid || !this.cid) {
            alert('无法刷新：缺少视频标识');
            return;
        }
        
        // 显示加载状态
        const originalText = this.refreshBtn.innerHTML;
        this.refreshBtn.innerHTML = '<span class="spinner"></span>刷新中...';
        this.refreshBtn.disabled = true;
        
        // 发送刷新请求
        fetch(this.apiEndpoint, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/x-www-form-urlencoded',
            },
            body: `bvid=${encodeURIComponent(this.bvid)}&cid=${this.cid}`
        })
        .then(response => response.json())
        .then(data => {
            if (data.success) {
                // 刷新成功，重新加载页面或更新视频源
                if (this.video) {
                    this.video.src = data.new_url;
                    this.video.load();
                    this.video.play();
                }
                this.showToast('视频链接刷新成功', 'success');
            } else {
                this.showToast('刷新失败：' + data.message, 'error');
            }
        })
        .catch(error => {
            console.error('刷新失败:', error);
            this.showToast('刷新失败：网络错误', 'error');
        })
        .finally(() => {
            this.refreshBtn.innerHTML = originalText;
            this.refreshBtn.disabled = false;
        });
    }
    
    showToast(message, type) {
        // 简单的提示实现
        const toast = document.createElement('div');
        toast.className = `toast toast-${type}`;
        toast.textContent = message;
        toast.style.cssText = `
            position: fixed;
            top: 20px;
            right: 20px;
            padding: 12px 24px;
            background: ${type === 'success' ? '#4caf50' : '#f44336'};
            color: white;
            border-radius: 4px;
            z-index: 9999;
        `;
        document.body.appendChild(toast);
        setTimeout(() => toast.remove(), 3000);
    }
}

// 初始化
document.addEventListener('DOMContentLoaded', function() {
    const video = document.getElementById('video-player');
    const refreshBtn = document.querySelector('.refresh-video-btn');
    
    if (video || refreshBtn) {
        new VideoPlayerManager(video, refreshBtn);
    }
});

后端刷新API

<?php
/**
 * 通用视频刷新API - 独立于任何CMS
 */
header('Content-Type: application/json');

// 引入核心类
require_once dirname(__DIR__) . '/class/BilibiliParser.php';
require_once dirname(__DIR__) . '/class/VideoCache.php';
require_once dirname(__DIR__) . '/class/Logger.php';

use BilibiliVideoManager\BilibiliParser;
use BilibiliVideoManager\VideoCache;
use BilibiliVideoManager\Logger;

// 初始化核心组件
$parser = new BilibiliParser();
$cache = new VideoCache();
$logger = new Logger();

// 处理请求
if ($_SERVER['REQUEST_METHOD'] !== 'POST') {
    echo json_encode(['success' => false, 'message' => '无效的请求方法']);
    exit;
}

$bvid = trim($_POST['bvid'] ?? '');
$cid = intval($_POST['cid'] ?? 0);

if (empty($bvid) || $cid <= 0) {
    echo json_encode(['success' => false, 'message' => '参数不完整']);
    exit;
}

try {
    $logger->info("开始刷新视频: BV号={$bvid}, 文章ID={$cid}");
    
    // 1. 获取视频信息
    $videoInfo = $parser->getVideoInfo($bvid);
    if (!$videoInfo['success']) {
        throw new Exception($videoInfo['message']);
    }
    
    // 2. 清除旧缓存
    $cache->delete($bvid);
    
    // 3. 获取新链接
    $playCount = $videoInfo['data']['view'] ?? 0;
    $videoUrlResult = $parser->getVideoUrl($bvid, $cid, 80, false, $playCount);
    
    if (!$videoUrlResult['success']) {
        throw new Exception($videoUrlResult['message']);
    }
    
    $newVideoUrl = $videoUrlResult['data']['url'];
    
    // 4. 这里可以插入数据库更新逻辑
    // $storage->update($cid, ['video_url' => $newVideoUrl]);
    
    $logger->info("视频刷新成功: {$bvid}");
    
    echo json_encode([
        'success' => true,
        'message' => '视频链接刷新成功',
        'bvid' => $bvid,
        'cid' => $cid,
        'new_url' => $newVideoUrl
    ]);
    
} catch (Exception $e) {
    $logger->error("刷新失败: " . $e->getMessage());
    echo json_encode([
        'success' => false,
        'message' => '刷新失败: ' . $e->getMessage()
    ]);
}

2.5 批量操作功能

系统支持批量刷新缓存、批量删除等操作，适合定时任务或后台管理。

<?php
/**
 * 批量更新缓存 - 适合定时任务
 */
class BatchUpdateManager {
    private $parser;
    private $cache;
    private $storage;
    private $logger;
    
    public function __construct($storage) {
        $this->parser = new BilibiliParser();
        $this->cache = new VideoCache();
        $this->storage = $storage;
        $this->logger = new Logger();
    }
    
    /**
     * 更新所有视频缓存
     */
    public function updateAll() {
        $videos = $this->storage->findAll();
        $results = [
            'total' => count($videos),
            'success' => 0,
            'failed' => 0,
            'errors' => []
        ];
        
        foreach ($videos as $video) {
            try {
                $bvid = $video['bvid'];
                $cid = $video['cid'] ?? 0;
                
                // 清除旧缓存
                $this->cache->delete($bvid);
                
                // 获取新链接
                $videoInfo = $this->parser->getVideoInfo($bvid);
                if (!$videoInfo['success']) {
                    throw new Exception($videoInfo['message']);
                }
                
                $playCount = $videoInfo['data']['view'] ?? 0;
                $videoUrlResult = $this->parser->getVideoUrl(
                    $bvid, 
                    $videoInfo['data']['cid'], 
                    80, 
                    false, 
                    $playCount
                );
                
                if (!$videoUrlResult['success']) {
                    throw new Exception($videoUrlResult['message']);
                }
                
                // 更新数据库
                $this->storage->update($video['id'], [
                    'video_url' => $videoUrlResult['data']['url'],
                    'updated_at' => time()
                ]);
                
                $results['success']++;
                $this->logger->info("批量更新成功: {$bvid}");
                
            } catch (Exception $e) {
                $results['failed']++;
                $results['errors'][] = [
                    'bvid' => $video['bvid'],
                    'error' => $e->getMessage()
                ];
                $this->logger->error("批量更新失败: {$video['bvid']} - " . $e->getMessage());
            }
        }
        
        return $results;
    }
    
    /**
     * 按分类更新
     */
    public function updateByCategory($categoryId) {
        $videos = $this->storage->findAll(['category_id' => $categoryId]);
        // ... 更新逻辑
    }
}

// 使用示例 - 定时任务脚本
$storage = new MySQLStorage($dbConfig);
$batchManager = new BatchUpdateManager($storage);
$result = $batchManager->updateAll();

echo "更新完成：成功 {$result['success']}，失败 {$result['failed']}\n";

三、创新点与技术亮点

3.1 基于热度的动态缓存

传统的缓存方案通常采用固定时间，要么缓存时间过长导致链接过期，要么过短增加API调用。本方案根据视频播放量动态调整缓存时间：

热门视频(>100播放)  → 24小时缓存
普通视频(10-100)    → 6小时缓存  
冷门视频(<10)       → 1小时缓存

数学表达：

CacheTTL(playCount) = {
    86400, if playCount > 100
    21600, if 10 ≤ playCount ≤ 100
    3600,  if playCount < 10
}

3.2 智能刷新阈值

缓存超过一半时间即标记为"需要刷新"，当用户访问时自动获取新链接：

'needs_refresh' => $cacheAge >= $cacheTTL * 0.5

这个50%阈值是经验值，可根据实际需求调整：

• 调低阈值（如30%）：链接更新更及时，但API调用增加
• 调高阈值（如70%）：减少API调用，但链接过期风险增加

3.3 双缓存加速架构

请求视频链接
    ↓
内存缓存(5ms) → 命中 → 返回
    ↓ 未命中
文件缓存(50ms) → 命中 → 更新内存缓存 → 返回
    ↓ 未命中
B站API(500ms) → 写入双缓存 → 返回

3.4 错误自动恢复

当视频播放失败时，系统自动触发刷新流程，无需用户手动操作：

videoPlayer.addEventListener('error', () => {
    // 自动刷新链接
    refreshVideoLink(bvid, cid);
});

3.5 通用集成设计

核心类完全独立，不依赖任何框架，通过接口适配不同系统：

// 自定义系统集成示例
class MySystemIntegration {
    private $parser;
    private $storage;
    
    public function __construct() {
        $this->parser = new BilibiliParser();
        // 适配自有数据库
        $this->storage = new MySQLStorage([
            'host' => 'localhost',
            'dbname' => 'myapp',
            'user' => 'user',
            'password' => 'pass'
        ]);
    }
    
    public function publishVideo($bvid, $category) {
        // 解析视频
        $videoInfo = $this->parser->parseUrl("https://bilibili.com/video/{$bvid}");
        
        // 保存到自有数据库
        $id = $this->storage->save([
            'bvid' => $videoInfo['data']['bvid'],
            'title' => $videoInfo['data']['title'],
            'video_url' => $videoInfo['data']['video_url'],
            'cover' => $videoInfo['data']['pic'],
            'category' => $category,
            'created_at' => time()
        ]);
        
        return ['success' => true, 'id' => $id];
    }
}

四、性能测试与对比

4.1 缓存命中率测试

在100个视频、1000次访问的测试环境中：

4.2 链接有效性对比

测试10个视频，跟踪24小时：

4.3 服务器负担分析

五、集成指南

5.1 快速开始

<?php
// 1. 引入核心类
require_once 'class/BilibiliParser.php';
require_once 'class/VideoCache.php';

use BilibiliVideoManager\BilibiliParser;

// 2. 初始化解析器
$parser = new BilibiliParser();

// 3. 解析视频
$result = $parser->parseUrl('https://www.bilibili.com/video/BV1xx411c7mK');

if ($result['success']) {
    $video = $result['data'];
    echo "标题: " . $video['title'] . "\n";
    echo "作者: " . $video['author'] . "\n";
    echo "视频地址: " . $video['video_url'] . "\n";
} else {
    echo "解析失败: " . $result['message'];
}

5.2 前端集成

<!DOCTYPE html>
<html>
<head>
    <title>视频播放</title>
    <style>
        .video-container { max-width: 800px; margin: 0 auto; }
        video { width: 100%; }
        .refresh-btn { 
            padding: 10px 20px; 
            background: #00a1d6; 
            color: white; 
            border: none; 
            border-radius: 4px;
            cursor: pointer;
            margin-top: 10px;
        }
        .refresh-btn:hover { background: #00b5e5; }
    </style>
</head>
<body>
    <div class="video-container">
        <video id="video-player" controls>
            <source src="<?php echo $videoUrl; ?>" type="video/mp4">
        </video>
        
        <button class="refresh-btn refresh-video-btn" 
                data-bvid="<?php echo $bvid; ?>" 
                data-cid="<?php echo $cid; ?>"
                data-api-endpoint="/api/refresh_video.php">
            🔄 刷新视频链接
        </button>
    </div>
    
    <script src="js/video-player.js"></script>
</body>
</html>

5.3 WordPress集成示例

<?php
/**
 * WordPress插件示例
 */
class BilibiliVideoPlugin {
    
    public function __construct() {
        add_shortcode('bilibili', [$this, 'handleShortcode']);
        add_action('wp_ajax_refresh_bilibili_video', [$this, 'ajaxRefreshVideo']);
        add_action('wp_ajax_nopriv_refresh_bilibili_video', [$this, 'ajaxRefreshVideo']);
    }
    
    /**
     * 短代码处理
     * [bilibili bvid="BV1xx411c7mK"]
     */
    public function handleShortcode($atts) {
        $bvid = $atts['bvid'] ?? '';
        
        // 解析视频
        require_once WP_CONTENT_DIR . '/bilibili-video-manager/class/BilibiliParser.php';
        $parser = new BilibiliVideoManager\BilibiliParser();
        $result = $parser->parseUrl('https://bilibili.com/video/' . $bvid);
        
        if (!$result['success']) {
            return '<p>视频加载失败</p>';
        }
        
        $video = $result['data'];
        
        // 保存到WordPress自定义字段
        global $post;
        update_post_meta($post->ID, '_bilibili_bvid', $bvid);
        update_post_meta($post->ID, '_bilibili_video_url', $video['video_url']);
        
        // 输出播放器
        return $this->renderPlayer($video);
    }
    
    private function renderPlayer($video) {
        ob_start();
        ?>
        <div class="bilibili-video-player">
            <video controls style="width:100%">
                <source src="<?php echo esc_url($video['video_url']); ?>" type="video/mp4">
            </video>
            <button class="refresh-video-btn" 
                    data-bvid="<?php echo esc_attr($video['bvid']); ?>"
                    data-cid="<?php echo esc_attr(get_the_ID()); ?>">
                刷新链接
            </button>
        </div>
        <script>
        // 引入视频播放器脚本
        </script>
        <?php
        return ob_get_clean();
    }
}

5.4 Laravel集成示例

<?php
namespace App\Http\Controllers;

use Illuminate\Http\Request;
use BilibiliVideoManager\BilibiliParser;

class VideoController extends Controller
{
    private $parser;
    
    public function __construct()
    {
        $this->parser = new BilibiliParser(storage_path('bilibili-cache'));
    }
    
    /**
     * 解析B站视频
     */
    public function parse(Request $request)
    {
        $url = $request->input('url');
        $result = $this->parser->parseUrl($url);
        
        if (!$result['success']) {
            return response()->json([
                'success' => false,
                'message' => $result['message']
            ], 400);
        }
        
        // 保存到数据库
        $video = Video::create([
            'bvid' => $result['data']['bvid'],
            'title' => $result['data']['title'],
            'video_url' => $result['data']['video_url'],
            'cover' => $result['data']['pic'],
            'author' => $result['data']['author']
        ]);
        
        return response()->json([
            'success' => true,
            'data' => $video
        ]);
    }
    
    /**
     * 刷新视频链接
     */
    public function refresh(Request $request)
    {
        $bvid = $request->input('bvid');
        $cid = $request->input('cid');
        
        // 获取视频信息
        $videoInfo = $this->parser->getVideoInfo($bvid);
        
        if (!$videoInfo['success']) {
            return response()->json([
                'success' => false,
                'message' => $videoInfo['message']
            ], 400);
        }
        
        // 获取新链接
        $playCount = $videoInfo['data']['view'] ?? 0;
        $videoUrl = $this->parser->getVideoUrl(
            $bvid, 
            $videoInfo['data']['cid'], 
            80, 
            false, 
            $playCount
        );
        
        if (!$videoUrl['success']) {
            return response()->json([
                'success' => false,
                'message' => $videoUrl['message']
            ], 400);
        }
        
        // 更新数据库
        $video = Video::where('bvid', $bvid)->first();
        if ($video) {
            $video->video_url = $videoUrl['data']['url'];
            $video->save();
        }
        
        return response()->json([
            'success' => true,
            'new_url' => $videoUrl['data']['url']
        ]);
    }
}

六、配置与优化

6.1 配置文件

{
    "api": {
        "video_info": "https://api.bilibili.com/x/web-interface/view",
        "play_url": "https://api.bilibili.com/x/player/playurl"
    },
    "cache": {
        "hot_threshold": 100,
        "cold_threshold": 10,
        "hot_ttl": 86400,
        "normal_ttl": 21600,
        "cold_ttl": 3600,
        "memory_ttl": 300,
        "refresh_ratio": 0.5
    },
    "request": {
        "max_retries": 3,
        "retry_delay": 1,
        "timeout": 30,
        "user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
    },
    "cdn": {
        "enabled": true,
        "replace_patterns": {
            "upos-sz-estgoss": "upos-sz-mirrorcos"
        }
    }
}

6.2 性能优化建议

1. 缓存目录优化

   // 使用更快的存储介质
   $cache = new VideoCache('/dev/shm/bilibili-cache'); // Linux内存文件系统

2. 批量更新定时任务

3. 3 * php /path/to/batch_update.php >> /var/log/bilibili-update.log

4. 监控告警

   // 命中率监控
   $stats = $cache->getStats();
   if ($stats['hit_rate'] < 50) {
    // 发送告警，缓存命中率过低
    notifyAdmin("缓存命中率异常: {$stats['hit_rate']}%");
   }

七、总结与展望

7.1 方案优势

1. 完全通用：不依赖任何CMS，可集成到任意PHP项目
2. 智能缓存：基于热度的动态缓存策略，平衡性能与时效性
3. 自动恢复：播放失败自动刷新，提升用户体验
4. 高性能：双缓存架构，毫秒级响应
5. 可扩展：模块化设计，易于定制和扩展

7.2 应用场景

• 个人博客：集成视频内容
• 内容管理系统：WordPress、Typecho、Drupal插件
• 视频网站：自建视频聚合平台
• 企业内网：培训视频管理
• 知识库系统：视频教程集成

7.3 未来优化方向

1. 多平台支持：扩展支持YouTube、腾讯视频等
2. 视频转码：集成FFmpeg进行格式转换
3. 分布式缓存：支持Redis/Memcached
4. 统计分析：视频播放数据可视化
5. API限流：智能控制请求频率

结语

本文介绍的B站视频管理工具，通过智能缓存策略和自动刷新机制，有效解决了视频链接时效性的问题。更重要的是，这套方案设计为完全通用，可以无缝集成到任何PHP项目中，无论是个人博客、企业系统还是大型平台。

核心代码已开源，欢迎使用和贡献：